Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:19 2007

Asterisk developer's documentation :: Codename Pineapple

---

chan_sip3.c File Reference

---

Detailed Description

Implementation of Session Initiation Protocol Version 3 of chan_sip.

Author:

Mark Spencer <markster@digium.com>

Olle E. Johansson <oej@edvina.net> (all the chan_sip3 changes)

See Also:

• CREDITS

Implementation of RFC 3261 - without S/MIME, TCP and TLS support Configuration file sip.conf

Todo:

SIP over TCP

SIP over TLS

Better support of forking

VIA branch tag transaction checking

Transaction support

Definition in file chan_sip3.c.

#include "asterisk.h"
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <netdb.h>
#include <signal.h>
#include <sys/signal.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <regex.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp.h"
#include "asterisk/udptl.h"
#include "asterisk/acl.h"
#include "asterisk/manager.h"
#include "asterisk/translate.h"
#include "asterisk/callerid.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/dsp.h"
#include "asterisk/features.h"
#include "asterisk/srv.h"
#include "asterisk/astdb.h"
#include "asterisk/causes.h"
#include "asterisk/utils.h"
#include "asterisk/file.h"
#include "asterisk/astobj.h"
#include "asterisk/dnsmgr.h"
#include "asterisk/devicestate.h"
#include "asterisk/linkedlists.h"
#include "asterisk/stringfields.h"
#include "asterisk/monitor.h"
#include "asterisk/localtime.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/compiler.h"
#include "sip3/sip3.h"
#include "sip3/sip3funcs.h"

Include dependency graph for chan_sip3.c:

Go to the source code of this file.

Defines
#define	CHAN_SIP3_MAIN
#define	GNURK
#define	SIPLABEL   sip3
Functions
GNURK int	add_t38_sdp (struct sip_request *resp, struct sip_dialog *p)
	Add T.38 Session Description Protocol message.
static int	add_vidupdate (struct sip_request *req)
	AST_MODULE_INFO (ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT,"Session Initiation Protocol, chan_sip3 version (SIP)",.load=load_module,.unload=unload_module,.reload=reload,)
	AST_MUTEX_DEFINE_STATIC (sip_reload_lock)
	Make sure we don't reload twice at the same time.
GNURK void	ast_quiet_chan (struct ast_channel *chan)
	Turn off generator data XXX Does this function belong in the SIP channel?
static int	auto_congest (void *nothing)
	Scheduled congestion on a call.
static void	build_route (struct sip_dialog *p, struct sip_request *req, int backwards)
	Build route list from Record-Route header.
static int	cb_extensionstate (char *context, char *exten, int state, void *data)
	Callback for the devicestate notification (SUBSCRIBE) support subsystem.
static void	check_pendings (struct sip_dialog *p)
	Check pending actions on SIP call.
static int	check_user (struct sip_dialog *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin)
	Find user If we get a match, this will add a reference pointer to the user object in ASTOBJ, that needs to be unreferenced.
static enum check_auth_result	check_user_full (struct sip_dialog *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin, struct sip_device **authpeer)
	Check if matching user or peer is defined Match user on From: user name and peer on IP/port This is used on first invite (not re-invites) and subscribe requests.
static void	check_via (struct sip_dialog *p, struct sip_request *req)
	check Via: header for hostname, port and rport request/answer
GNURK int	create_addr (struct sip_dialog *dialog, const char *username, char *domain, const char *device)
	create address structure from peer name Or, if peer not found, find it in the global DNS returns TRUE (-1) on failure, FALSE on success
static int	create_addr_from_peer (struct sip_dialog *dialog, struct sip_device *device)
	Create address structure from device reference. return -1 on error, 0 on success.
GNURK void	do_setnat (struct sip_dialog *dialog, int natflags)
	Set nat mode on the various media streams.
void	free_old_route (struct sip_route *route)
	Remove route from route list.
static int	func_header_read (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
	Read SIP header (dialplan function).
static int	function_sipchaninfo_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	${SIPCHANINFO()} Dialplan function - reads sip channel data
static int	function_sippeer (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	${SIPPEER()} Dialplan function - reads peer data
static int	get_also_info (struct sip_dialog *p, struct sip_request *oreq)
	Call transfer support (old way, deprecated by the IETF)--.
static int	get_msg_text (char *buf, int len, struct sip_request *req)
	Get text out of a SIP MESSAGE packet.
GNURK struct sip_dialog *	get_sip_dialog_byid_locked (const char *callid, const char *totag, const char *fromtag)
	Lock dialog list lock and find matching pvt lock Their tag is fromtag, our tag is to-tag This means that in some transactions, totag needs to be their tag :-) depending upon the direction.
static int	handle_invite_replaces (struct sip_dialog *p, struct sip_request *req, int debug, struct sockaddr_in *sin)
	Handle the transfer part of INVITE with a replaces: header, meaning a target pickup or an attended transfer.
GNURK int	handle_request (struct sip_dialog *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock)
	Handle incoming SIP requests (methods).
static int	handle_request_bye (struct sip_dialog *p, struct sip_request *req)
	Handle incoming BYE request.
static int	handle_request_cancel (struct sip_dialog *p, struct sip_request *req)
	Handle incoming CANCEL request.
static void	handle_request_info (struct sip_dialog *p, struct sip_request *req)
	Receive SIP INFO Message.
static int	handle_request_invite (struct sip_dialog *p, struct sip_request *req, int debug, struct sockaddr_in *sin, int *recount, char *e)
	Handle incoming INVITE request.
static int	handle_request_message (struct sip_dialog *p, struct sip_request *req)
	Handle incoming MESSAGE request.
static int	handle_request_notify (struct sip_dialog *p, struct sip_request *req, struct sockaddr_in *sin, char *e)
	Handle incoming notifications.
static int	handle_request_options (struct sip_dialog *p, struct sip_request *req)
	Handle incoming OPTIONS request.
static int	handle_request_register (struct sip_dialog *p, struct sip_request *req, struct sockaddr_in *sin, char *e)
	Handle incoming REGISTER request.
static int	handle_request_subscribe (struct sip_dialog *p, struct sip_request *req, struct sockaddr_in *sin, char *e)
	Handle incoming SUBSCRIBE request.
static void	handle_response (struct sip_dialog *p, int resp, char *rest, struct sip_request *req)
	Handle SIP response in dialogue.
static void	handle_response_answer (struct sip_dialog *dialog, struct sip_request *req, int outgoing, int reinvite)
	Handle a positive response to an INVITE - 200 OK.
static void	handle_response_bye (struct sip_dialog *dialog, int resp, char *rest, struct sip_request *req)
static void	handle_response_invite (struct sip_dialog *p, int resp, char *rest, struct sip_request *req)
	Handle SIP response to INVITE dialogue.
static void	handle_response_message (struct sip_dialog *dialog, int resp, char *rest, struct sip_request *req)
static void	handle_response_notify (struct sip_dialog *dialog, int resp, char *rest, struct sip_request *req)
static void	handle_response_refer (struct sip_dialog *p, int resp, char *rest, struct sip_request *req)
static void	list_route (struct sip_route *route)
	List all routes - mostly for debugging.
static int	load_module (void)
	load_module: PBX load module - initialization
static int	parse_ok_contact (struct sip_dialog *pvt, struct sip_request *req)
	Save contact header for 200 OK on INVITE.
static enum parse_register_result	parse_register_contact (struct sip_dialog *pvt, struct sip_device *peer, struct sip_request *req)
	Parse contact header and save registration (peer registration).
static void	receive_message (struct sip_dialog *p, struct sip_request *req)
	Receive SIP MESSAGE method messages.
static enum check_auth_result	register_verify (struct sip_dialog *p, struct sockaddr_in *sin, struct sip_request *req, char *uri)
	Verify registration of user Registration is done in several steps, first a REGISTER without auth to get a challenge (nonce) then a second one with auth Registration requests are only matched with peers that are marked as "dynamic".
static int	reload (void)
	reload: Part of Asterisk module interface
static int	set_address_from_contact (struct sip_dialog *pvt)
	Change the other partys IP address based on given contact.
static int	sip_addheader (struct ast_channel *chan, void *data)
	Add a SIP header to an outbound INVITE.
static int	sip_answer (struct ast_channel *ast)
	sip_answer: Answer SIP call , send 200 OK on Invite Part of PBX interface
static int	sip_call (struct ast_channel *ast, char *dest, int timeout)
	Initiate SIP call from PBX used from the dial() application.
GNURK int	sip_debug_test_pvt (struct sip_dialog *p)
	Test PVT for debugging output.
static int	sip_devicestate (void *data)
	Part of PBX channel interface.
GNURK int	sip_do_reload ()
	Reload module.
static int	sip_dtmfmode (struct ast_channel *chan, void *data)
	Set the DTMFmode for an outbound SIP call (application).
GNURK void	sip_dump_history (struct sip_dialog *dialog)
	Dump SIP history to debug log file at end of lifespan for SIP dialog.
static int	sip_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
	sip_fixup: Fix up a channel: If a channel is consumed, this is called. Basically update any ->owner links :: PBX interface
static int	sip_handle_t38_reinvite (struct ast_channel *chan, struct sip_dialog *pvt, int reinvite)
static int	sip_hangup (struct ast_channel *ast)
	sip_hangup: Hangup SIP call Part of PBX interface, called from ast_hangup
static int	sip_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
	Play indication to user :: PBX interface With SIP a lot of indications is sent as messages, letting the device play the indication - busy signal, congestion etc.
static struct ast_channel *	sip_new (struct sip_dialog *dialog, int state, const char *title)
	Initiate a call in the SIP channel :: PBX interface.
GNURK int	sip_notify (int fd, int argc, char *argv[])
	Cli command to send SIP notify to peer.
GNURK void	sip_peer_hold (struct sip_dialog *p, int hold)
	Change onhold state of a peer using a pvt structure.
GNURK int	sip_prune_realtime (int fd, int argc, char *argv[])
	Remove temporary realtime objects from memory (CLI).
GNURK int	sip_reload (int fd)
	Force reload of module from cli.
int	sip_reload_check ()
static struct ast_channel *	sip_request_call (const char *type, int format, void *data, int *cause)
GNURK int	sip_send_mwi_to_peer (struct sip_device *peer)
	Send message waiting indication to alert peer that they've got voicemail.
static int	sip_senddigit_begin (struct ast_channel *ast, char digit)
	Start sending DTMF character on SIP channel within one call, we're able to transmit in many methods simultaneously.
static int	sip_senddigit_end (struct ast_channel *ast, char digit, unsigned int duration)
	Send DTMF character on SIP channel within one call, we're able to transmit in many methods simultaneously.
static int	sip_sendtext (struct ast_channel *ast, const char *text)
	Send SIP MESSAGE text within a call Called from PBX core sendtext() application.
static int	sip_sipredirect (struct sip_dialog *p, const char *dest)
	Transfer call before connect with a 302 redirect.
static int	sip_transfer (struct ast_channel *ast, const char *dest)
	Transfer SIP call :: PBX interface.
static int	sip_write (struct ast_channel *ast, struct ast_frame *frame)
	Send frame to media channel (rtp) :: PBX interface.
static int	t38_get_rate (int t38cap)
	Get Max T.38 Transmission rate from T38 capabilities.
static char *	terminate_uri (char *uri)
GNURK void	try_suggested_sip_codec (struct sip_dialog *p)
	Try setting codec suggested by the SIP_CODEC channel variable.
static int	unload_module (void)
GNURK int	update_call_counter (struct sip_dialog *fup, int event)
	update_call_counter: Handle call_limit for SIP users Setting a call-limit will cause calls above the limit not to be accepted.
static int	write_media_frame (struct ast_channel *ast, struct sip_dialog *p, struct ast_frame *frame, struct ast_rtp *mediartp)
Variables
static char *	app_dtmfmode = "SIPDtmfMode"
static char *	app_sipaddheader = "SIPAddHeader"
static char *	descrip_dtmfmode = "SIPDtmfMode(inband|info|rfc2833): Changes the dtmfmode for a SIP call\n"
static char *	descrip_sipaddheader
sip_dialog *	dialoglist = NULL
expiry_times	expiry
	various expiry times for registrations
sip_globals	global
	Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical.
io_context *	io
ast_config *	notify_types
sched_context *	sched
static struct ast_custom_function	sip_header_function
static int	sip_reloading = FALSE
static enum channelreloadreason	sip_reloadreason
static const struct ast_channel_tech	sip_tech
	Definition of this channel for PBX channel registration.
static const struct ast_channel_tech	sip_tech_info
	This version of the sip channel tech has no send_digit_begin callback. This is for use with channels using SIP INFO DTMF so that the core knows that the channel doesn't want DTMF BEGIN frames.
static struct ast_custom_function	sipchaninfo_function
	Structure to declare a dialplan function: SIPCHANINFO.
channel_counters	sipcounters = { 0, 0, 0, 0, 0, 0, 0, 0}
ast_custom_function	sippeer_function
	Structure to declare a dialplan function: SIPPEER.
static char *	synopsis_dtmfmode = "Change the dtmfmode for a SIP call"
static char *	synopsis_sipaddheader = "Add a SIP header to the outbound call"

---

Define Documentation

#define CHAN_SIP3_MAIN

Definition at line 406 of file chan_sip3.c.

#define GNURK

Definition at line 410 of file chan_sip3.c.

#define SIPLABEL   sip3

Definition at line 473 of file chan_sip3.c.

---

Function Documentation

GNURK int add_t38_sdp (  struct sip_request *  resp, struct sip_dialog *  p )

Add T.38 Session Description Protocol message. Definition at line 1749 of file chan_sip3.c. References add_header(), add_header_contentLength(), add_line(), ast_build_string(), ast_inet_ntoa(), ast_log(), ast_udptl_get_local_max_datagram(), ast_udptl_get_us(), t38properties::capability, debug(), t38properties::jointcapability, sip_dialog::lastrtprx, sip_dialog::lastrtptx, len, LOG_DEBUG, LOG_WARNING, sip_dialog::ourip, t38properties::peercapability, s, sip_dialog::sessionid, sip_dialog::sessionversion, sip_debug_test_pvt(), sip_dialog::t38, t38_get_rate(), T38FAX_FILL_BIT_REMOVAL, T38FAX_RATE_MANAGEMENT_LOCAL_TCF, T38FAX_TRANSCODING_JBIG, T38FAX_TRANSCODING_MMR, T38FAX_UDP_EC_NONE, T38FAX_UDP_EC_REDUNDANCY, T38FAX_VERSION, T38FAX_VERSION_0, T38FAX_VERSION_1, sip_dialog::udptl, and sip_dialog::udptlredirip. { int len = 0; int x = 0; struct sockaddr_in udptlsin; char v[256] = ""; char s[256] = ""; char o[256] = ""; char c[256] = ""; char t[256] = ""; char m_modem[256]; char a_modem[1024]; char *m_modem_next = m_modem; size_t m_modem_left = sizeof(m_modem); char *a_modem_next = a_modem; size_t a_modem_left = sizeof(a_modem); struct sockaddr_in udptldest = { 0, }; int debug; debug = sip_debug_test_pvt(p); len = 0; if (!p->udptl) { ast_log(LOG_WARNING, "No way to add SDP without an UDPTL structure\n"); return -1; } if (!p->sessionid) { p->sessionid = getpid(); p->sessionversion = p->sessionid; } else p->sessionversion++; /* Our T.38 end is */ ast_udptl_get_us(p->udptl, &udptlsin); /* Determine T.38 UDPTL destination */ if (p->udptlredirip.sin_addr.s_addr) { udptldest.sin_port = p->udptlredirip.sin_port; udptldest.sin_addr = p->udptlredirip.sin_addr; } else { udptldest.sin_addr = p->ourip; udptldest.sin_port = udptlsin.sin_port; } if (debug) ast_log(LOG_DEBUG, "T.38 UDPTL is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(udptlsin.sin_port)); /* We break with the "recommendation" and send our IP, in order that our peer doesn't have to ast_gethostbyname() us */ if (debug) { ast_log(LOG_DEBUG, "Our T38 capability (%d), peer T38 capability (%d), joint capability (%d)\n", p->t38.capability, p->t38.peercapability, p->t38.jointcapability); } snprintf(v, sizeof(v), "v=0\r\n"); snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, ast_inet_ntoa(udptldest.sin_addr)); snprintf(s, sizeof(s), "s=session\r\n"); snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(udptldest.sin_addr)); snprintf(t, sizeof(t), "t=0 0\r\n"); ast_build_string(&m_modem_next, &m_modem_left, "m=image %d udptl t38\r\n", ntohs(udptldest.sin_port)); if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_0) ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:0\r\n"); if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_1) ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:1\r\n"); if ((x = t38_get_rate(p->t38.jointcapability))) ast_build_string(&a_modem_next, &a_modem_left, "a=T38MaxBitRate:%d\r\n",x); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxFillBitRemoval:%d\r\n", (p->t38.jointcapability & T38FAX_FILL_BIT_REMOVAL) ? 1 : 0); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingMMR:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_MMR) ? 1 : 0); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingJBIG:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_JBIG) ? 1 : 0); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxRateManagement:%s\r\n", (p->t38.jointcapability & T38FAX_RATE_MANAGEMENT_LOCAL_TCF) ? "localTCF" : "transferredTCF"); x = ast_udptl_get_local_max_datagram(p->udptl); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxBuffer:%d\r\n",x); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxDatagram:%d\r\n",x); if (p->t38.jointcapability != T38FAX_UDP_EC_NONE) ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxUdpEC:%s\r\n", (p->t38.jointcapability & T38FAX_UDP_EC_REDUNDANCY) ? "t38UDPRedundancy" : "t38UDPFEC"); len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m_modem) + strlen(a_modem); add_header(resp, "Content-Type", "application/sdp"); add_header_contentLength(resp, len); add_line(resp, v); add_line(resp, o); add_line(resp, s); add_line(resp, c); add_line(resp, t); add_line(resp, m_modem); add_line(resp, a_modem); /* Update lastrtprx when we send our SDP */ p->lastrtprx = p->lastrtptx = time(NULL); return 0; }

static int add_vidupdate (  struct sip_request *  req  )  [static]

AST_MODULE_INFO (  ASTERISK_GPL_KEY  , AST_MODFLAG_DEFAULT  , "Session Initiation   Protocol, chan_sip3 version(SIP)"  , .  load = load_module, .  unload = unload_module, .  reload = reload )

AST_MUTEX_DEFINE_STATIC (  sip_reload_lock   )

Make sure we don't reload twice at the same time.

GNURK void ast_quiet_chan (  struct ast_channel *  chan  )

Turn off generator data XXX Does this function belong in the SIP channel? Definition at line 4034 of file chan_sip3.c. References ast_channel::_state, ast_deactivate_generator(), AST_STATE_UP, and ast_channel::generatordata. { if (chan && chan->_state == AST_STATE_UP) { if (chan->generatordata) ast_deactivate_generator(chan); } }

static int auto_congest (  void *  nothing  )  [static]

Scheduled congestion on a call. Definition at line 881 of file chan_sip3.c. References append_history, ast_channel_trylock, ast_channel_unlock, AST_CONTROL_CONGESTION, ast_log(), ast_queue_control(), dialog_lock(), FALSE, sip_dialog::initid, LOG_NOTICE, sip_dialog::owner, and TRUE. { struct sip_dialog *dialog = nothing; dialog_lock(dialog, TRUE); dialog->initid = -1; if (dialog->owner) { /* XXX fails on possible deadlock */ if (!ast_channel_trylock(dialog->owner)) { ast_log(LOG_NOTICE, "Auto-congesting %s\n", dialog->owner->name); append_history(dialog, "Cong", "Auto-congesting (timer)"); ast_queue_control(dialog->owner, AST_CONTROL_CONGESTION); ast_channel_unlock(dialog->owner); } } dialog_lock(dialog, FALSE); return 0; }

static void build_route (  struct sip_dialog *  p, struct sip_request *  req, int  backwards )  [static]

Build route list from Record-Route header. Definition at line 2107 of file chan_sip3.c. References __get_header(), ast_log(), ast_malloc, free_old_route(), sip_route::hop, len, LOG_DEBUG, sip_route::next, option_debug, sip_dialog::route, and sip_dialog::route_persistant. { struct sip_route *thishop, *head, *tail; int start = 0; int len; const char *rr, *contact, *c; /* Once a persistant route is set, don't fool with it */ if (p->route && p->route_persistant) { if (option_debug) ast_log(LOG_DEBUG, "build_route: Retaining previous route: <%s>\n", p->route->hop); return; } if (p->route) { free_old_route(p->route); p->route = NULL; } p->route_persistant = backwards; /* Build a tailq, then assign it to p->route when done. * If backwards, we add entries from the head so they end up * in reverse order. However, we do need to maintain a correct * tail pointer because the contact is always at the end. */ head = NULL; tail = head; /* 1st we pass through all the hops in any Record-Route headers */ for (;;) { /* Each Record-Route header */ rr = __get_header(req, "Record-Route", &start); if (*rr == '\0') break; for (; (rr = strchr(rr, '<')) ; rr += len) { /* Each route entry */ ++rr; len = strcspn(rr, ">") + 1; /* Make a struct route */ if ((thishop = ast_malloc(sizeof(*thishop) + len))) { /* ast_calloc is not needed because all fields are initialized in this block */ ast_copy_string(thishop->hop, rr, len); if (option_debug > 1) ast_log(LOG_DEBUG, "build_route: Record-Route hop: <%s>\n", thishop->hop); /* Link in */ if (backwards) { /* Link in at head so they end up in reverse order */ thishop->next = head; head = thishop; /* If this was the first then it'll be the tail */ if (!tail) tail = thishop; } else { thishop->next = NULL; /* Link in at the end */ if (tail) tail->next = thishop; else head = thishop; tail = thishop; } } } } /* Only append the contact if we are dealing with a strict router */ if (!head || (!ast_strlen_zero(head->hop) && strstr(head->hop,";lr") == NULL) ) { /* 2nd append the Contact: if there is one */ /* Can be multiple Contact headers, comma separated values - we just take the first */ contact = get_header(req, "Contact"); if (!ast_strlen_zero(contact)) { if (option_debug > 1) ast_log(LOG_DEBUG, "build_route: Contact hop: %s\n", contact); /* Look for <: delimited address */ c = strchr(contact, '<'); if (c) { /* Take to > */ ++c; len = strcspn(c, ">") + 1; } else { /* No <> - just take the lot */ c = contact; len = strlen(contact) + 1; } if ((thishop = ast_malloc(sizeof(*thishop) + len))) { /* ast_calloc is not needed because all fields are initialized in this block */ ast_copy_string(thishop->hop, c, len); thishop->next = NULL; /* Goes at the end */ if (tail) tail->next = thishop; else head = thishop; } } } /* Store as new route */ p->route = head; /* For debugging dump what we ended up with */ if (sip_debug_test_pvt(p)) list_route(p->route); }

static int cb_extensionstate (  char *  context, char *  exten, int  state, void *  data )  [static]

Callback for the devicestate notification (SUBSCRIBE) support subsystem. Note: If you add an "hint" priority to the extension in the dial plan, you will get notifications on device state changes Definition at line 2234 of file chan_sip3.c. References append_history, AST_EXTENSION_DEACTIVATED, AST_EXTENSION_REMOVED, ast_extension_state2str(), ast_verbose(), sip_dialog::autokillid, DEFAULT_TRANS_TIMEOUT, FALSE, sip_dialog::laststate, NONE, option_verbose, sip_cancel_destroy(), sip_scheddestroy(), sip_dialog::stateid, sip_dialog::subscribed, transmit_state_notify(), VERBOSE_PREFIX_1, and VERBOSE_PREFIX_2. { struct sip_dialog *p = data; switch(state) { case AST_EXTENSION_DEACTIVATED: /* Retry after a while */ case AST_EXTENSION_REMOVED: /* Extension is gone */ if (p->autokillid > -1) sip_cancel_destroy(p); /* Remove subscription expiry for renewals */ sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); /* Delete subscription in 32 secs */ ast_verbose(VERBOSE_PREFIX_2 "Extension state: Watcher for hint %s %s. Notify User %s\n", exten, state == AST_EXTENSION_DEACTIVATED ? "deactivated" : "removed", p->peername); p->stateid = -1; p->subscribed = NONE; append_history(p, "Subscribestatus", "%s", state == AST_EXTENSION_REMOVED ? "HintRemoved" : "Deactivated"); break; default: /* Tell user */ p->laststate = state; break; } transmit_state_notify(p, state, 1, FALSE); if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_1 "Extension Changed %s new state %s for Notify User %s\n", exten, ast_extension_state2str(state), p->peername); return 0; }

static void check_pendings (  struct sip_dialog *  p  )  [static]

Check pending actions on SIP call. Definition at line 3433 of file chan_sip3.c. References ast_clear_flag, ast_log(), ast_test_flag, DEFAULT_TRANS_TIMEOUT, FALSE, sip_dialog::flags, option_debug, SIP_BYE, SIP_CAN_BYE, SIP_CANCEL, SIP_NEEDREINVITE, SIP_PENDINGBYE, sip_scheddestroy(), transmit_reinvite_with_sdp(), and transmit_request_with_auth(). { if (ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) { /* if we can't BYE, then this is really a pending CANCEL */ if (!ast_test_flag(&p->flags[0], SIP_CAN_BYE)) transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, 1, 0); /* Actually don't destroy us yet, wait for the 487 on our original INVITE, but do set an autodestruct just in case we never get it. */ else transmit_request_with_auth(p, SIP_BYE, 0, 1, 1); ast_clear_flag(&p->flags[0], SIP_PENDINGBYE); sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); } else if (ast_test_flag(&p->flags[0], SIP_NEEDREINVITE)) { if (option_debug) ast_log(LOG_DEBUG, "Sending pending reinvite on '%s'\n", p->callid); /* Didn't get to reinvite yet, so do it now */ transmit_reinvite_with_sdp(p, FALSE); ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE); } }

static int check_user (  struct sip_dialog *  p, struct sip_request *  req, int  sipmethod, char *  uri, enum xmittype  reliable, struct sockaddr_in *  sin )  [static]

Find user If we get a match, this will add a reference pointer to the user object in ASTOBJ, that needs to be unreferenced. Definition at line 2868 of file chan_sip3.c. References check_user_full(). { return check_user_full(p, req, sipmethod, uri, reliable, sin, NULL); }

static enum check_auth_result check_user_full (  struct sip_dialog *  p, struct sip_request *  req, int  sipmethod, char *  uri, enum xmittype  reliable, struct sockaddr_in *  sin, struct sip_device **  authpeer )  [static]

Check if matching user or peer is defined Match user on From: user name and peer on IP/port This is used on first invite (not re-invites) and subscribe requests. Returns: 0 on success, non-zero on failure Definition at line 2637 of file chan_sip3.c. References sip_device_extra::accountcode, accountcode, sip_globals::allowguest, sip_device::allowtransfer, sip_device_extra::amaflags, ast_apply_ha(), ast_copy_flags, ast_inet_ntoa(), ast_is_shrinkable_phonenumber(), ast_log(), ast_rtp_codec_setpref(), ast_rtp_destroy(), AST_RTP_DTMF, ast_set_flag, ast_shrink_phone_number(), ast_strdupa, ast_string_field_free, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_uri_decode(), ast_variable_new(), ast_verbose(), AUTH_SUCCESSFUL, sip_device::autoframing, build_contact(), sip_device::call_limit, sip_device::callgroup, sip_device::callingpres, sip_device::capability, sip_device::chanvars, check_auth(), sip_device_extra::cid_name, cid_name, sip_device_extra::cid_num, cid_num, context, debug(), device_unref(), do_setnat(), exten, sip_device::extra, find_device(), sip_device::flags, get_calleridname(), get_header(), get_in_brackets(), get_rpid_num(), global, sip_device::ha, sip_device::language, language, sip_device::lastms, LOG_NOTICE, sip_device::maxcallbitrate, sip_device::maxms, sip_device_extra::mohinterpret, mohinterpret, sip_device_extra::mohsuggest, mohsuggest, ast_variable::next, sip_registry::peer, sip_device::pickupgroup, sip_device::prefs, sip_device::registry, replace_cid(), SIP_CALL_LIMIT, sip_cancel_destroy(), sip_debug_test_addr(), SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_RFC2833, SIP_FLAGS_TO_COPY, SIP_INSECURE_INVITE, SIP_NAT_ROUTE, SIP_PAGE2_FLAGS_TO_COPY, SIP_PAGE2_VIDEOSUPPORT, SIP_PEER, SIP_PKT_IGNORE, SIP_UNKNOWN, SIP_USER, sip_device::sipoptions, and sip_device::type. { struct sip_device *device = NULL; char from[256], *c; char *of; char rpid_num[50]; const char *rpid; enum check_auth_result res = AUTH_SUCCESSFUL; char *t; char calleridname[50]; int debug = sip_debug_test_addr(sin); struct ast_variable *tmpvar = NULL, *v = NULL; enum objecttype devicematch = SIP_UNKNOWN; char *uri2 = ast_strdupa(uri); /* Terminate URI */ t = uri2; while (*t && *t > 32 && *t != ';') t++; *t = '\0'; ast_copy_string(from, get_header(req, "From"), sizeof(from)); /* XXX bug in original code, overwrote string */ ast_uri_decode(from); /* XXX here tries to map the username for invite things */ memset(calleridname, 0, sizeof(calleridname)); get_calleridname(from, calleridname, sizeof(calleridname)); if (calleridname[0]) ast_string_field_set(p, cid_name, calleridname); rpid = get_header(req, "Remote-Party-ID"); memset(rpid_num, 0, sizeof(rpid_num)); if (!ast_strlen_zero(rpid)) p->callingpres = get_rpid_num(rpid, rpid_num, sizeof(rpid_num)); of = get_in_brackets(from); if (ast_strlen_zero(p->exten)) { char *t = uri2; if (!strncmp(t, "sip:", 4)) t+= 4; ast_string_field_set(p, exten, t); t = strchr(p->exten, '@'); if (t) *t = '\0'; if (ast_strlen_zero(p->our_contact)) build_contact(p); } /* save the URI part of the From header */ ast_string_field_set(p, from, of); if (strncmp(of, "sip:", 4)) ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n"); else of += 4; /* Get just the username part */ if ((c = strchr(of, '@'))) { char *tmp; *c = '\0'; if ((c = strchr(of, ':'))) *c = '\0'; tmp = ast_strdupa(of); if (ast_is_shrinkable_phonenumber(tmp)) ast_shrink_phone_number(tmp); ast_string_field_set(p, cid_num, tmp); } if (ast_strlen_zero(of)) return AUTH_SUCCESSFUL; if (p->registry && p->registry->peer) /* We already know this device from registry */ device = p->registry->peer; else /* Find device in device list */ device = find_device(of, NULL, 1); if (device && !ast_apply_ha(device->ha, sin)) { device_unref(device); device = NULL; } /* Secondly match on IP/port (will in the future only be applied to trunks, not devices */ if (!device) { /* Look for peer based on the IP address we received data from */ /* If peer is registered from this IP address or have this as a default IP address, this call is from the peer */ device = find_device(NULL, &p->recv, 1); } if (device && !ast_apply_ha(device->ha, sin)) { device_unref(device); device = NULL; } if (device) devicematch = SIP_PEER; /* We matched on a peer */ /* No device found */ if (!device) { if (debug) ast_verbose("Found no matching peer or user for '%s:%d'\n", ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port)); /* do we allow guests? */ if (!global.allowguest) res = -1; /* we don't want any guests, authentication will fail */ return res; } /* Ok, we have a device, let's check authentication if needed */ ast_copy_flags(&p->flags[0], &device->flags[0], SIP_FLAGS_TO_COPY); ast_copy_flags(&p->flags[1], &device->flags[1], SIP_PAGE2_FLAGS_TO_COPY); /* Copy SIP extensions profile to peer */ if (p->sipoptions) device->sipoptions = p->sipoptions; /* copy channel vars */ for (v = device->chanvars ; v ; v = v->next) { if ((tmpvar = ast_variable_new(v->name, v->value))) { tmpvar->next = p->chanvars; p->chanvars = tmpvar; } } p->prefs = device->prefs; /* Set Frame packetization */ if (p->rtp) { ast_rtp_codec_setpref(p->rtp, &p->prefs); p->autoframing = device->autoframing; } replace_cid(p, rpid_num, calleridname); do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE)); if (device->maxms && device->lastms) p->timer_t1 = device->lastms; if (ast_test_flag(&device->flags[0], SIP_INSECURE_INVITE)) { /* Pretend there is no required authentication */ ast_string_field_free(p, peersecret); ast_string_field_free(p, peermd5secret); } /* Now, check auth */ if (!(res = check_auth(p, req, device->name, device->secret, device->md5secret, sipmethod, uri, reliable, ast_test_flag(req, SIP_PKT_IGNORE)))) { /* We have positive authentication, let's configure this SIP session */ sip_cancel_destroy(p); ast_copy_flags(&p->flags[0], &device->flags[0], SIP_FLAGS_TO_COPY); ast_copy_flags(&p->flags[1], &device->flags[1], SIP_PAGE2_FLAGS_TO_COPY); /* Copy SIP extensions profile from INVITE */ if (p->sipoptions) device->sipoptions = p->sipoptions; /* If we have a call limit, set flag */ if (device->call_limit) ast_set_flag(&p->flags[0], SIP_CALL_LIMIT); if (!ast_strlen_zero(device->extra.context)) ast_string_field_set(p, context, device->extra.context); if (!ast_strlen_zero(device->extra.cid_num) && !ast_strlen_zero(p->cid_num)) { char *tmp = ast_strdupa(device->extra.cid_num); if (tmp) { if (ast_is_shrinkable_phonenumber(tmp)) ast_shrink_phone_number(tmp); ast_string_field_set(p, cid_num, tmp); } else { ast_string_field_set(p, cid_num, device->extra.cid_num); } } if (!ast_strlen_zero(device->extra.cid_name) && !ast_strlen_zero(p->cid_num)) ast_string_field_set(p, cid_name, device->extra.cid_name); ast_string_field_set(p, peersecret, device->secret); ast_string_field_set(p, peermd5secret, device->md5secret); ast_string_field_set(p, fullcontact, device->fullcontact); ast_string_field_set(p, peername, device->name); ast_string_field_set(p, authname, device->name); if (!ast_strlen_zero(device->defaultuser)) { ast_string_field_set(p, peername, device->defaultuser); /* Use the default username for authentication on outbound calls */ if(!ast_strlen_zero(device->authuser)) ast_string_field_set(p, authname, device->authuser); } if (p->t38.peercapability) p->t38.jointcapability &= p->t38.peercapability; p->maxcallbitrate = device->maxcallbitrate; /* If we do not support video, remove video from call structure */ if (!ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) && p->vrtp) { ast_rtp_destroy(p->vrtp); p->vrtp = NULL; } ast_string_field_set(p, subscribecontext, device->extra.subscribecontext); ast_string_field_set(p, accountcode, device->extra.accountcode); ast_string_field_set(p, language, device->language); ast_string_field_set(p, mohsuggest, device->extra.mohsuggest); ast_string_field_set(p, mohinterpret, device->extra.mohinterpret); p->allowtransfer = device->allowtransfer; p->amaflags = device->extra.amaflags; p->callgroup = device->callgroup; p->pickupgroup = device->pickupgroup; p->callingpres = device->callingpres; p->capability = device->capability; p->jointcapability = device->capability; p->prefs = device->prefs; if (p->peercapability) p->jointcapability &= p->peercapability; p->maxcallbitrate = device->maxcallbitrate; if (!ast_test_flag((&p->flags[1]), SIP_PAGE2_VIDEOSUPPORT) && p->vrtp) { ast_rtp_destroy(p->vrtp); p->vrtp = NULL; } if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) p->noncodeccapability |= AST_RTP_DTMF; else p->noncodeccapability &= ~AST_RTP_DTMF; /* copy channel vars */ for (v = device->chanvars ; v ; v = v->next) { if ((tmpvar = ast_variable_new(v->name, v->value))) { tmpvar->next = p->chanvars; p->chanvars = tmpvar; } } do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE)); ast_string_field_set(p, peersecret, device->secret); ast_string_field_set(p, peermd5secret, device->md5secret); ast_string_field_set(p, subscribecontext, device->extra.subscribecontext); ast_string_field_set(p, mohinterpret, device->extra.mohinterpret); ast_string_field_set(p, mohsuggest, device->extra.mohsuggest); if (device->callingpres) /* Peer calling pres setting will override RPID */ p->callingpres = device->callingpres; } if (device && debug) ast_verbose("Found %s '%s'\n", device->type & SIP_USER ? "user" : "peer", device->name); device_unref(device); return res; }

static void check_via (  struct sip_dialog *  p, struct sip_request *  req )  [static]

check Via: header for hostname, port and rport request/answer Definition at line 2571 of file chan_sip3.c. References ahp, ast_gethostbyname(), ast_inet_ntoa(), ast_log(), ast_set_flag, ast_verbose(), sip_dialog::flags, get_header(), hp, LOG_WARNING, sip_dialog::sa, sip_debug_test_pvt(), sip_nat_mode(), SIP_NAT_ROUTE, sip_real_dst(), and STANDARD_SIP_PORT. { char via[256]; char *c, *pt; struct hostent *hp; struct ast_hostent ahp; ast_copy_string(via, get_header(req, "Via"), sizeof(via)); if (strlen(via) == 0) ast_log(LOG_DEBUG, "Empty VIA string found \n"); /* Work on the leftmost value of the topmost Via header */ c = strchr(via, ','); if (c) *c = '\0'; /* Check for rport */ c = strstr(via, ";rport"); if (c && (c[6] != '=')) /* rport query, not answer */ ast_set_flag(&p->flags[0], SIP_NAT_ROUTE); c = strchr(via, ';'); if (c) *c = '\0'; c = strchr(via, ' '); if (c) { *c = '\0'; c = ast_skip_blanks(c+1); if (strcasecmp(via, "SIP/2.0/UDP")) { ast_log(LOG_WARNING, "Don't know how to respond via '%s'\n", via); return; } pt = strchr(c, ':'); if (pt) *pt++ = '\0'; /* remember port pointer */ /* Set sender's address to the IP address in via for replies */ memset(&p->sa, 0, sizeof(p->sa)); p->sa.sin_family = AF_INET; if (!inet_aton(c, &p->sa.sin_addr)) { /* Check if this is an IP address, not a host name */ /* resolve host name */ hp = ast_gethostbyname(c, &ahp); if (!hp) { ast_log(LOG_WARNING, "'%s' is not a valid DNS host name\n", c); return; } memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr)); } p->sa.sin_port = htons(pt ? atoi(pt) : STANDARD_SIP_PORT); if (sip_debug_test_pvt(p)) { const struct sockaddr_in *dst = sip_real_dst(p); ast_verbose("Sending to %s : %d (%s)\n", ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), sip_nat_mode(p)); ast_verbose("Sender's address %s : %d (%s)\n", ast_inet_ntoa(p->sa.sin_addr), ntohs(p->sa.sin_port), sip_nat_mode(p)); } } }

GNURK int create_addr (  struct sip_dialog *  dialog, const char *  username, char *  domain, const char *  device )

create address structure from peer name Or, if peer not found, find it in the global DNS returns TRUE (-1) on failure, FALSE on success Definition at line 808 of file chan_sip3.c. References ahp, ast_get_srv(), ast_gethostbyname(), ast_log(), ast_string_field_set, ast_strlen_zero(), ast_verbose(), create_addr_from_peer(), device_unref(), FALSE, find_device(), global, hp, LOG_DEBUG, LOG_WARNING, option_debug, option_verbose, sip_dialog::recv, sip_dialog::sa, sip_globals::srvlookup, STANDARD_SIP_PORT, sip_globals::t1default, sip_dialog::timer_t1, and TRUE. { struct hostent *hp; struct ast_hostent ahp; struct sip_device *p = NULL; char *port; int portno; char host[MAXHOSTNAMELEN], *hostn; char peername[256]; char todomain[256]; int srvcheck = TRUE; dialog->sa.sin_family = AF_INET; dialog->timer_t1 = global.t1default; /* Default SIP retransmission timer T1 (RFC 3261) */ if (!ast_strlen_zero(device)) { int res; p = find_device(device, NULL, 1); if (p) { res = create_addr_from_peer(dialog, p); device_unref(p); return res; } else { if (option_verbose > 1) ast_verbose("Can't find peer %s\n", device); return -1; /* Can't find peer */ } } /* See if we have a port. If we have a given port, disable SRV lookups */ if (!ast_strlen_zero(domain)) { ast_copy_string(todomain, domain, sizeof(todomain)); port = strchr(todomain, ':'); } if (port) { *port++ = '\0'; srvcheck = FALSE; } hostn = domain; portno = port ? atoi(port) : STANDARD_SIP_PORT; if (global.srvlookup && srvcheck) { char service[MAXHOSTNAMELEN]; int tportno; int ret; snprintf(service, sizeof(service), "_sip._udp.%s", domain); ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service); if (ret > 0) { hostn = host; portno = tportno; if (option_debug > 2) ast_log(LOG_DEBUG, "Resolved domain %s to host %s in SRV \n", domain, hostn); } } hp = ast_gethostbyname(hostn, &ahp); if (!hp) { ast_log(LOG_WARNING, "No such host: %s\n", peername); return -2; } ast_string_field_set(dialog, tohost, domain); memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr)); dialog->sa.sin_port = htons(portno); dialog->recv = dialog->sa; return 0; }

static int create_addr_from_peer (  struct sip_dialog *  r, struct sip_device *  peer )  [static]

Create address structure from device reference. return -1 on error, 0 on success. Definition at line 692 of file chan_sip3.c. References sip_device::addr, sip_device::allowtransfer, sip_dialog::allowtransfer, ast_copy_flags, ast_inet_ntoa(), ast_log(), ast_rtp_codec_setpref(), ast_rtp_destroy(), AST_RTP_DTMF, ast_rtp_set_rtpholdtimeout(), ast_rtp_set_rtpkeepalive(), ast_rtp_set_rtptimeout(), ast_rtp_setdtmf(), ast_rtp_setdtmfcompensate(), ast_set_flag, ast_strdupa, ast_string_field_build, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_udptl_destroy(), ast_udptl_get_error_correction_scheme(), sip_device::autoframing, sip_dialog::autoframing, sip_device::call_limit, sip_device::callgroup, sip_dialog::callgroup, t38properties::capability, sip_device::capability, sip_dialog::capability, context, sip_device::defaddr, do_setnat(), sip_device::extra, sip_device::flags, sip_dialog::flags, global, sip_dialog::initreq, t38properties::jointcapability, sip_device::lastms, LOG_DEBUG, sip_device::maxcallbitrate, sip_dialog::maxcallbitrate, sip_device::maxms, sip_device_extra::mohinterpret, mohinterpret, sip_device_extra::mohsuggest, mohsuggest, sip_dialog::noncodeccapability, option_debug, sip_device::pickupgroup, sip_dialog::pickupgroup, sip_device::prefs, sip_dialog::prefs, sip_dialog::recv, sip_dialog::rtp, rtptimers::rtpholdtimeout, rtptimers::rtpkeepalive, rtptimers::rtptimeout, sip_device::rtptimer, sip_dialog::sa, SIP_CALL_LIMIT, SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_INFO, SIP_DTMF_RFC2833, SIP_FLAGS_TO_COPY, SIP_NAT, SIP_NAT_ROUTE, SIP_PAGE2_FLAGS_TO_COPY, SIP_PAGE2_RFC2833_COMPENSATE, SIP_PAGE2_T38SUPPORT, SIP_PAGE2_VIDEOSUPPORT, sip_globals::t1min, sip_dialog::t38, sip_globals::t38_capability, T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF, T38FAX_UDP_EC_FEC, T38FAX_UDP_EC_NONE, T38FAX_UDP_EC_REDUNDANCY, sip_dialog::timer_t1, sip_device_extra::tohost, sip_dialog::udptl, UDPTL_ERROR_CORRECTION_FEC, UDPTL_ERROR_CORRECTION_NONE, UDPTL_ERROR_CORRECTION_REDUNDANCY, and sip_dialog::vrtp. { if ((device->addr.sin_addr.s_addr || device->defaddr.sin_addr.s_addr) && (!device->maxms || ((device->lastms >= 0) && (device->lastms <= device->maxms)))) { dialog->sa = (device->addr.sin_addr.s_addr) ? device->addr : device->defaddr; dialog->recv = dialog->sa; } else return -1; ast_copy_flags(&dialog->flags[0], &device->flags[0], SIP_FLAGS_TO_COPY); ast_copy_flags(&dialog->flags[1], &device->flags[1], SIP_PAGE2_FLAGS_TO_COPY); dialog->capability = device->capability; if (!ast_test_flag(&dialog->flags[1], SIP_PAGE2_VIDEOSUPPORT) && dialog->vrtp) { ast_rtp_destroy(dialog->vrtp); dialog->vrtp = NULL; } dialog->prefs = device->prefs; if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_T38SUPPORT)) { dialog->t38.capability = global.t38_capability; if (dialog->udptl) { if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_FEC ) dialog->t38.capability |= T38FAX_UDP_EC_FEC; else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_REDUNDANCY ) dialog->t38.capability |= T38FAX_UDP_EC_REDUNDANCY; else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_NONE ) dialog->t38.capability |= T38FAX_UDP_EC_NONE; dialog->t38.capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF; if (option_debug > 1) ast_log(LOG_DEBUG,"Our T38 capability (%d)\n", dialog->t38.capability); } dialog->t38.jointcapability = dialog->t38.capability; } else if (dialog->udptl) { ast_udptl_destroy(dialog->udptl); dialog->udptl = NULL; } do_setnat(dialog, ast_test_flag(&dialog->flags[0], SIP_NAT) & SIP_NAT_ROUTE ); if (dialog->rtp) { ast_rtp_setdtmf(dialog->rtp, ast_test_flag(&dialog->flags[0], SIP_DTMF) != SIP_DTMF_INFO); ast_rtp_setdtmfcompensate(dialog->rtp, ast_test_flag(&dialog->flags[1], SIP_PAGE2_RFC2833_COMPENSATE)); } if (dialog->vrtp) { ast_rtp_setdtmf(dialog->vrtp, 0); ast_rtp_setdtmfcompensate(dialog->vrtp, 0); } /* Set Frame packetization */ if (dialog->rtp) { ast_rtp_codec_setpref(dialog->rtp, &dialog->prefs); dialog->autoframing = device->autoframing; } /* XXX Why use username for all of this? */ //ast_string_field_set(dialog, peername, device->defaultuser); ast_string_field_set(dialog, peername, device->name); /* Authuser is fromuser, and if that not is set, it's the defaultuser, if that's set */ if (ast_strlen_zero(device->extra.fromuser)) ast_string_field_set(dialog, authname, device->defaultuser); else ast_string_field_set(dialog, authname, device->extra.fromuser); ast_string_field_set(dialog, defaultuser, device->defaultuser); ast_string_field_set(dialog, peersecret, device->secret); ast_string_field_set(dialog, peermd5secret, device->md5secret); ast_string_field_set(dialog, tohost, device->extra.tohost); ast_string_field_set(dialog, mohinterpret, device->extra.mohinterpret); ast_string_field_set(dialog, mohsuggest, device->extra.mohsuggest); ast_string_field_set(dialog, fullcontact, device->fullcontact); if (!dialog->initreq && !ast_strlen_zero(device->extra.fromdomain)) { char *tmpcall; char *c; tmpcall = ast_strdupa(dialog->callid); c = strchr(tmpcall, '@'); if (c) { *c = '\0'; ast_string_field_build(dialog, callid, "%s@%s", tmpcall, device->extra.fromdomain); } } if (ast_strlen_zero(dialog->tohost)) ast_string_field_set(dialog, tohost, ast_inet_ntoa(dialog->sa.sin_addr)); if (!ast_strlen_zero(device->extra.fromdomain)) ast_string_field_set(dialog, fromdomain, device->extra.fromdomain); if (!ast_strlen_zero(device->extra.fromuser)) ast_string_field_set(dialog, fromuser, device->extra.fromuser); dialog->callgroup = device->callgroup; dialog->pickupgroup = device->pickupgroup; dialog->allowtransfer = device->allowtransfer; /* Set timer T1 to RTT for this peer (if known by qualify=) */ /* Minimum is settable or default to 100 ms */ if (device->maxms && device->lastms) dialog->timer_t1 = device->lastms < global.t1min ? global.t1min : device->lastms; if ((ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) dialog->noncodeccapability |= AST_RTP_DTMF; else dialog->noncodeccapability &= ~AST_RTP_DTMF; ast_string_field_set(dialog, context, device->extra.context); ast_rtp_set_rtptimeout(dialog->rtp, device->rtptimer.rtptimeout); ast_rtp_set_rtpholdtimeout(dialog->rtp, device->rtptimer.rtpholdtimeout); ast_rtp_set_rtpkeepalive(dialog->rtp, device->rtptimer.rtpkeepalive); if (dialog->vrtp) { ast_rtp_set_rtptimeout(dialog->vrtp, device->rtptimer.rtptimeout); ast_rtp_set_rtpholdtimeout(dialog->vrtp, device->rtptimer.rtpholdtimeout); ast_rtp_set_rtpkeepalive(dialog->vrtp, device->rtptimer.rtpkeepalive); } if (device->call_limit) ast_set_flag(&dialog->flags[0], SIP_CALL_LIMIT); dialog->maxcallbitrate = device->maxcallbitrate; return 0; }

GNURK void do_setnat (  struct sip_dialog *  dialog, int  natflags )

Set nat mode on the various media streams. Definition at line 668 of file chan_sip3.c. References ast_log(), ast_rtp_setnat(), ast_udptl_setnat(), LOG_DEBUG, option_debug, sip_dialog::rtp, sip_dialog::udptl, and sip_dialog::vrtp. { const char *mode = natflags ? "On" : "Off"; if (dialog->rtp) { if (option_debug) ast_log(LOG_DEBUG, "Setting NAT on RTP to %s\n", mode); ast_rtp_setnat(dialog->rtp, natflags); } if (dialog->vrtp) { if (option_debug) ast_log(LOG_DEBUG, "Setting NAT on VRTP to %s\n", mode); ast_rtp_setnat(dialog->vrtp, natflags); } if (dialog->udptl) { if (option_debug) ast_log(LOG_DEBUG, "Setting NAT on UDPTL to %s\n", mode); ast_udptl_setnat(dialog->udptl, natflags); } }

void free_old_route (  struct sip_route *  route  )

Remove route from route list. Definition at line 2084 of file chan_sip3.c. References free, and sip_route::next. { struct sip_route *next; while (route) { next = route->next; free(route); route = next; } }

static int func_header_read (  struct ast_channel *  chan, const char *  function, char *  data, char *  buf, size_t  len )  [static]

Read SIP header (dialplan function). Definition at line 3212 of file chan_sip3.c. References __get_header(), AST_APP_ARG, ast_channel_lock, ast_channel_unlock, AST_DECLARE_APP_ARGS, ast_log(), AST_STANDARD_APP_ARGS, ast_strlen_zero(), sip_request::header, sip_dialog::initreq, LOG_WARNING, sip_tech, sip_tech_info, ast_channel::tech, and ast_channel::tech_pvt. { struct sip_dialog *p; const char *content = NULL; AST_DECLARE_APP_ARGS(args, AST_APP_ARG(header); AST_APP_ARG(number); ); int i, number, start = 0; if (ast_strlen_zero(data)) { ast_log(LOG_WARNING, "This function requires a header name.\n"); return -1; } ast_channel_lock(chan); if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) { ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n"); ast_channel_unlock(chan); return -1; } AST_STANDARD_APP_ARGS(args, data); if (!args.number) { number = 1; } else { sscanf(args.number, "%d", &number); if (number < 1) number = 1; } p = chan->tech_pvt; /* If there is no private structure, this channel is no longer alive */ if (!p) { ast_channel_unlock(chan); return -1; } for (i = 0; i < number; i++) content = __get_header(p->initreq, args.header, &start); if (ast_strlen_zero(content)) { ast_channel_unlock(chan); return -1; } ast_copy_string(buf, content, len); ast_channel_unlock(chan); return 0; }

static int function_sipchaninfo_read (  struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len )  [static]

${SIPCHANINFO()} Dialplan function - reads sip channel data Definition at line 3364 of file chan_sip3.c. References ast_channel_lock, ast_channel_unlock, ast_inet_ntoa(), ast_log(), LOG_WARNING, sip_dialog::recv, sip_dialog::sa, sip_tech, sip_tech_info, t38properties::state, sip_dialog::t38, T38_DISABLED, ast_channel::tech, and ast_channel::tech_pvt. { struct sip_dialog *p; *buf = 0; if (!data) { ast_log(LOG_WARNING, "This function requires a parameter name.\n"); return -1; } ast_channel_lock(chan); if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) { ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n"); ast_channel_unlock(chan); return -1; } p = chan->tech_pvt; /* If there is no private structure, this channel is no longer alive */ if (!p) { ast_channel_unlock(chan); return -1; } if (!strcasecmp(data, "peerip")) { ast_copy_string(buf, p->sa.sin_addr.s_addr ? ast_inet_ntoa(p->sa.sin_addr) : "", len); } else if (!strcasecmp(data, "recvip")) { ast_copy_string(buf, p->recv.sin_addr.s_addr ? ast_inet_ntoa(p->recv.sin_addr) : "", len); } else if (!strcasecmp(data, "from")) { ast_copy_string(buf, p->from, len); } else if (!strcasecmp(data, "uri")) { ast_copy_string(buf, p->uri, len); } else if (!strcasecmp(data, "useragent")) { ast_copy_string(buf, p->useragent, len); } else if (!strcasecmp(data, "peername")) { ast_copy_string(buf, p->peername, len); } else if (!strcasecmp(data, "t38passthrough")) { if (p->t38.state == T38_DISABLED) ast_copy_string(buf, "0", sizeof("0")); else /* T38 is offered or enabled in this call */ ast_copy_string(buf, "1", sizeof("1")); } else { ast_channel_unlock(chan); return -1; } ast_channel_unlock(chan); return 0; }

static int function_sippeer (  struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len )  [static]

${SIPPEER()} Dialplan function - reads peer data Definition at line 3276 of file chan_sip3.c. References sip_device_extra::accountcode, sip_device::addr, ast_codec_pref_index(), ast_getformatname(), ast_getformatname_multiple(), ast_inet_ntoa(), ast_test_flag, sip_device::call_limit, sip_device::capability, sip_device_extra::cid_name, sip_device_extra::cid_num, device_status(), device_unref(), sip_device::expire, sip_device::extra, find_device(), sip_device::flags, sip_device::inUse, sip_device::language, sip_device::mailbox, sip_device::prefs, SIP_PAGE2_DYNAMIC, and strsep(). { struct sip_device *peer; char *colname; if ((colname = strchr(data, '|'))) *colname++ = '\0'; else colname = "ip"; if (!(peer = find_device(data, NULL, 1))) return -1; if (!strcasecmp(colname, "ip")) { ast_copy_string(buf, peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "", len); } else if (!strcasecmp(colname, "status")) { device_status(peer, buf, len); } else if (!strcasecmp(colname, "language")) { ast_copy_string(buf, peer->language, len); } else if (!strcasecmp(colname, "regexten")) { ast_copy_string(buf, peer->extra.regexten, len); } else if (!strcasecmp(colname, "limit")) { snprintf(buf, len, "%d", peer->call_limit); } else if (!strcasecmp(colname, "curcalls")) { snprintf(buf, len, "%d", peer->inUse); } else if (!strcasecmp(colname, "accountcode")) { ast_copy_string(buf, peer->extra.accountcode, len); } else if (!strcasecmp(colname, "useragent")) { ast_copy_string(buf, peer->useragent, len); } else if (!strcasecmp(colname, "mailbox")) { ast_copy_string(buf, peer->mailbox.mailbox, len); } else if (!strcasecmp(colname, "context")) { ast_copy_string(buf, peer->extra.context, len); } else if (!strcasecmp(colname, "expire")) { snprintf(buf, len, "%d", peer->expire); } else if (!strcasecmp(colname, "dynamic")) { ast_copy_string(buf, (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) ? "yes" : "no"), len); } else if (!strcasecmp(colname, "callerid_name")) { ast_copy_string(buf, peer->extra.cid_name, len); } else if (!strcasecmp(colname, "callerid_num")) { ast_copy_string(buf, peer->extra.cid_num, len); } else if (!strcasecmp(colname, "codecs")) { ast_getformatname_multiple(buf, len -1, peer->capability); } else if (!strncasecmp(colname, "codec[", 6)) { char *codecnum; int index = 0, codec = 0; codecnum = colname + 6; /* move past the '[' */ codecnum = strsep(&codecnum, "]"); /* trim trailing ']' if any */ index = atoi(codecnum); if((codec = ast_codec_pref_index(&peer->prefs, index))) { ast_copy_string(buf, ast_getformatname(codec), len); } } device_unref(peer); return 0; }

static int get_also_info (  struct sip_dialog *  p, struct sip_request *  oreq )  [static]

Call transfer support (old way, deprecated by the IETF)--. Definition at line 2515 of file chan_sip3.c. References ast_canmatch_extension(), ast_exists_extension(), ast_log(), ast_string_field_set, ast_strlen_zero(), ast_uri_decode(), ast_verbose(), context, sip_globals::default_context, get_header(), get_in_brackets(), global, sip_dialog::initreq, LOG_WARNING, ast_channel::macrocontext, option_debug, sip_dialog::owner, pbx_builtin_getvar_helper(), sip_dialog::refer, sip_refer::refer_call, sip_refer::refer_contact, sip_refer::refer_to, sip_refer::refer_to_domain, sip_refer::referred_by, S_OR, and sip_debug_test_pvt(). { char tmp[256] = "", *c, *a; struct sip_request *req = oreq ? oreq : p->initreq; struct sip_refer *referdata = p->refer; const char *transfer_context = NULL; ast_copy_string(tmp, get_header(req, "Also"), sizeof(tmp)); c = get_in_brackets(tmp); ast_uri_decode(c); if (strncmp(c, "sip:", 4)) { ast_log(LOG_WARNING, "Huh? Not a SIP header in Also: transfer (%s)?\n", c); return -1; } c += 4; if ((a = strchr(c, ';'))) /* Remove arguments */ *a = '\0'; if ((a = strchr(c, '@'))) { /* Separate Domain */ *a++ = '\0'; ast_copy_string(referdata->refer_to_domain, a, sizeof(referdata->refer_to_domain)); } if (sip_debug_test_pvt(p)) ast_verbose("Looking for %s in %s\n", c, p->context); if (p->owner) /* Mimic behaviour in res_features.c */ transfer_context = pbx_builtin_getvar_helper(p->owner, "TRANSFER_CONTEXT"); /* By default, use the context in the channel sending the REFER */ if (ast_strlen_zero(transfer_context)) { transfer_context = S_OR(p->owner->macrocontext, S_OR(p->context, global.default_context)); } if (ast_exists_extension(NULL, transfer_context, c, 1, NULL)) { /* This is a blind transfer */ if (option_debug) ast_log(LOG_DEBUG,"SIP Bye-also transfer to Extension %s@%s \n", c, transfer_context); ast_copy_string(referdata->refer_to, c, sizeof(referdata->refer_to)); ast_copy_string(referdata->referred_by, "", sizeof(referdata->referred_by)); ast_copy_string(referdata->refer_contact, "", sizeof(referdata->refer_contact)); referdata->refer_call = NULL; /* Set new context */ ast_string_field_set(p, context, transfer_context); return 0; } else if (ast_canmatch_extension(NULL, p->context, c, 1, NULL)) { return 1; } return -1; }

static int get_msg_text (  char *  buf, int  len, struct sip_request *  req )  [static]

Get text out of a SIP MESSAGE packet. Definition at line 2874 of file chan_sip3.c. References sip_request::line, and sip_request::lines. { int x; int y; buf[0] = '\0'; y = len - strlen(buf) - 5; if (y < 0) y = 0; for (x=0;x<req->lines;x++) { strncat(buf, req->line[x], y); /* safe */ y -= strlen(req->line[x]) + 1; if (y < 0) y = 0; if (y != 0) strcat(buf, "\n"); /* safe */ } return 0; }

GNURK struct sip_dialog* get_sip_dialog_byid_locked (  const char *  callid, const char *  totag, const char *  fromtag )

Lock dialog list lock and find matching pvt lock Their tag is fromtag, our tag is to-tag This means that in some transactions, totag needs to be their tag :-) depending upon the direction. Definition at line 2464 of file chan_sip3.c. References ast_log(), dialog_lock(), dialoglist, dialoglist_lock(), FALSE, LOG_DEBUG, match(), sip_dialog::next, option_debug, sip_dialog::tag, and TRUE. Referenced by handle_request_invite(), and local_attended_transfer(). { struct sip_dialog *sip_dialog_ptr; dialoglist_lock(); if (option_debug > 3 && totag) ast_log(LOG_DEBUG, "Looking for callid %s (fromtag %s totag %s)\n", callid, fromtag ? fromtag : "<no fromtag>", totag ? totag : "<no totag>"); /* Search interfaces and find the match */ for (sip_dialog_ptr = dialoglist; sip_dialog_ptr; sip_dialog_ptr = sip_dialog_ptr->next) { if (!strcmp(sip_dialog_ptr->callid, callid)) { int match = 1; char *ourtag = sip_dialog_ptr->tag; /* Go ahead and lock it (and its owner) before returning */ dialog_lock(sip_dialog_ptr, TRUE); /* Check if tags match. If not, this is not the call we want (With a forking SIP proxy, several call legs share the call id, but have different tags) */ if (strcmp(fromtag, sip_dialog_ptr->theirtag) || strcmp(totag, ourtag)) match = 0; if (!match) { dialog_lock(sip_dialog_ptr, FALSE); continue; } if (option_debug > 3 && totag) ast_log(LOG_DEBUG, "Matched %s call - their tag is %s Our tag is %s\n", ast_test_flag(&sip_dialog_ptr->flags[0], SIP_OUTGOING) ? "OUTGOING": "INCOMING", sip_dialog_ptr->theirtag, sip_dialog_ptr->tag); /* deadlock avoidance... */ while (sip_dialog_ptr->owner && ast_channel_trylock(sip_dialog_ptr->owner)) { dialog_lock(sip_dialog_ptr, FALSE); usleep(1); dialog_lock(sip_dialog_ptr, TRUE); } break; } } dialoglist_unlock(); if (option_debug > 3 && !sip_dialog_ptr) ast_log(LOG_DEBUG, "Found no match for callid %s to-tag %s from-tag %s\n", callid, totag, fromtag); return sip_dialog_ptr; }

static int handle_invite_replaces (  struct sip_dialog *  p, struct sip_request *  req, int  debug, struct sockaddr_in *  sin )  [static]

Handle the transfer part of INVITE with a replaces: header, meaning a target pickup or an attended transfer. Definition at line 4198 of file chan_sip3.c. References ast_channel::_state, append_history, ast_bridged_channel(), AST_CAUSE_SWITCH_CONGESTION, ast_channel_masquerade(), ast_channel_unlock, ast_frfree(), ast_hangup(), ast_log(), ast_quiet_chan(), ast_read(), ast_set_flag, ast_setstate(), ast_state2str(), AST_STATE_DOWN, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_test_flag, DEFAULT_TRANS_TIMEOUT, dialog_lock(), FALSE, sip_pvt::flags, ast_channel::hangupcause, LOG_ERROR, LOG_NOTICE, LOG_WARNING, option_debug, sip_pvt::owner, sip_dialog::owner, sip_dialog::refer, sip_refer::refer_call, SIP_DEFER_BYE_ON_TRANSFER, SIP_PKT_IGNORE, sip_scheddestroy(), ast_channel::tech_pvt, transmit_response(), transmit_response_reliable(), transmit_response_with_attachment(), WITH_SDP, and XMIT_RELIABLE. { struct ast_frame *f; int earlyreplace = 0; int oneleggedreplace = 0; /* Call with no bridge, propably IVR or voice message */ struct ast_channel *c = p->owner; /* Our incoming call */ struct ast_channel *replacecall = p->refer->refer_call->owner; /* The channel we're about to take over */ struct ast_channel *targetcall; /* The bridge to the take-over target */ /* Check if we're in ring state */ if (replacecall->_state == AST_STATE_RING) earlyreplace = 1; /* Check if we have a bridge */ if (!(targetcall = ast_bridged_channel(replacecall))) { /* We have no bridge */ if (!earlyreplace) { if (option_debug > 1) ast_log(LOG_DEBUG, " Attended transfer attempted to replace call with no bridge (maybe ringing). Channel %s!\n", replacecall->name); oneleggedreplace = 1; } } if (option_debug > 3 && targetcall && targetcall->_state == AST_STATE_RINGING) ast_log(LOG_DEBUG, "SIP transfer: Target channel is in ringing state\n"); if (option_debug > 3) { if (targetcall) ast_log(LOG_DEBUG, "SIP transfer: Invite Replace incoming channel should bridge to channel %s while hanging up channel %s\n", targetcall->name, replacecall->name); else ast_log(LOG_DEBUG, "SIP transfer: Invite Replace incoming channel should replace and hang up channel %s (one call leg)\n", replacecall->name); } if (ast_test_flag(req, SIP_PKT_IGNORE)) { ast_log(LOG_NOTICE, "Ignoring this INVITE with replaces in a stupid way.\n"); /* We should answer something here. If we are here, the call we are replacing exists, so an accepted can't harm */ transmit_response_with_attachment(WITH_SDP, p, "200 OK", req, XMIT_RELIABLE); /* Do something more clever here */ ast_channel_unlock(c); dialog_lock(p->refer->refer_call, FALSE); return 1; } if (!c) { /* What to do if no channel ??? */ ast_log(LOG_ERROR, "Unable to create new channel. Invite/replace failed.\n"); transmit_response_reliable(p, "503 Service Unavailable", req); append_history(p, "Xfer", "INVITE/Replace Failed. No new channel."); sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); dialog_lock(p->refer->refer_call, FALSE); return 1; } append_history(p, "Xfer", "INVITE/Replace received"); /* We have three channels to play with channel c: New incoming call targetcall: Call from PBX to target p->refer->refer_call: SIP pvt dialog from transferer to pbx. replacecall: The owner of the previous We need to masq C into refer_call to connect to targetcall; If we are talking to internal audio stream, target call is null. */ /* Fake call progress */ transmit_response(p, "100 Trying", req); ast_setstate(c, AST_STATE_RING); /* Masquerade the new call into the referred call to connect to target call Targetcall is not touched by the masq */ /* Answer the incoming call and set channel to UP state */ transmit_response_with_attachment(WITH_SDP, p, "200 OK", req, XMIT_RELIABLE); ast_setstate(c, AST_STATE_UP); /* Stop music on hold and other generators */ ast_quiet_chan(replacecall); ast_quiet_chan(targetcall); if (option_debug > 3) ast_log(LOG_DEBUG, "Invite/Replaces: preparing to masquerade %s into %s\n", c->name, replacecall->name); /* Unlock clone, but not original (replacecall) */ ast_channel_unlock(c); /* Unlock dialog */ dialog_lock(p->refer->refer_call, FALSE); /* Make sure that the masq does not free our PVT for the old call */ ast_set_flag(&p->refer->refer_call->flags[0], SIP_DEFER_BYE_ON_TRANSFER); /* Delay hangup */ /* Prepare the masquerade - if this does not happen, we will be gone */ if(ast_channel_masquerade(replacecall, c)) ast_log(LOG_ERROR, "Failed to masquerade C into Replacecall\n"); else if (option_debug > 3) ast_log(LOG_DEBUG, "Invite/Replaces: Going to masquerade %s into %s\n", c->name, replacecall->name); /* The masquerade will happen as soon as someone reads a frame from the channel */ /* C should now be in place of replacecall */ /* ast_read needs to lock channel */ ast_channel_unlock(c); if (earlyreplace || oneleggedreplace ) { /* Force the masq to happen */ if ((f = ast_read(replacecall))) { /* Force the masq to happen */ ast_frfree(f); f = NULL; if (option_debug > 3) ast_log(LOG_DEBUG, "Invite/Replace: Could successfully read frame from RING channel!\n"); } else { ast_log(LOG_WARNING, "Invite/Replace: Could not read frame from RING channel \n"); } c->hangupcause = AST_CAUSE_SWITCH_CONGESTION; ast_channel_unlock(replacecall); } else { /* Bridged call, UP channel */ if ((f = ast_read(replacecall))) { /* Force the masq to happen */ /* Masq ok */ ast_frfree(f); f = NULL; if (option_debug > 2) ast_log(LOG_DEBUG, "Invite/Replace: Could successfully read frame from channel! Masq done.\n"); } else { ast_log(LOG_WARNING, "Invite/Replace: Could not read frame from channel. Transfer failed\n"); } ast_channel_unlock(replacecall); } dialog_lock(p->refer->refer_call, FALSE); ast_setstate(c, AST_STATE_DOWN); if (option_debug > 3) { struct ast_channel *test; ast_log(LOG_DEBUG, "After transfer:----------------------------\n"); ast_log(LOG_DEBUG, " -- C: %s State %s\n", c->name, ast_state2str(c->_state)); if (replacecall) ast_log(LOG_DEBUG, " -- replacecall: %s State %s\n", replacecall->name, ast_state2str(replacecall->_state)); if (p->owner) { ast_log(LOG_DEBUG, " -- P->owner: %s State %s\n", p->owner->name, ast_state2str(p->owner->_state)); test = ast_bridged_channel(p->owner); if (test) ast_log(LOG_DEBUG, " -- Call bridged to P->owner: %s State %s\n", test->name, ast_state2str(test->_state)); else ast_log(LOG_DEBUG, " -- No call bridged to C->owner \n"); } else ast_log(LOG_DEBUG, " -- No channel yet \n"); ast_log(LOG_DEBUG, "End After transfer:----------------------------\n"); } ast_channel_unlock(p->owner); /* Unlock new owner */ dialog_lock(p, FALSE); /* The call should be down with no ast_channel, so hang it up */ c->tech_pvt = NULL; ast_hangup(c); return 0; }

GNURK int handle_request (  struct sip_dialog *  p, struct sip_request *  req, struct sockaddr_in *  sin, int *  recount, int *  nounlock )

Handle incoming SIP requests (methods). Note: This is where all incoming requests go first Definition at line 5263 of file chan_sip3.c. References __sip_ack(), append_history, ast_inet_ntoa(), ast_log(), ast_set_flag, ast_string_field_set, ast_strlen_zero(), ast_test_flag, check_pendings(), sip_request::cseqheader, debug(), DEFAULT_TRANS_TIMEOUT, DIALOG_STATE_TERMINATED, dialogstatechange(), error(), extract_uri(), FALSE, find_sdp(), sip_dialog::flags, sip_request::from, get_header(), gettag(), handle_request_bye(), handle_request_cancel(), handle_request_info(), handle_request_invite(), handle_request_message(), handle_request_notify(), handle_request_options(), handle_request_refer(), handle_request_register(), handle_request_subscribe(), handle_response(), sip_request::header, sip_dialog::initreq, len, LOG_ERROR, LOG_NOTICE, LOG_WARNING, sip_request::method, option_debug, process_sdp(), sip_request::rlPart1, sip_request::rlPart2, sip_request::seqno, SIP_ACK, SIP_ALREADYGONE, SIP_BYE, SIP_CANCEL, sip_debug_test_pvt(), SIP_INFO, SIP_INVITE, SIP_MESSAGE, sip_method2txt(), SIP_NEEDDESTROY, SIP_NOTIFY, SIP_OPTIONS, SIP_PKT_IGNORE, SIP_PKT_IGNORE_REQ, SIP_PKT_IGNORE_RESP, SIP_PKT_RESPONSE, SIP_PKT_WITH_TOTAG, SIP_REFER, SIP_REGISTER, SIP_RESPONSE, sip_scheddestroy(), SIP_SUBSCRIBE, sip_dialog::tag, transmit_response(), transmit_response_reliable(), transmit_response_with_attachment(), WITH_ALLOW, and XMIT_UNRELIABLE. { /* Called with p->lock held, as well as p->owner->lock if appropriate, keeping things relatively static */ //struct sip_request resp; const char *cmd; const char *cseq; const char *useragent; int len; int respid; int res = 0; int debug = sip_debug_test_pvt(p); char *e; int error = 0; /* Clear out potential response */ //memset(&resp, 0, sizeof(resp)); /* Get Method and Cseq */ cseq = req->cseqheader; cmd = req->header[0]; /* Must have Cseq */ if (ast_strlen_zero(cmd) || ast_strlen_zero(cseq)) { ast_log(LOG_ERROR, "Missing Cseq. Dropping this SIP message, it's incomplete.\n"); error = 1; } else { int seqno; /* Can we do this earlier in parse_request? */ if (!error && sscanf(cseq, "%d%n", &seqno, &len) != 1) { ast_log(LOG_ERROR, "No seqno in '%s'. Dropping incomplete message.\n", cmd); error = 1; } req->seqno = seqno; } if (error) { if (!p->initreq) /* New call */ ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); /* Make sure we destroy this dialog */ return -1; } /* Get the command XXX */ cmd = req->rlPart1; e = req->rlPart2; /* Save useragent of the client */ useragent = get_header(req, "User-Agent"); if (!ast_strlen_zero(useragent)) ast_string_field_set(p, useragent, useragent); /* Find out SIP method for incoming request */ if (req->method == SIP_RESPONSE) { /* Response to our request */ /* Response to our request -- Do some sanity checks */ if (!p->initreq) { if (option_debug) ast_log(LOG_DEBUG, "That's odd... Got a response on a call we dont know about. Cseq %d Cmd %s\n", req->seqno, cmd); ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); return 0; } else if (p->ocseq < req->seqno) { if (option_debug) ast_log(LOG_DEBUG, "Ignoring out of order response %d (expecting %d)\n", req->seqno, p->ocseq); return -1; } else if (p->ocseq != req->seqno) { /* ignore means "don't do anything with it" but still have to respond appropriately In fact, it really means that we have to resend the response but in this version of chan_sip we haven't got it in memory... */ ast_set_flag(req, SIP_PKT_IGNORE); ast_set_flag(req, SIP_PKT_IGNORE_RESP); append_history(p, "Ignore", "Ignoring this retransmit\n"); } e = ast_skip_blanks(e); if (sscanf(e, "%d %n", &respid, &len) != 1) { ast_log(LOG_WARNING, "Invalid response: '%s'\n", e); } else { /* More SIP ridiculousness, we have to ignore bogus contacts in 100 etc responses */ if ((respid == 200) || ((respid >= 300) && (respid <= 399))) extract_uri(p, req); handle_response(p, respid, e + len, req); } return 0; } /* New SIP request coming in (could be new request in existing SIP dialog as well...) */ p->method = req->method; /* Find out which SIP method they are using */ if (option_debug > 3) ast_log(LOG_DEBUG, "**** Received %s - Command in SIP %s\n", sip_method2txt(p->method), cmd); if (p->icseq && (p->icseq > req->seqno)) { if (option_debug) ast_log(LOG_DEBUG, "Ignoring too old SIP packet packet %d (expecting >= %d)\n", req->seqno, p->icseq); if (req->method != SIP_ACK) transmit_response(p, "503 Server error", req); /* We must respond according to RFC 3261 sec 12.2 */ return -1; } else if (p->icseq && p->icseq == req->seqno && req->method != SIP_ACK && (p->method != SIP_CANCEL || ast_test_flag(&p->flags[0], SIP_ALREADYGONE))) { /* ignore means "don't do anything with it" but still have to respond appropriately. We do this if we receive a repeat of the last sequence number */ ast_set_flag(req, SIP_PKT_IGNORE); ast_set_flag(req, SIP_PKT_IGNORE_REQ); if (option_debug > 2) ast_log(LOG_DEBUG, "Ignoring SIP message because of retransmit (%s Seqno %d, ours %d)\n", sip_method2txt(p->method), p->icseq, req->seqno); } if (req->seqno >= p->icseq) /* Next should follow monotonically (but not necessarily incrementally -- thanks again to the genius authors of SIP -- increasing */ p->icseq = req->seqno; /* Find their tag if we haven't got it */ if (ast_strlen_zero(p->theirtag)) { char tag[128]; gettag(req->from, tag, sizeof(tag)); ast_string_field_set(p, theirtag, tag); } snprintf(p->lastmsg, sizeof(p->lastmsg), "Rx: %s", cmd); /* If this is a request packet without a from tag, it's not correct according to RFC 3261 */ /* Check if this a new request in a new dialog with a totag already attached to it, RFC 3261 - section 12.2 - and we don't want to mess with recovery */ if ((!p->initreq) && ast_test_flag(req, SIP_PKT_WITH_TOTAG)) { /* If this is a first request and it got a to-tag, it is not for us */ if (!ast_test_flag(req, SIP_PKT_IGNORE) && req->method == SIP_INVITE) transmit_response_reliable(p, "481 Call/Transaction Does Not Exist", req); else if (req->method != SIP_ACK) transmit_response(p, "481 Call/Transaction Does Not Exist", req); sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); dialogstatechange(p, DIALOG_STATE_TERMINATED); return res; } /* Handle various incoming SIP methods in requests */ switch (p->method) { case SIP_OPTIONS: res = handle_request_options(p, req); break; case SIP_INVITE: res = handle_request_invite(p, req, debug, sin, recount, e); break; case SIP_REFER: res = handle_request_refer(p, req, debug, req->seqno, nounlock); break; case SIP_CANCEL: res = handle_request_cancel(p, req); break; case SIP_BYE: res = handle_request_bye(p, req); break; case SIP_MESSAGE: res = handle_request_message(p, req); break; case SIP_SUBSCRIBE: res = handle_request_subscribe(p, req, sin, e); break; case SIP_REGISTER: res = handle_request_register(p, req, sin, e); break; case SIP_INFO: handle_request_info(p, req); break; case SIP_NOTIFY: res = handle_request_notify(p, req, sin, e); break; case SIP_ACK: /* Make sure we don't ignore this */ /* ACK on 200 OK */ if (req->seqno == p->pendinginvite) { if (option_debug) ast_log(LOG_DEBUG, "Got ACK on 200 OK, this call setup is complete - %s Cseq %d\n", p->callid, req->seqno); p->pendinginvite = 0; __sip_ack(p, req->seqno, SIP_PKT_RESPONSE, 0, FALSE); if (find_sdp(req)) { if (process_sdp(p, req)) return -1; } check_pendings(p); } else if (option_debug) ast_log(LOG_DEBUG, "Got ACK that does not match dialog cseq, this is unexpected - %s Cseq %d Pending cseq %d\n", p->callid, req->seqno, p->pendinginvite); /* Got an ACK that we did not match with active dialog. We have given a final response */ if (!p->lastinvite && ast_strlen_zero(p->randdata)) ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); break; default: transmit_response_with_attachment(WITH_ALLOW, p, "501 Method Not Implemented", req, XMIT_UNRELIABLE); ast_log(LOG_NOTICE, "Unknown SIP command '%s' from '%s'\n", cmd, ast_inet_ntoa(p->sa.sin_addr)); /* If this is some new method, and we don't have a call, destroy it now */ if (!p->initreq) ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); break; } return res; }

static int handle_request_bye (  struct sip_dialog *  p, struct sip_request *  req )  [static]

Handle incoming BYE request. Definition at line 4858 of file chan_sip3.c. References append_history, ast_async_goto(), ast_bridged_channel(), AST_CONTROL_UNHOLD, ast_inet_ntoa(), ast_log(), ast_queue_control(), ast_queue_hangup(), ast_rtp_get_quality(), ast_set_flag, ast_string_field_set, ast_strlen_zero(), ast_test_flag, check_via(), ast_channel::context, context, sip_globals::default_context, DEFAULT_TRANS_TIMEOUT, sip_dialog::flags, get_also_info(), get_header(), global, sip_dialog::initreq, LOG_NOTICE, LOG_WARNING, option_debug, pbx_builtin_setvar_helper(), sip_dialog::pendinginvite, set_initreq(), SIP_ALREADYGONE, SIP_NO_HISTORY, SIP_OUTGOING, SIP_PKT_IGNORE, sip_scheddestroy(), stop_media_flows(), transmit_response(), and transmit_response_reliable(). { struct ast_channel *c=NULL; int res; struct ast_channel *bridged_to; char *audioqos = NULL, *videoqos = NULL; if (p->pendinginvite && !ast_test_flag(&p->flags[0], SIP_OUTGOING) && !ast_test_flag(req, SIP_PKT_IGNORE)) transmit_response_reliable(p, "487 Request Terminated", p->initreq); set_initreq(p, req); check_via(p, req); ast_set_flag(&p->flags[0], SIP_ALREADYGONE); if (p->rtp) { audioqos = ast_rtp_get_quality(p->rtp); if (p->owner) pbx_builtin_setvar_helper(p->owner, "RTPAUDIOQOS", audioqos); } if (p->vrtp) { videoqos = ast_rtp_get_quality(p->vrtp); if (p->owner) pbx_builtin_setvar_helper(p->owner, "RTPVIDEOQOS", videoqos); } /* Get RTCP quality before end of call */ if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY) || p->owner) { if (p->rtp) append_history(p, "RTCPaudio", "Quality:%s", audioqos); if (p->vrtp) append_history(p, "RTCPvideo", "Quality:%s", videoqos); } stop_media_flows(p); if (!ast_strlen_zero(get_header(req, "Also"))) { ast_log(LOG_NOTICE, "Client '%s' using deprecated BYE/Also transfer method. Ask vendor to support REFER instead\n", ast_inet_ntoa(p->recv.sin_addr)); if (ast_strlen_zero(p->context)) ast_string_field_set(p, context, global.default_context); res = get_also_info(p, req); if (!res) { c = p->owner; if (c) { bridged_to = ast_bridged_channel(c); if (bridged_to) { /* Don't actually hangup here... */ ast_queue_control(c, AST_CONTROL_UNHOLD); ast_async_goto(bridged_to, p->context, p->refer->refer_to,1); } else ast_queue_hangup(p->owner); } } else { ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_inet_ntoa(p->recv.sin_addr)); if (p->owner) ast_queue_hangup(p->owner); } } else if (p->owner) { ast_queue_hangup(p->owner); if (option_debug > 2) ast_log(LOG_DEBUG, "Received bye, issuing owner hangup\n"); } else { sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); if (option_debug > 2) ast_log(LOG_DEBUG, "Received bye, no owner, selfdestruct soon.\n"); } transmit_response(p, "200 OK", req); return 1; }

static int handle_request_cancel (  struct sip_dialog *  p, struct sip_request *  req )  [static]

Handle incoming CANCEL request. Definition at line 4829 of file chan_sip3.c. References ast_channel::_state, ast_log(), ast_queue_hangup(), ast_set_flag, AST_STATE_UP, check_via(), DEFAULT_TRANS_TIMEOUT, sip_dialog::flags, sip_dialog::initreq, option_debug, sip_dialog::owner, SIP_ALREADYGONE, sip_scheddestroy(), stop_media_flows(), transmit_response(), and transmit_response_reliable(). { check_via(p, req); ast_set_flag(&p->flags[0], SIP_ALREADYGONE); if (p->owner && p->owner->_state == AST_STATE_UP) { /* This call is up, cancel is ignored, we need a bye */ transmit_response(p, "200 OK", req); if (option_debug) ast_log(LOG_DEBUG, "Got CANCEL on an answered call. Ignoring... \n"); return 0; } stop_media_flows(p); if (p->owner) ast_queue_hangup(p->owner); else sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); if (p->initreq) { transmit_response_reliable(p, "487 Request Terminated", p->initreq); transmit_response(p, "200 OK", req); return 1; } else { transmit_response(p, "481 Call Leg Does Not Exist", req); return 0; } }

static void handle_request_info (  struct sip_dialog *  p, struct sip_request *  req )  [static]

Receive SIP INFO Message. Note: Doesn't read the duration of the DTMF signal Definition at line 3038 of file chan_sip3.c. References ast_bridged_channel(), ast_cdr_setuserfield(), AST_CONTROL_FLASH, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRAME_DTMF, ast_log(), ast_queue_control(), ast_queue_frame(), ast_strlen_zero(), ast_test_flag, ast_verbose(), ast_channel::cdr, DIALOG_STATE_TERMINATED, DIALOG_STATE_TRYING, dialogstatechange(), event, sip_dialog::flags, get_body(), get_header(), ast_frame::len, LOG_WARNING, sip_dialog::owner, SIP_PKT_IGNORE, SIP_USECLIENTCODE, sipdebug, sip_dialog::state, ast_frame::subclass, transmit_final_response(), transmit_response(), and XMIT_UNRELIABLE. { char buf[1024]; unsigned int event; const char *c = get_header(req, "Content-Type"); if (ast_test_flag(req, SIP_PKT_IGNORE)) { transmit_response(p, "200 OK", req); return; } /* All replies to INFO are final */ dialogstatechange(p, DIALOG_STATE_TERMINATED); /* Need to check the media/type */ if (!strcasecmp(c, "application/dtmf-relay") || !strcasecmp(c, "application/vnd.nortelnetworks.digits")) { unsigned int duration = 0; if (p->state == DIALOG_STATE_TRYING) { /* INFO outside of a dialog */ transmit_final_response(p, "481 Call leg/transaction does not exist", req, XMIT_UNRELIABLE); /* Should return error */ return; } /* Try getting the "signal=" part */ if (ast_strlen_zero(c = get_body(req, "Signal")) && ast_strlen_zero(c = get_body(req, "d"))) { ast_log(LOG_WARNING, "Unable to retrieve DTMF signal from INFO message from %s\n", p->callid); transmit_response(p, "200 OK", req); /* Should return error */ return; } else ast_copy_string(buf, c, sizeof(buf)); if (!ast_strlen_zero((c = get_body(req, "Duration")))) duration = atoi(c); if (!duration) duration = 100; /* 100 ms */ if (ast_strlen_zero(buf)) { /* Nothing there folks, move on. */ transmit_response(p, "200 OK", req); return; } /* We have a DTMF code in the attachment */ if (buf[0] == '*') event = 10; else if (buf[0] == '#') event = 11; else if ((buf[0] >= 'A') && (buf[0] <= 'D')) event = 12 + buf[0] - 'A'; else event = atoi(buf); if (event == 16) { /* send a FLASH event */ struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_FLASH, }; ast_queue_frame(p->owner, &f); if (sipdebug) ast_verbose("* DTMF-relay event received: FLASH\n"); } else { /* send a DTMF event */ struct ast_frame f = { AST_FRAME_DTMF, }; if (event < 10) { f.subclass = '0' + event; } else if (event < 11) { f.subclass = '*'; } else if (event < 12) { f.subclass = '#'; } else if (event < 16) { f.subclass = 'A' + (event - 12); } f.len = duration; ast_queue_frame(p->owner, &f); if (sipdebug) ast_verbose("* DTMF-relay event received: %c\n", f.subclass); } transmit_response(p, "200 OK", req); return; } else if (!strcasecmp(c, "application/media_control+xml")) { /* Eh, we'll just assume it's a fast picture update for now */ if (p->owner) ast_queue_control(p->owner, AST_CONTROL_VIDUPDATE); transmit_response(p, "200 OK", req); return; } else if (!ast_strlen_zero(c = get_header(req, "X-ClientCode"))) { /* Client code (from SNOM phone) */ if (ast_test_flag(&p->flags[0], SIP_USECLIENTCODE)) { if (p->owner && p->owner->cdr) ast_cdr_setuserfield(p->owner, c); if (p->owner && ast_bridged_channel(p->owner) && ast_bridged_channel(p->owner)->cdr) ast_cdr_setuserfield(ast_bridged_channel(p->owner), c); transmit_response(p, "200 OK", req); } else { transmit_response(p, "415 Unsupported media type", req); } return; } /* Other type of INFO message, not really understood by Asterisk */ /* if (get_msg_text(buf, sizeof(buf), req)) { */ ast_log(LOG_WARNING, "Unable to parse INFO message from %s. Content %s\n", p->callid, buf); transmit_response(p, "415 Unsupported media type", req); return; }

static int handle_request_invite (  struct sip_dialog *  p, struct sip_request *  req, int  debug, struct sockaddr_in *  sin, int *  recount, char *  e )  [static]

Handle incoming INVITE request. Note: If the INVITE has a Replaces header, it is part of an attended transfer. If so, we do not go through the dial plan but tries to find the active call and masquerade into it XXX: we should also check here does the other side supports t38 at all !!! XXX Definition at line 4359 of file chan_sip3.c. References ast_channel::_state, append_history, ast_bridged_channel(), AST_CAUSE_CALL_REJECTED, AST_CAUSE_NORMAL_CLEARING, ast_channel_lock, ast_channel_unlock, ast_hangup(), ast_log(), AST_PBX_CALL_LIMIT, AST_PBX_FAILED, ast_pbx_start(), AST_PBX_SUCCESS, ast_pickup_call(), ast_pickup_ext(), ast_rtp_setdtmf(), ast_rtp_setdtmfcompensate(), ast_set_flag, ast_setstate(), AST_STATE_DOWN, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_strdupa, ast_string_field_free, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_uri_decode(), ast_verbose(), AUTH_CHALLENGE_SENT, AUTH_FAKE_AUTH, sip_dialog::autokillid, build_contact(), build_route(), sip_dialog::capability, check_user(), check_via(), context, DEC_CALL_LIMIT, sip_globals::default_context, DEFAULT_TRANS_TIMEOUT, dialog_lock(), DIALOG_STATE_CONFIRMED, DIALOG_STATE_EARLY, DIALOG_STATE_PROCEEDING, DIALOG_STATE_TERMINATED, dialogstatechange(), error(), exten, extract_uri(), FALSE, find_sdp(), sip_dialog::flags, get_destination(), get_header(), get_rdnis(), get_sip_dialog_byid_locked(), global, handle_invite_replaces(), ast_channel::hangupcause, INC_CALL_LIMIT, sip_dialog::jointcapability, sip_dialog::lastinvite, LOG_NOTICE, LOG_WARNING, make_our_tag(), option_debug, sip_pvt::owner, sip_dialog::owner, parse_ok_contact(), parse_sip_options(), sip_dialog::pendinginvite, process_sdp(), sip_dialog::refer, sip_refer::refer_call, sip_dialog::rtp, S_OR, sip_request::seqno, set_initreq(), SIP_ALREADYGONE, sip_cancel_destroy(), SIP_DTMF, SIP_DTMF_INFO, sip_handle_t38_reinvite(), SIP_INVITE, sip_new(), SIP_NO_HISTORY, SIP_OPT_REPLACES, SIP_OUTGOING, SIP_PAGE2_ALLOWOVERLAP, SIP_PAGE2_RFC2833_COMPENSATE, SIP_PKT_IGNORE, sip_refer_allocate(), sip_scheddestroy(), sip_tech, sip_tech_info, sipdebug, sip_dialog::sipoptions, t38properties::state, strcasestr(), strsep(), sip_dialog::t38, T38_DISABLED, T38_ENABLED, T38_PEER_REINVITE, sip_dialog::tag, ast_channel::tech, ast_channel::tech_pvt, transmit_fake_auth_response(), transmit_final_response(), transmit_response(), transmit_response_reliable(), transmit_response_with_attachment(), transmit_response_with_unsupported(), TRUE, ast_channel_tech::type, sip_dialog::udptl, update_call_counter(), WITH_SDP, WITH_T38_SDP, XMIT_CRITICAL, XMIT_RELIABLE, and XMIT_UNRELIABLE. { int res = 1; int gotdest; const char *p_replaces; char *replace_id = NULL; const char *required; unsigned int required_profile = 0; struct ast_channel *c = NULL; /* New channel */ int error = 0; /* Find out what they support */ if (!p->sipoptions) { const char *supported = get_header(req, "Supported"); if (!ast_strlen_zero(supported)) parse_sip_options(p, supported); } /* Find out what they require */ required = get_header(req, "Require"); if (!ast_strlen_zero(required)) { required_profile = parse_sip_options(NULL, required); if (required_profile && required_profile != SIP_OPT_REPLACES) { /* At this point we only support REPLACES */ transmit_response_with_unsupported(p, "420 Bad extension (unsupported)", req, required); ast_log(LOG_WARNING,"Received SIP INVITE with unsupported required extension: %s\n", required); error = 1; } } /* Check if this is a loop */ if (!error && ast_test_flag(&p->flags[0], SIP_OUTGOING) && p->owner && (p->owner->_state != AST_STATE_UP)) { /* This is a call to ourself. Send ourselves an error code and stop processing immediately, as SIP really has no good mechanism for being able to call yourself */ /* we need to check the tags and the branch. If they're different, this is in fact a forked call through a SIP proxy somewhere. */ transmit_final_response(p, "482 Loop Detected", req, XMIT_RELIABLE); error = 1; } /* Check if we already have a pending invite. If so, then deny this one */ if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->pendinginvite) { /* We already have a pending invite. Sorry. You are on hold. */ transmit_response(p, "491 Request Pending", req); if (option_debug) ast_log(LOG_DEBUG, "Got INVITE on call where we already have pending INVITE, deferring that - %s\n", p->callid); /* No destruction here, we have a current dialog */ return 0; } if (error) { dialogstatechange(p, DIALOG_STATE_TERMINATED); if (!p->lastinvite) sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return 0; } p_replaces = get_header(req, "Replaces"); if (!ast_strlen_zero(p_replaces)) { /* We have a replaces header */ char *ptr; char *fromtag = NULL; char *totag = NULL; char *start, *to; if (p->owner) { if (option_debug > 2) ast_log(LOG_DEBUG, "INVITE w Replaces on existing call? Refusing action. [%s]\n", p->callid); transmit_response(p, "400 Bad request", req); /* The best way to not not accept the transfer */ /* Do not destroy existing call */ return -1; } if (sipdebug && option_debug > 2) ast_log(LOG_DEBUG, "INVITE part of call transfer. Replaces [%s]\n", p_replaces); /* Create a buffer we can manipulate */ replace_id = ast_strdupa(p_replaces); ast_uri_decode(replace_id); if (!p->refer && !sip_refer_allocate(p)) { append_history(p, "Xfer", "INVITE/Replace Failed. Out of memory."); transmit_final_response(p, "500 Server Internal Error", req, XMIT_RELIABLE); return -1; } /* Todo: (When we find phones that support this) if the replaces header contains ";early-only" we can only replace the call in early stage, not after it's up. If it's not in early mode, 486 Busy. */ /* Skip leading whitespace */ replace_id = ast_skip_blanks(replace_id); start = replace_id; while ( (ptr = strsep(&start, ";")) ) { ptr = ast_skip_blanks(ptr); /* XXX maybe unnecessary ? */ if ( (to = strcasestr(ptr, "to-tag=") ) ) totag = to + 7; /* skip the keyword */ else if ( (to = strcasestr(ptr, "from-tag=") ) ) { fromtag = to + 9; /* skip the keyword */ fromtag = strsep(&fromtag, "&"); /* trim what ? */ } } if (sipdebug && option_debug > 3) ast_log(LOG_DEBUG,"Invite/replaces: Will use Replace-Call-ID : %s Fromtag: %s Totag: %s\n", replace_id, fromtag ? fromtag : "<no from tag>", totag ? totag : "<no to tag>"); /* Try to find call that we are replacing If we have a Replaces header, we need to cancel that call if we succeed with this call */ if ((p->refer->refer_call = get_sip_dialog_byid_locked(replace_id, totag, fromtag)) == NULL) { ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existent call id (%s)!\n", replace_id); transmit_final_response(p, "481 Call leg Does not exit (Replaces)", req, XMIT_RELIABLE); error = 1; } /* At this point, bot the pvt and the owner of the call to be replaced is locked */ /* The matched call is the call from the transferer to Asterisk . We want to bridge the bridged part of the call to the incoming invite, thus taking over the refered call */ if (p->refer->refer_call == p) { ast_log(LOG_NOTICE, "INVITE with replaces into it's own call id (%s == %s)!\n", replace_id, p->callid); p->refer->refer_call = NULL; transmit_final_response(p, "400 Bad request", req, XMIT_RELIABLE); error = 1; } if (!error && !p->refer->refer_call->owner) { /* Oops, someting wrong anyway, no owner, no call */ ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existing call id (%s)!\n", replace_id); /* Check for better return code */ transmit_final_response(p, "481 Call leg Does not exit (Replaces)", req, XMIT_RELIABLE); error = 1; } if (!error && p->refer->refer_call->owner->_state != AST_STATE_RING && p->refer->refer_call->owner->_state != AST_STATE_UP ) { ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-ringing or active call id (%s)!\n", replace_id); transmit_final_response(p, "603 Declined (Replaces)", req, XMIT_RELIABLE); error = 1; } if (error) { /* Give up this dialog */ append_history(p, "Xfer", "INVITE/Replace Failed."); dialog_lock(p, FALSE); if (p->refer->refer_call) { dialog_lock(p->refer->refer_call, FALSE); ast_channel_unlock(p->refer->refer_call->owner); } return -1; } } /* Check if this is an INVITE that sets up a new dialog or a re-invite in an existing dialog */ if (!ast_test_flag(req, SIP_PKT_IGNORE)) { sip_cancel_destroy(p); /* This also counts as a pending invite */ p->pendinginvite = req->seqno; check_via(p, req); if (!p->owner) { /* Not a re-invite */ /* Use this as the basis */ set_initreq(p, req); if (debug) ast_verbose("Using INVITE request as basis request - %s\n", p->callid); append_history(p, "Invite", "New call: %s", p->callid); parse_ok_contact(p, req); } else { /* Re-invite on existing call */ /* Handle SDP here if we already have an owner */ if (find_sdp(req)) { if (process_sdp(p, req)) { transmit_response(p, "488 Not acceptable here", req); if (!p->lastinvite) sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return -1; } } else { p->jointcapability = p->capability; if (option_debug) ast_log(LOG_DEBUG, "Hm.... No sdp for the moment\n"); } if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) /* This is a response, note what it was for */ append_history(p, "ReInv", "Re-invite received"); } } else if (debug) ast_verbose("Ignoring this INVITE request\n"); if (!p->lastinvite && !ast_test_flag(req, SIP_PKT_IGNORE) && !p->owner) { /* This is a new invite */ /* Handle authentication if this is our first invite */ res = check_user(p, req, SIP_INVITE, e, XMIT_RELIABLE, sin); if (res == AUTH_CHALLENGE_SENT) return 0; if (res < 0) { /* Something failed in authentication */ if (res == AUTH_FAKE_AUTH) { ast_log(LOG_NOTICE, "Sending fake auth rejection for user %s\n", get_header(req, "From")); transmit_fake_auth_response(p, req, 1); } else { ast_log(LOG_NOTICE, "Failed to authenticate user %s\n", get_header(req, "From")); transmit_response_reliable(p, "403 Forbidden", req); } sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); ast_string_field_free(p, theirtag); return 0; } /* We have a succesful authentication, process the SDP portion if there is one */ if (find_sdp(req)) { if (process_sdp(p, req)) { /* Unacceptable codecs */ transmit_final_response(p, "488 Not acceptable here", req, XMIT_RELIABLE); if (option_debug) ast_log(LOG_DEBUG, "No compatible codecs for this SIP call.\n"); return -1; } } else { /* No SDP in invite, call control session */ p->jointcapability = p->capability; if (option_debug > 1) ast_log(LOG_DEBUG, "No SDP in Invite, third party call control\n"); } /* Initialize the context if it hasn't been already */ if (ast_strlen_zero(p->context)) ast_string_field_set(p, context, global.default_context); /* Check number of concurrent calls -vs- incoming limit HERE */ if (option_debug) ast_log(LOG_DEBUG, "Checking SIP call limits for device %s\n", p->peername); if ((res = update_call_counter(p, INC_CALL_LIMIT))) { if (res < 0) { ast_log(LOG_NOTICE, "Failed to place call for user %s, too many calls\n", p->peername); transmit_final_response(p, "480 Temporarily Unavailable", req, XMIT_RELIABLE); } return 0; } gotdest = get_destination(p, NULL); /* Get destination right away */ get_rdnis(p, NULL); /* Get redirect information */ extract_uri(p, req); /* Get the Contact URI */ build_contact(p); /* Build our contact header */ if (p->rtp) { ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) != SIP_DTMF_INFO); ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE)); } if (!replace_id && gotdest) { /* No matching extension found */ char *response; if (gotdest == 1 && ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWOVERLAP)) response = "484 Address Incomplete"; else response = "404 Not Found"; transmit_final_response(p, response, req, XMIT_RELIABLE); update_call_counter(p, DEC_CALL_LIMIT); return 0; } else { /* If no extension was specified, use the s one */ /* Basically for calling to IP/Host name only */ if (ast_strlen_zero(p->exten)) ast_string_field_set(p, exten, "s"); /* Initialize our tag */ make_our_tag(p->tag, sizeof(p->tag)); /* First invitation - create the channel */ c = sip_new(p, AST_STATE_DOWN, S_OR(p->peername, NULL)); *recount = 1; /* Save Record-Route for any later requests we make on this dialogue */ build_route(p, req, 0); if (c) /* Pre-lock the call */ ast_channel_lock(c); } } else { if (option_debug > 1 && sipdebug) { if (!ast_test_flag(req, SIP_PKT_IGNORE)) ast_log(LOG_DEBUG, "Got a SIP re-invite for call %s\n", p->callid); else ast_log(LOG_DEBUG, "Got a SIP re-transmit of INVITE for call %s\n", p->callid); } c = p->owner; } if (!ast_test_flag(req, SIP_PKT_IGNORE) && p) p->lastinvite = req->seqno; if (replace_id) { /* Attended transfer or call pickup - we're the target */ /* Go and take over the target call */ if (sipdebug && option_debug > 3) ast_log(LOG_DEBUG, "Sending this call to the invite/replcaes handler %s\n", p->callid); return handle_invite_replaces(p, req, debug, sin); } if (c) { /* We have a call -either a new call or an old one (RE-INVITE) */ switch(c->_state) { case AST_STATE_DOWN: if (option_debug > 1) ast_log(LOG_DEBUG, "%s: New call is still down.... Trying... \n", c->name); transmit_response(p, "100 Trying", req); ast_setstate(c, AST_STATE_RING); if (strcmp(p->exten, ast_pickup_ext())) { /* Call to extension -start pbx on this call */ enum ast_pbx_result res; const char *response = NULL; res = ast_pbx_start(c); switch(res) { case AST_PBX_FAILED: ast_log(LOG_WARNING, "Failed to start PBX :(\n"); response = "503 Unavailable"; break; case AST_PBX_CALL_LIMIT: ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n"); response = "480 Temporarily Unavailable"; break; case AST_PBX_SUCCESS: /* nothing to do */ break; } if (response) transmit_final_response(p, response, req, ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_RELIABLE); if (res) { /* Unlock locks so ast_hangup can do its magic */ ast_channel_unlock(c); dialog_lock(p, FALSE); ast_hangup(c); dialog_lock(p, TRUE); c = NULL; } } else { /* Pickup call in call group */ ast_channel_unlock(c); if (ast_pickup_call(c)) { ast_log(LOG_NOTICE, "Nothing to pick up for %s\n", p->callid); transmit_final_response(p, "503 Unavailable", req, ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_RELIABLE); ast_set_flag(&p->flags[0], SIP_ALREADYGONE); /* Unlock locks so ast_hangup can do its magic */ dialog_lock(p, FALSE); c->hangupcause = AST_CAUSE_CALL_REJECTED; } else { dialog_lock(p, FALSE); ast_setstate(c, AST_STATE_DOWN); c->hangupcause = AST_CAUSE_NORMAL_CLEARING; } ast_hangup(c); dialog_lock(p, TRUE); c = NULL; } break; case AST_STATE_RING: transmit_response(p, "100 Trying", req); if (!p->owner) dialogstatechange(p, DIALOG_STATE_PROCEEDING); break; case AST_STATE_RINGING: transmit_response(p, "180 Ringing", req); if (!p->owner) dialogstatechange(p, DIALOG_STATE_EARLY); break; case AST_STATE_UP: if (option_debug > 1) ast_log(LOG_DEBUG, "%s: This call is UP.... \n", c->name); if (p->t38.state == T38_PEER_REINVITE) { struct ast_channel *bridgepeer = NULL; struct sip_dialog *bridge_dialog = NULL; if ((bridgepeer = ast_bridged_channel(p->owner))) { /* We have a bridge, and this is re-invite to switchover to T38 so we send re-invite with T38 SDP, to other side of bridge*/ /*! XXX: we should also check here does the other side supports t38 at all !!! XXX */ if (!strcasecmp(bridgepeer->tech->type, "SIP")) { /* If we are bridged to SIP channel */ bridge_dialog = (struct sip_dialog*)bridgepeer->tech_pvt; if (bridge_dialog->t38.state == T38_DISABLED) { if (bridge_dialog->udptl) { /* If everything is OK with other side's udptl struct */ /* Send re-invite to the bridged channel */ sip_handle_t38_reinvite(bridgepeer, p, 1); } else { /* Something is wrong with peers udptl struct */ ast_log(LOG_WARNING, "Strange... The other side of the bridge don't have udptl struct\n"); dialog_lock(bridge_dialog, TRUE); bridge_dialog->t38.state = T38_DISABLED; dialog_lock(bridge_dialog, FALSE); if (option_debug > 1) ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", bridge_dialog->t38.state, bridgepeer->name); transmit_final_response(p, "488 Not Acceptable here", req, ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_RELIABLE); } } else { /* The other side is already setup for T.38 most likely so we need to acknowledge this too */ transmit_response_with_attachment(WITH_T38_SDP, p, "200 OK", req, XMIT_CRITICAL); dialogstatechange(p, DIALOG_STATE_CONFIRMED); p->t38.state = T38_ENABLED; if (option_debug) ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>"); } } else { /* Other side is not a SIP channel */ transmit_final_response(p, "488 Not Acceptable here", req, ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_RELIABLE); p->t38.state = T38_DISABLED; if (option_debug > 1) ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>"); } } else { /* we are not bridged in a call */ transmit_response_with_attachment(WITH_T38_SDP, p, "200 OK", req, XMIT_CRITICAL); dialogstatechange(p, DIALOG_STATE_CONFIRMED); p->t38.state = T38_ENABLED; if (option_debug) ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>"); } } else if (p->t38.state == T38_DISABLED) { /* Channel doesn't have T38 offered or enabled */ int sendok = TRUE; /* If we are bridged to a channel that has T38 enabled than this is a case of RTP re-invite after T38 session */ /* so handle it here (re-invite other party to RTP) */ struct ast_channel *bridgepeer = NULL; struct sip_dialog *bridge_dialog = NULL; if ((bridgepeer = ast_bridged_channel(p->owner))) { if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) { bridge_dialog = (struct sip_dialog*)bridgepeer->tech_pvt; /* Does the bridged peer have T38 ? */ if (bridge_dialog->t38.state == T38_ENABLED) { ast_log(LOG_WARNING, "RTP re-invite after T38 session not handled yet !\n"); /* Insted of this we should somehow re-invite the other side of the bridge to RTP */ transmit_final_response(p, "488 Not Acceptable here (unsupported)", req, ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_RELIABLE); sendok = FALSE; } /* No bridged peer with T38 enabled*/ } } /* This is a normal call and we can accept it - let's rock and roll! */ if (sendok) transmit_response_with_attachment(WITH_SDP, p, "200 OK", req, XMIT_CRITICAL); dialogstatechange(p, DIALOG_STATE_CONFIRMED); } break; default: ast_log(LOG_WARNING, "Don't know how to handle INVITE in state %d\n", c->_state); transmit_response(p, "100 Trying", req); break; } } else { if (p && (p->autokillid == -1)) { const char *msg; if (!p->jointcapability) msg = "488 Not Acceptable Here (codec error)"; else { ast_log(LOG_NOTICE, "Unable to create/find SIP channel for this INVITE\n"); msg = "503 Unavailable"; } transmit_final_response(p, msg, req, ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_RELIABLE); } } return res; }

static int handle_request_message (  struct sip_dialog *  p, struct sip_request *  req )  [static]

Handle incoming MESSAGE request. Definition at line 4929 of file chan_sip3.c. References ast_test_flag, ast_verbose(), receive_message(), SIP_PKT_DEBUG, SIP_PKT_IGNORE, transmit_final_response(), and XMIT_UNRELIABLE. { if (!ast_test_flag(req, SIP_PKT_IGNORE)) { if (ast_test_flag(req, SIP_PKT_DEBUG)) ast_verbose("Receiving message!\n"); receive_message(p, req); } else transmit_final_response(p, "202 Accepted", req, XMIT_UNRELIABLE); return 1; }

static int handle_request_notify (  struct sip_dialog *  p, struct sip_request *  req, struct sockaddr_in *  sin, char *  e )  [static]

Handle incoming notifications. Note: Out of dialog NOTIFY messages are killed in match_or_create_dialog() If implementing VMI support, that needs to change Definition at line 4046 of file chan_sip3.c. References ast_log(), DEFAULT_TRANS_TIMEOUT, event, FALSE, get_header(), get_msg_text(), sip_dialog::lastinvite, LOG_NOTICE, LOG_WARNING, option_debug, sip_scheddestroy(), sipdebug, transmit_response(), and TRUE. { /* This is mostly a skeleton for future improvements */ /* Mostly created to return proper answers on notifications on outbound REFER's */ int res = 0; const char *event = get_header(req, "Event"); char *eventid = NULL; char *sep; if( (sep = strchr(event, ';')) ) { /* XXX bug here - overwriting string ? */ *sep++ = '\0'; eventid = sep; } if (option_debug > 1 && sipdebug) ast_log(LOG_DEBUG, "Got NOTIFY Event: %s\n", event); if (strcmp(event, "refer")) { /* We don't understand this event. */ /* Here's room to implement incoming voicemail notifications :-) */ transmit_response(p, "489 Bad event", req); if (!p->lastinvite) sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return -1; } else { /* Save nesting depth for now, since there might be other events we will support in the future */ /* Handle REFER notifications */ char buf[1024]; char *cmd, *code; int respcode; int success = TRUE; /* EventID for each transfer... EventID is basically the REFER cseq We are getting notifications on a call that we transfered We should hangup when we are getting a 200 OK in a sipfrag Check if we have an owner of this event */ /* Check the content type */ if (strncasecmp(get_header(req, "Content-Type"), "message/sipfrag", strlen("message/sipfrag"))) { /* We need a sipfrag */ transmit_response(p, "400 Bad request", req); sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return -1; } /* Get the text of the attachment */ if (get_msg_text(buf, sizeof(buf), req)) { ast_log(LOG_WARNING, "Unable to retrieve attachment from NOTIFY %s\n", p->callid); transmit_response(p, "400 Bad request", req); sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return -1; } /* From the RFC... A minimal, but complete, implementation can respond with a single NOTIFY containing either the body: SIP/2.0 100 Trying if the subscription is pending, the body: SIP/2.0 200 OK if the reference was successful, the body: SIP/2.0 503 Service Unavailable if the reference failed, or the body: SIP/2.0 603 Declined if the REFER request was accepted before approval to follow the reference could be obtained and that approval was subsequently denied (see Section 2.4.7). If there are several REFERs in the same dialog, we need to match the ID of the event header... */ if (option_debug > 2) ast_log(LOG_DEBUG, "* SIP Transfer NOTIFY Attachment: \n---%s\n---\n", buf); cmd = ast_skip_blanks(buf); code = cmd; /* We are at SIP/2.0 */ while(*code && (*code > 32)) { /* Search white space */ code++; } *code++ = '\0'; code = ast_skip_blanks(code); sep = code; sep++; while(*sep && (*sep > 32)) { /* Search white space */ sep++; } *sep++ = '\0'; /* Response string */ respcode = atoi(code); switch (respcode) { case 100: /* Trying: */ /* Don't do anything yet */ break; case 183: /* Ringing: */ /* Don't do anything yet */ break; case 200: /* OK: The new call is up, hangup this call */ /* Hangup the call that we are replacing */ break; case 301: /* Moved permenantly */ case 302: /* Moved temporarily */ /* Do we get the header in the packet in this case? */ success = FALSE; break; case 503: /* Service Unavailable: The new call failed */ /* Cancel transfer, continue the call */ success = FALSE; break; case 603: /* Declined: Not accepted */ /* Cancel transfer, continue the current call */ success = FALSE; break; } if (!success) { ast_log(LOG_NOTICE, "Transfer failed. Sorry. Nothing further to do with this call\n"); } /* Confirm that we received this packet */ transmit_response(p, "200 OK", req); return res; }; }

static int handle_request_options (  struct sip_dialog *  p, struct sip_request *  req )  [static]

Handle incoming OPTIONS request. Definition at line 4175 of file chan_sip3.c. References ast_string_field_set, ast_strlen_zero(), build_contact(), context, sip_globals::default_context, DEFAULT_TRANS_TIMEOUT, get_destination(), global, sip_dialog::lastinvite, sip_scheddestroy(), transmit_response_with_attachment(), WITH_ALLOW, and XMIT_UNRELIABLE. { int res; res = get_destination(p, req); build_contact(p); /* XXX Should we authenticate OPTIONS? XXX */ if (ast_strlen_zero(p->context)) ast_string_field_set(p, context, global.default_context); if (res < 0) transmit_response_with_attachment(WITH_ALLOW, p, "404 Not Found", req, XMIT_UNRELIABLE); else transmit_response_with_attachment(WITH_ALLOW, p, "200 OK", req, XMIT_UNRELIABLE); /* Destroy if this OPTIONS was the opening request, but not if it's in the middle of a normal call flow. */ if (!p->lastinvite) sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return res; }

static int handle_request_register (  struct sip_dialog *  p, struct sip_request *  req, struct sockaddr_in *  sin, char *  e )  [static]

Handle incoming REGISTER request. Definition at line 5212 of file chan_sip3.c. References append_history, ast_inet_ntoa(), ast_log(), ast_test_flag, ast_verbose(), AUTH_NOT_FOUND, AUTH_SECRET_FAILED, AUTH_UNKNOWN_DOMAIN, AUTH_USERNAME_MISMATCH, check_via(), DEFAULT_TRANS_TIMEOUT, get_header(), LOG_NOTICE, option_debug, register_verify(), set_initreq(), SIP_PKT_DEBUG, and sip_scheddestroy(). { enum check_auth_result res; static int register_counter = 0; register_counter++; if (option_debug > 3) ast_log(LOG_DEBUG, "-REGISTRATIONS- register counter %d\n", register_counter); /* Use this as the basis */ if (ast_test_flag(req, SIP_PKT_DEBUG)) ast_verbose("Using latest REGISTER request as basis request\n"); set_initreq(p, req); check_via(p, req); if ((res = register_verify(p, sin, req, e)) < 0) { const char *reason = ""; switch (res) { case AUTH_SECRET_FAILED: reason = "Wrong password"; break; case AUTH_USERNAME_MISMATCH: reason = "Username/auth name mismatch"; break; case AUTH_NOT_FOUND: reason = "No matching peer found"; break; case AUTH_UNKNOWN_DOMAIN: reason = "Not a local domain"; break; default: break; } ast_log(LOG_NOTICE, "Registration from '%s' failed for '%s' - %s\n", get_header(req, "To"), ast_inet_ntoa(sin->sin_addr), reason); } if (res < 1) { /* Destroy the session, but keep us around for just a bit in case they don't get our 200 OK */ sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); } append_history(p, "RegRequest", "%s : Account %s", res ? "Failed": "Succeeded", get_header(req, "To")