Asterisk
/
asterisk
mirror of https://github.com/asterisk/asterisk
1
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '18.17'
${ noResults }
asterisk/channels/pjsip/dialplan_functions.c

1787 lines
60 KiB
Raw Permalink Blame History

/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2013, Digium, Inc.
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*!
* \file
*
* \author \verbatim Joshua Colp <jcolp@digium.com> \endverbatim
* \author \verbatim Matt Jordan <mjordan@digium.com> \endverbatim
*
* \ingroup functions
*
* \brief PJSIP channel dialplan functions
*/
/*** MODULEINFO
<support_level>core</support_level>
***/
/*** DOCUMENTATION
<function name="PJSIP_DIAL_CONTACTS" language="en_US">
<synopsis>
Return a dial string for dialing all contacts on an AOR.
</synopsis>
<syntax>
<parameter name="endpoint" required="true">
<para>Name of the endpoint</para>
</parameter>
<parameter name="aor" required="false">
<para>Name of an AOR to use, if not specified the configured AORs on the endpoint are used</para>
</parameter>
<parameter name="request_user" required="false">
<para>Optional request user to use in the request URI</para>
</parameter>
</syntax>
<description>
<para>Returns a properly formatted dial string for dialing all contacts on an AOR.</para>
</description>
</function>
<function name="PJSIP_MEDIA_OFFER" language="en_US">
<synopsis>
Media and codec offerings to be set on an outbound SIP channel prior to dialing.
</synopsis>
<syntax>
<parameter name="media" required="true">
<para>types of media offered</para>
</parameter>
</syntax>
<description>
<para>When read, returns the codecs offered based upon the media choice.</para>
<para>When written, sets the codecs to offer when an outbound dial attempt is made,
or when a session refresh is sent using <replaceable>PJSIP_SEND_SESSION_REFRESH</replaceable>.
</para>
</description>
<see-also>
<ref type="function">PJSIP_SEND_SESSION_REFRESH</ref>
</see-also>
</function>
<function name="PJSIP_DTMF_MODE" language="en_US">
<since>
<version>13.18.0</version>
<version>14.7.0</version>
<version>15.1.0</version>
<version>16.0.0</version>
</since>
<synopsis>
Get or change the DTMF mode for a SIP call.
</synopsis>
<syntax>
</syntax>
<description>
<para>When read, returns the current DTMF mode</para>
<para>When written, sets the current DTMF mode</para>
<para>This function uses the same DTMF mode naming as the dtmf_mode configuration option</para>
</description>
</function>
<function name="PJSIP_MOH_PASSTHROUGH" language="en_US">
<synopsis>
Get or change the on-hold behavior for a SIP call.
</synopsis>
<syntax>
</syntax>
<description>
<para>When read, returns the current moh passthrough mode</para>
<para>When written, sets the current moh passthrough mode</para>
<para>If <replaceable>yes</replaceable>, on-hold re-INVITEs are sent. If <replaceable>no</replaceable>, music on hold is generated.</para>
<para>This function can be used to override the moh_passthrough configuration option</para>
</description>
</function>
<function name="PJSIP_SEND_SESSION_REFRESH" language="en_US">
<since>
<version>13.12.0</version>
<version>14.1.0</version>
<version>15.0.0</version>
</since>
<synopsis>
W/O: Initiate a session refresh via an UPDATE or re-INVITE on an established media session
</synopsis>
<syntax>
<parameter name="update_type" required="false">
<para>The type of update to send. Default is <literal>invite</literal>.</para>
<enumlist>
<enum name="invite">
<para>Send the session refresh as a re-INVITE.</para>
</enum>
<enum name="update">
<para>Send the session refresh as an UPDATE.</para>
</enum>
</enumlist>
</parameter>
</syntax>
<description>
<para>This function will cause the PJSIP stack to immediately refresh
the media session for the channel. This will be done using either a
re-INVITE (default) or an UPDATE request.
</para>
<para>This is most useful when combined with the <replaceable>PJSIP_MEDIA_OFFER</replaceable>
dialplan function, as it allows the formats in use on a channel to be
re-negotiated after call setup.</para>
<warning>
<para>The formats the endpoint supports are <emphasis>not</emphasis>
checked or enforced by this function. Using this function to offer
formats not supported by the endpoint <emphasis>may</emphasis> result
in a loss of media.</para>
</warning>
<example title="Re-negotiate format to g722">
; Within some existing extension on an answered channel
same => n,Set(PJSIP_MEDIA_OFFER(audio)=!all,g722)
same => n,Set(PJSIP_SEND_SESSION_REFRESH()=invite)
</example>
</description>
<see-also>
<ref type="function">PJSIP_MEDIA_OFFER</ref>
</see-also>
</function>
<function name="PJSIP_PARSE_URI" language="en_US">
<since>
<version>13.24.0</version>
<version>16.1.0</version>
<version>17.0.0</version>
</since>
<synopsis>
Parse an uri and return a type part of the URI.
</synopsis>
<syntax>
<parameter name="uri" required="true">
<para>URI to parse</para>
</parameter>
<parameter name="type" required="true">
<para>The <literal>type</literal> parameter specifies which URI part to read</para>
<enumlist>
<enum name="display">
<para>Display name.</para>
</enum>
<enum name="scheme">
<para>URI scheme.</para>
</enum>
<enum name="user">
<para>User part.</para>
</enum>
<enum name="passwd">
<para>Password part.</para>
</enum>
<enum name="host">
<para>Host part.</para>
</enum>
<enum name="port">
<para>Port number, or zero.</para>
</enum>
<enum name="user_param">
<para>User parameter.</para>
</enum>
<enum name="method_param">
<para>Method parameter.</para>
</enum>
<enum name="transport_param">
<para>Transport parameter.</para>
</enum>
<enum name="ttl_param">
<para>TTL param, or -1.</para>
</enum>
<enum name="lr_param">
<para>Loose routing param, or zero.</para>
</enum>
<enum name="maddr_param">
<para>Maddr param.</para>
</enum>
</enumlist>
</parameter>
</syntax>
<description>
<para>Parse an URI and return a specified part of the URI.</para>
</description>
</function>
<info name="CHANNEL" language="en_US" tech="PJSIP">
<enumlist>
<enum name="rtp">
<para>R/O Retrieve media related information.</para>
<parameter name="type" required="true">
<para>When <replaceable>rtp</replaceable> is specified, the
<literal>type</literal> parameter must be provided. It specifies
which RTP parameter to read.</para>
<enumlist>
<enum name="src">
<para>Retrieve the local address for RTP.</para>
</enum>
<enum name="dest">
<para>Retrieve the remote address for RTP.</para>
</enum>
<enum name="direct">
<para>If direct media is enabled, this address is the remote address
used for RTP.</para>
</enum>
<enum name="secure">
<para>Whether or not the media stream is encrypted.</para>
<enumlist>
<enum name="0">
<para>The media stream is not encrypted.</para>
</enum>
<enum name="1">
<para>The media stream is encrypted.</para>
</enum>
</enumlist>
</enum>
<enum name="hold">
<para>Whether or not the media stream is currently restricted
due to a call hold.</para>
<enumlist>
<enum name="0">
<para>The media stream is not held.</para>
</enum>
<enum name="1">
<para>The media stream is held.</para>
</enum>
</enumlist>
</enum>
</enumlist>
</parameter>
<parameter name="media_type" required="false">
<para>When <replaceable>rtp</replaceable> is specified, the
<literal>media_type</literal> parameter may be provided. It specifies
which media stream the chosen RTP parameter should be retrieved
from.</para>
<enumlist>
<enum name="audio">
<para>Retrieve information from the audio media stream.</para>
<note><para>If not specified, <literal>audio</literal> is used
by default.</para></note>
</enum>
<enum name="video">
<para>Retrieve information from the video media stream.</para>
</enum>
</enumlist>
</parameter>
</enum>
<enum name="rtcp">
<para>R/O Retrieve RTCP statistics.</para>
<parameter name="statistic" required="true">
<para>When <replaceable>rtcp</replaceable> is specified, the
<literal>statistic</literal> parameter must be provided. It specifies
which RTCP statistic parameter to read.</para>
<enumlist>
<enum name="all">
<para>Retrieve a summary of all RTCP statistics.</para>
<para>The following data items are returned in a semi-colon
delineated list:</para>
<enumlist>
<enum name="ssrc">
<para>Our Synchronization Source identifier</para>
</enum>
<enum name="themssrc">
<para>Their Synchronization Source identifier</para>
</enum>
<enum name="lp">
<para>Our lost packet count</para>
</enum>
<enum name="rxjitter">
<para>Received packet jitter</para>
</enum>
<enum name="rxcount">
<para>Received packet count</para>
</enum>
<enum name="txjitter">
<para>Transmitted packet jitter</para>
</enum>
<enum name="txcount">
<para>Transmitted packet count</para>
</enum>
<enum name="rlp">
<para>Remote lost packet count</para>
</enum>
<enum name="rtt">
<para>Round trip time</para>
</enum>
<enum name="txmes">
<para>Transmitted Media Experience Score</para>
</enum>
<enum name="rxmes">
<para>Received Media Experience Score</para>
</enum>
</enumlist>
</enum>
<enum name="all_jitter">
<para>Retrieve a summary of all RTCP Jitter statistics.</para>
<para>The following data items are returned in a semi-colon
delineated list:</para>
<enumlist>
<enum name="minrxjitter">
<para>Our minimum jitter</para>
</enum>
<enum name="maxrxjitter">
<para>Our max jitter</para>
</enum>
<enum name="avgrxjitter">
<para>Our average jitter</para>
</enum>
<enum name="stdevrxjitter">
<para>Our jitter standard deviation</para>
</enum>
<enum name="reported_minjitter">
<para>Their minimum jitter</para>
</enum>
<enum name="reported_maxjitter">
<para>Their max jitter</para>
</enum>
<enum name="reported_avgjitter">
<para>Their average jitter</para>
</enum>
<enum name="reported_stdevjitter">
<para>Their jitter standard deviation</para>
</enum>
</enumlist>
</enum>
<enum name="all_loss">
<para>Retrieve a summary of all RTCP packet loss statistics.</para>
<para>The following data items are returned in a semi-colon
delineated list:</para>
<enumlist>
<enum name="minrxlost">
<para>Our minimum lost packets</para>
</enum>
<enum name="maxrxlost">
<para>Our max lost packets</para>
</enum>
<enum name="avgrxlost">
<para>Our average lost packets</para>
</enum>
<enum name="stdevrxlost">
<para>Our lost packets standard deviation</para>
</enum>
<enum name="reported_minlost">
<para>Their minimum lost packets</para>
</enum>
<enum name="reported_maxlost">
<para>Their max lost packets</para>
</enum>
<enum name="reported_avglost">
<para>Their average lost packets</para>
</enum>
<enum name="reported_stdevlost">
<para>Their lost packets standard deviation</para>
</enum>
</enumlist>
</enum>
<enum name="all_rtt">
<para>Retrieve a summary of all RTCP round trip time information.</para>
<para>The following data items are returned in a semi-colon
delineated list:</para>
<enumlist>
<enum name="minrtt">
<para>Minimum round trip time</para>
</enum>
<enum name="maxrtt">
<para>Maximum round trip time</para>
</enum>
<enum name="avgrtt">
<para>Average round trip time</para>
</enum>
<enum name="stdevrtt">
<para>Standard deviation round trip time</para>
</enum>
</enumlist>
</enum>
<enum name="all_mes">
<para>Retrieve a summary of all RTCP Media Experience Score information.</para>
<para>The following data items are returned in a semi-colon
delineated list:</para>
<enumlist>
<enum name="minmes">
<para>Minimum MES based on us analysing received packets.</para>
</enum>
<enum name="maxmes">
<para>Maximum MES based on us analysing received packets.</para>
</enum>
<enum name="avgmes">
<para>Average MES based on us analysing received packets.</para>
</enum>
<enum name="stdevmes">
<para>Standard deviation MES based on us analysing received packets.</para>
</enum>
<enum name="reported_minmes">
<para>Minimum MES based on data we get in Sender and Receiver Reports sent by the remote end</para>
</enum>
<enum name="reported_maxmes">
<para>Maximum MES based on data we get in Sender and Receiver Reports sent by the remote end</para>
</enum>
<enum name="reported_avgmes">
<para>Average MES based on data we get in Sender and Receiver Reports sent by the remote end</para>
</enum>
<enum name="reported_stdevmes">
<para>Standard deviation MES based on data we get in Sender and Receiver Reports sent by the remote end</para>
</enum>
</enumlist>
</enum>
<enum name="txcount"><para>Transmitted packet count</para></enum>
<enum name="rxcount"><para>Received packet count</para></enum>
<enum name="txjitter"><para>Transmitted packet jitter</para></enum>
<enum name="rxjitter"><para>Received packet jitter</para></enum>
<enum name="remote_maxjitter"><para>Their max jitter</para></enum>
<enum name="remote_minjitter"><para>Their minimum jitter</para></enum>
<enum name="remote_normdevjitter"><para>Their average jitter</para></enum>
<enum name="remote_stdevjitter"><para>Their jitter standard deviation</para></enum>
<enum name="local_maxjitter"><para>Our max jitter</para></enum>
<enum name="local_minjitter"><para>Our minimum jitter</para></enum>
<enum name="local_normdevjitter"><para>Our average jitter</para></enum>
<enum name="local_stdevjitter"><para>Our jitter standard deviation</para></enum>
<enum name="txploss"><para>Transmitted packet loss</para></enum>
<enum name="rxploss"><para>Received packet loss</para></enum>
<enum name="remote_maxrxploss"><para>Their max lost packets</para></enum>
<enum name="remote_minrxploss"><para>Their minimum lost packets</para></enum>
<enum name="remote_normdevrxploss"><para>Their average lost packets</para></enum>
<enum name="remote_stdevrxploss"><para>Their lost packets standard deviation</para></enum>
<enum name="local_maxrxploss"><para>Our max lost packets</para></enum>
<enum name="local_minrxploss"><para>Our minimum lost packets</para></enum>
<enum name="local_normdevrxploss"><para>Our average lost packets</para></enum>
<enum name="local_stdevrxploss"><para>Our lost packets standard deviation</para></enum>
<enum name="rtt"><para>Round trip time</para></enum>
<enum name="maxrtt"><para>Maximum round trip time</para></enum>
<enum name="minrtt"><para>Minimum round trip time</para></enum>
<enum name="normdevrtt"><para>Average round trip time</para></enum>
<enum name="stdevrtt"><para>Standard deviation round trip time</para></enum>
<enum name="local_ssrc"><para>Our Synchronization Source identifier</para></enum>
<enum name="remote_ssrc"><para>Their Synchronization Source identifier</para></enum>
<enum name="txmes"><para>
Current MES based on us analyzing rtt, jitter and loss
in the actual received RTP stream received from the remote end.
I.E. This is the MES for the incoming audio stream.
</para></enum>
<enum name="rxmes"><para>
Current MES based on rtt and the jitter and loss values in
RTCP sender and receiver reports we receive from the
remote end. I.E. This is the MES for the outgoing audio stream.
</para></enum>
<enum name="remote_maxmes"><para>Max MES based on data we get in Sender and Receiver Reports sent by the remote end</para></enum>
<enum name="remote_minmes"><para>Min MES based on data we get in Sender and Receiver Reports sent by the remote end</para></enum>
<enum name="remote_normdevmes"><para>Average MES based on data we get in Sender and Receiver Reports sent by the remote end</para></enum>
<enum name="remote_stdevmes"><para>Standard deviation MES based on data we get in Sender and Receiver Reports sent by the remote end</para></enum>
<enum name="local_maxmes"><para>Max MES based on us analyzing the received RTP stream</para></enum>
<enum name="local_minmes"><para>Min MES based on us analyzing the received RTP stream</para></enum>
<enum name="local_normdevmes"><para>Average MES based on us analyzing the received RTP stream</para></enum>
<enum name="local_stdevmes"><para>Standard deviation MES based on us analyzing the received RTP stream</para></enum>
</enumlist>
</parameter>
<parameter name="media_type" required="false">
<para>When <replaceable>rtcp</replaceable> is specified, the
<literal>media_type</literal> parameter may be provided. It specifies
which media stream the chosen RTCP parameter should be retrieved
from.</para>
<enumlist>
<enum name="audio">
<para>Retrieve information from the audio media stream.</para>
<note><para>If not specified, <literal>audio</literal> is used
by default.</para></note>
</enum>
<enum name="video">
<para>Retrieve information from the video media stream.</para>
</enum>
</enumlist>
</parameter>
</enum>
<enum name="endpoint">
<para>R/O The name of the endpoint associated with this channel.
Use the <replaceable>PJSIP_ENDPOINT</replaceable> function to obtain
further endpoint related information.</para>
</enum>
<enum name="contact">
<para>R/O The name of the contact associated with this channel.
Use the <replaceable>PJSIP_CONTACT</replaceable> function to obtain
further contact related information. Note this may not be present and if so
is only available on outgoing legs.</para>
</enum>
<enum name="aor">
<para>R/O The name of the AOR associated with this channel.
Use the <replaceable>PJSIP_AOR</replaceable> function to obtain
further AOR related information. Note this may not be present and if so
is only available on outgoing legs.</para>
</enum>
<enum name="pjsip">
<para>R/O Obtain information about the current PJSIP channel and its
session.</para>
<parameter name="type" required="true">
<para>When <replaceable>pjsip</replaceable> is specified, the
<literal>type</literal> parameter must be provided. It specifies
which signalling parameter to read.</para>
<enumlist>
<enum name="call-id">
<para>The SIP call-id.</para>
</enum>
<enum name="secure">
<para>Whether or not the signalling uses a secure transport.</para>
<enumlist>
<enum name="0"><para>The signalling uses a non-secure transport.</para></enum>
<enum name="1"><para>The signalling uses a secure transport.</para></enum>
</enumlist>
</enum>
<enum name="target_uri">
<para>The contact URI where requests are sent.</para>
</enum>
<enum name="local_uri">
<para>The local URI.</para>
</enum>
<enum name="local_tag">
<para>Tag in From header</para>
</enum>
<enum name="remote_uri">
<para>The remote URI.</para>
</enum>
<enum name="remote_tag">
<para>Tag in To header</para>
</enum>
<enum name="request_uri">
<para>The request URI of the incoming <literal>INVITE</literal>
associated with the creation of this channel.</para>
</enum>
<enum name="t38state">
<para>The current state of any T.38 fax on this channel.</para>
<enumlist>
<enum name="DISABLED"><para>T.38 faxing is disabled on this channel.</para></enum>
<enum name="LOCAL_REINVITE"><para>Asterisk has sent a <literal>re-INVITE</literal> to the remote end to initiate a T.38 fax.</para></enum>
<enum name="REMOTE_REINVITE"><para>The remote end has sent a <literal>re-INVITE</literal> to Asterisk to initiate a T.38 fax.</para></enum>
<enum name="ENABLED"><para>A T.38 fax session has been enabled.</para></enum>
<enum name="REJECTED"><para>A T.38 fax session was attempted but was rejected.</para></enum>
</enumlist>
</enum>
<enum name="local_addr">
<para>On inbound calls, the full IP address and port number that
the <literal>INVITE</literal> request was received on. On outbound
calls, the full IP address and port number that the <literal>INVITE</literal>
request was transmitted from.</para>
</enum>
<enum name="remote_addr">
<para>On inbound calls, the full IP address and port number that
the <literal>INVITE</literal> request was received from. On outbound
calls, the full IP address and port number that the <literal>INVITE</literal>
request was transmitted to.</para>
</enum>
</enumlist>
</parameter>
</enum>
</enumlist>
</info>
<info name="CHANNEL_EXAMPLES" language="en_US" tech="PJSIP">
<example title="PJSIP specific CHANNEL examples">
; Log the current Call-ID
same => n,Log(NOTICE, ${CHANNEL(pjsip,call-id)})
; Log the destination address of the audio stream
same => n,Log(NOTICE, ${CHANNEL(rtp,dest)})
; Store the round-trip time associated with a
; video stream in the CDR field video-rtt
same => n,Set(CDR(video-rtt)=${CHANNEL(rtcp,rtt,video)})
</example>
</info>
***/
#include "asterisk.h"
#include <pjsip.h>
#include <pjlib.h>
#include <pjsip_ua.h>
#include "asterisk/astobj2.h"
#include "asterisk/module.h"
#include "asterisk/acl.h"
#include "asterisk/app.h"
#include "asterisk/channel.h"
#include "asterisk/stream.h"
#include "asterisk/format.h"
#include "asterisk/dsp.h"
#include "asterisk/pbx.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_session.h"
#include "include/chan_pjsip.h"
#include "include/dialplan_functions.h"
/*!
* \brief String representations of the T.38 state enum
*/
static const char *t38state_to_string[T38_MAX_ENUM] = {
[T38_DISABLED] = "DISABLED",
[T38_LOCAL_REINVITE] = "LOCAL_REINVITE",
[T38_PEER_REINVITE] = "REMOTE_REINVITE",
[T38_ENABLED] = "ENABLED",
[T38_REJECTED] = "REJECTED",
};
/*!
* \internal \brief Handle reading RTP information
*/
static int channel_read_rtp(struct ast_channel *chan, const char *type, const char *field, char *buf, size_t buflen)
{
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
struct ast_sip_session *session;
struct ast_sip_session_media *media;
struct ast_sockaddr addr;
if (!channel) {
ast_log(AST_LOG_WARNING, "Channel %s has no pvt!\n", ast_channel_name(chan));
return -1;
}
session = channel->session;
if (!session) {
ast_log(AST_LOG_WARNING, "Channel %s has no session!\n", ast_channel_name(chan));
return -1;
}
if (ast_strlen_zero(type)) {
ast_log(AST_LOG_WARNING, "You must supply a type field for 'rtp' information\n");
return -1;
}
if (ast_strlen_zero(field) || !strcmp(field, "audio")) {
media = session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
} else if (!strcmp(field, "video")) {
media = session->active_media_state->default_session[AST_MEDIA_TYPE_VIDEO];
} else {
ast_log(AST_LOG_WARNING, "Unknown media type field '%s' for 'rtp' information\n", field);
return -1;
}
if (!media || !media->rtp) {
ast_log(AST_LOG_WARNING, "Channel %s has no %s media/RTP session\n",
ast_channel_name(chan), S_OR(field, "audio"));
return -1;
}
if (!strcmp(type, "src")) {
ast_rtp_instance_get_local_address(media->rtp, &addr);
ast_copy_string(buf, ast_sockaddr_stringify(&addr), buflen);
} else if (!strcmp(type, "dest")) {
ast_rtp_instance_get_remote_address(media->rtp, &addr);
ast_copy_string(buf, ast_sockaddr_stringify(&addr), buflen);
} else if (!strcmp(type, "direct")) {
ast_copy_string(buf, ast_sockaddr_stringify(&media->direct_media_addr), buflen);
} else if (!strcmp(type, "secure")) {
if (media->srtp) {
struct ast_sdp_srtp *srtp = media->srtp;
int flag = ast_test_flag(srtp, AST_SRTP_CRYPTO_OFFER_OK);
snprintf(buf, buflen, "%d", flag ? 1 : 0);
} else {
snprintf(buf, buflen, "%d", 0);
}
} else if (!strcmp(type, "hold")) {
snprintf(buf, buflen, "%d", media->remotely_held ? 1 : 0);
} else {
ast_log(AST_LOG_WARNING, "Unknown type field '%s' specified for 'rtp' information\n", type);
return -1;
}
return 0;
}
/*!
* \internal \brief Handle reading RTCP information
*/
static int channel_read_rtcp(struct ast_channel *chan, const char *type, const char *field, char *buf, size_t buflen)
{
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
struct ast_sip_session *session;
struct ast_sip_session_media *media;
if (!channel) {
ast_log(AST_LOG_WARNING, "Channel %s has no pvt!\n", ast_channel_name(chan));
return -1;
}
session = channel->session;
if (!session) {
ast_log(AST_LOG_WARNING, "Channel %s has no session!\n", ast_channel_name(chan));
return -1;
}
if (ast_strlen_zero(type)) {
ast_log(AST_LOG_WARNING, "You must supply a type field for 'rtcp' information\n");
return -1;
}
if (ast_strlen_zero(field) || !strcmp(field, "audio")) {
media = session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
} else if (!strcmp(field, "video")) {
media = session->active_media_state->default_session[AST_MEDIA_TYPE_VIDEO];
} else {
ast_log(AST_LOG_WARNING, "Unknown media type field '%s' for 'rtcp' information\n", field);
return -1;
}
if (!media || !media->rtp) {
ast_log(AST_LOG_WARNING, "Channel %s has no %s media/RTP session\n",
ast_channel_name(chan), S_OR(field, "audio"));
return -1;
}
if (!strncasecmp(type, "all", 3)) {
enum ast_rtp_instance_stat_field stat_field = AST_RTP_INSTANCE_STAT_FIELD_QUALITY;
if (!strcasecmp(type, "all_jitter")) {
stat_field = AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER;
} else if (!strcasecmp(type, "all_rtt")) {
stat_field = AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT;
} else if (!strcasecmp(type, "all_loss")) {
stat_field = AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS;
} else if (!strcasecmp(type, "all_mes")) {
stat_field = AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES;
}
if (!ast_rtp_instance_get_quality(media->rtp, stat_field, buf, buflen)) {
ast_log(AST_LOG_WARNING, "Unable to retrieve 'rtcp' statistics for %s\n", ast_channel_name(chan));
return -1;
}
} else {
struct ast_rtp_instance_stats stats;
int i;
struct {
const char *name;
enum { INT, DBL } type;
union {
unsigned int *i4;
double *d8;
};
} lookup[] = {
{ "txcount", INT, { .i4 = &stats.txcount, }, },
{ "rxcount", INT, { .i4 = &stats.rxcount, }, },
{ "txjitter", DBL, { .d8 = &stats.txjitter, }, },
{ "rxjitter", DBL, { .d8 = &stats.rxjitter, }, },
{ "remote_maxjitter", DBL, { .d8 = &stats.remote_maxjitter, }, },
{ "remote_minjitter", DBL, { .d8 = &stats.remote_minjitter, }, },
{ "remote_normdevjitter", DBL, { .d8 = &stats.remote_normdevjitter, }, },
{ "remote_stdevjitter", DBL, { .d8 = &stats.remote_stdevjitter, }, },
{ "local_maxjitter", DBL, { .d8 = &stats.local_maxjitter, }, },
{ "local_minjitter", DBL, { .d8 = &stats.local_minjitter, }, },
{ "local_normdevjitter", DBL, { .d8 = &stats.local_normdevjitter, }, },
{ "local_stdevjitter", DBL, { .d8 = &stats.local_stdevjitter, }, },
{ "txploss", INT, { .i4 = &stats.txploss, }, },
{ "rxploss", INT, { .i4 = &stats.rxploss, }, },
{ "remote_maxrxploss", DBL, { .d8 = &stats.remote_maxrxploss, }, },
{ "remote_minrxploss", DBL, { .d8 = &stats.remote_minrxploss, }, },
{ "remote_normdevrxploss", DBL, { .d8 = &stats.remote_normdevrxploss, }, },
{ "remote_stdevrxploss", DBL, { .d8 = &stats.remote_stdevrxploss, }, },
{ "local_maxrxploss", DBL, { .d8 = &stats.local_maxrxploss, }, },
{ "local_minrxploss", DBL, { .d8 = &stats.local_minrxploss, }, },
{ "local_normdevrxploss", DBL, { .d8 = &stats.local_normdevrxploss, }, },
{ "local_stdevrxploss", DBL, { .d8 = &stats.local_stdevrxploss, }, },
{ "rtt", DBL, { .d8 = &stats.rtt, }, },
{ "maxrtt", DBL, { .d8 = &stats.maxrtt, }, },
{ "minrtt", DBL, { .d8 = &stats.minrtt, }, },
{ "normdevrtt", DBL, { .d8 = &stats.normdevrtt, }, },
{ "stdevrtt", DBL, { .d8 = &stats.stdevrtt, }, },
{ "local_ssrc", INT, { .i4 = &stats.local_ssrc, }, },
{ "remote_ssrc", INT, { .i4 = &stats.remote_ssrc, }, },
{ "txmes", DBL, { .d8 = &stats.txmes, }, },
{ "rxmes", DBL, { .d8 = &stats.rxmes, }, },
{ "remote_maxmes", DBL, { .d8 = &stats.remote_maxmes, }, },
{ "remote_minmes", DBL, { .d8 = &stats.remote_minmes, }, },
{ "remote_normdevmes", DBL, { .d8 = &stats.remote_normdevmes, }, },
{ "remote_stdevmes", DBL, { .d8 = &stats.remote_stdevmes, }, },
{ "local_maxmes", DBL, { .d8 = &stats.local_maxmes, }, },
{ "local_minmes", DBL, { .d8 = &stats.local_minmes, }, },
{ "local_normdevmes", DBL, { .d8 = &stats.local_normdevmes, }, },
{ "local_stdevmes", DBL, { .d8 = &stats.local_stdevmes, }, },
{ NULL, },
};
if (ast_rtp_instance_get_stats(media->rtp, &stats, AST_RTP_INSTANCE_STAT_ALL)) {
ast_log(AST_LOG_WARNING, "Unable to retrieve 'rtcp' statistics for %s\n", ast_channel_name(chan));
return -1;
}
for (i = 0; !ast_strlen_zero(lookup[i].name); i++) {
if (!strcasecmp(type, lookup[i].name)) {
if (lookup[i].type == INT) {
snprintf(buf, buflen, "%u", *lookup[i].i4);
} else {
snprintf(buf, buflen, "%f", *lookup[i].d8);
}
return 0;
}
}
ast_log(AST_LOG_WARNING, "Unrecognized argument '%s' for 'rtcp' information\n", type);
return -1;
}
return 0;
}
static int print_escaped_uri(struct ast_channel *chan, const char *type,
pjsip_uri_context_e context, const void *uri, char *buf, size_t size)
{
int res;
char *buf_copy;
res = pjsip_uri_print(context, uri, buf, size);
if (res < 0) {
ast_log(LOG_ERROR, "Channel %s: Unescaped %s too long for %d byte buffer\n",
ast_channel_name(chan), type, (int) size);
/* Empty buffer that likely is not terminated. */
buf[0] = '\0';
return -1;
}
buf_copy = ast_strdupa(buf);
ast_escape_quoted(buf_copy, buf, size);
return 0;
}
/*!
* \internal \brief Handle reading signalling information
*/
static int channel_read_pjsip(struct ast_channel *chan, const char *type, const char *field, char *buf, size_t buflen)
{
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
char *buf_copy;
pjsip_dialog *dlg;
int res = 0;
if (!channel) {
ast_log(AST_LOG_WARNING, "Channel %s has no pvt!\n", ast_channel_name(chan));
return -1;
}
dlg = channel->session->inv_session->dlg;
if (ast_strlen_zero(type)) {
ast_log(LOG_WARNING, "You must supply a type field for 'pjsip' information\n");
return -1;
} else if (!strcmp(type, "call-id")) {
snprintf(buf, buflen, "%.*s", (int) pj_strlen(&dlg->call_id->id), pj_strbuf(&dlg->call_id->id));
} else if (!strcmp(type, "secure")) {
#ifdef HAVE_PJSIP_GET_DEST_INFO
pjsip_host_info dest;
pj_pool_t *pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "secure-check", 128, 128);
pjsip_get_dest_info(dlg->target, NULL, pool, &dest);
snprintf(buf, buflen, "%d", dest.flag & PJSIP_TRANSPORT_SECURE ? 1 : 0);
pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
#else
ast_log(LOG_WARNING, "Asterisk has been built against a version of pjproject which does not have the required functionality to support the 'secure' argument. Please upgrade to version 2.3 or later.\n");
return -1;
#endif
} else if (!strcmp(type, "target_uri")) {
res = print_escaped_uri(chan, type, PJSIP_URI_IN_REQ_URI, dlg->target, buf,
buflen);
} else if (!strcmp(type, "local_uri")) {
res = print_escaped_uri(chan, type, PJSIP_URI_IN_FROMTO_HDR, dlg->local.info->uri,
buf, buflen);
} else if (!strcmp(type, "local_tag")) {
ast_copy_pj_str(buf, &dlg->local.info->tag, buflen);
buf_copy = ast_strdupa(buf);
ast_escape_quoted(buf_copy, buf, buflen);
} else if (!strcmp(type, "remote_uri")) {
res = print_escaped_uri(chan, type, PJSIP_URI_IN_FROMTO_HDR,
dlg->remote.info->uri, buf, buflen);
} else if (!strcmp(type, "remote_tag")) {
ast_copy_pj_str(buf, &dlg->remote.info->tag, buflen);
buf_copy = ast_strdupa(buf);
ast_escape_quoted(buf_copy, buf, buflen);
} else if (!strcmp(type, "request_uri")) {
if (channel->session->request_uri) {
res = print_escaped_uri(chan, type, PJSIP_URI_IN_REQ_URI,
channel->session->request_uri, buf, buflen);
}
} else if (!strcmp(type, "t38state")) {
ast_copy_string(buf, t38state_to_string[channel->session->t38state], buflen);
} else if (!strcmp(type, "local_addr")) {
RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
struct transport_info_data *transport_data;
datastore = ast_sip_session_get_datastore(channel->session, "transport_info");
if (!datastore) {
ast_log(AST_LOG_WARNING, "No transport information for channel %s\n", ast_channel_name(chan));
return -1;
}
transport_data = datastore->data;
if (pj_sockaddr_has_addr(&transport_data->local_addr)) {
pj_sockaddr_print(&transport_data->local_addr, buf, buflen, 3);
}
} else if (!strcmp(type, "remote_addr")) {
RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
struct transport_info_data *transport_data;
datastore = ast_sip_session_get_datastore(channel->session, "transport_info");
if (!datastore) {
ast_log(AST_LOG_WARNING, "No transport information for channel %s\n", ast_channel_name(chan));
return -1;
}
transport_data = datastore->data;
if (pj_sockaddr_has_addr(&transport_data->remote_addr)) {
pj_sockaddr_print(&transport_data->remote_addr, buf, buflen, 3);
}
} else {
ast_log(AST_LOG_WARNING, "Unrecognized argument '%s' for 'pjsip' information\n", type);
return -1;
}
return res;
}
/*! \brief Struct used to push function arguments to task processor */
struct pjsip_func_args {
struct ast_sip_session *session;
const char *param;
const char *type;
const char *field;
char *buf;
size_t len;
int ret;
};
/*! \internal \brief Taskprocessor callback that handles the read on a PJSIP thread */
static int read_pjsip(void *data)
{
struct pjsip_func_args *func_args = data;
if (!strcmp(func_args->param, "rtp")) {
if (!func_args->session->channel) {
func_args->ret = -1;
return 0;
}
func_args->ret = channel_read_rtp(func_args->session->channel, func_args->type,
func_args->field, func_args->buf,
func_args->len);
} else if (!strcmp(func_args->param, "rtcp")) {
if (!func_args->session->channel) {
func_args->ret = -1;
return 0;
}
func_args->ret = channel_read_rtcp(func_args->session->channel, func_args->type,
func_args->field, func_args->buf,
func_args->len);
} else if (!strcmp(func_args->param, "endpoint")) {
if (!func_args->session->endpoint) {
ast_log(AST_LOG_WARNING, "Channel %s has no endpoint!\n", func_args->session->channel ?
ast_channel_name(func_args->session->channel) : "<unknown>");
func_args->ret = -1;
return 0;
}
snprintf(func_args->buf, func_args->len, "%s", ast_sorcery_object_get_id(func_args->session->endpoint));
} else if (!strcmp(func_args->param, "contact")) {
if (!func_args->session->contact) {
return 0;
}
snprintf(func_args->buf, func_args->len, "%s", ast_sorcery_object_get_id(func_args->session->contact));
} else if (!strcmp(func_args->param, "aor")) {
if (!func_args->session->aor) {
return 0;
}
snprintf(func_args->buf, func_args->len, "%s", ast_sorcery_object_get_id(func_args->session->aor));
} else if (!strcmp(func_args->param, "pjsip")) {
if (!func_args->session->channel) {
func_args->ret = -1;
return 0;
}
func_args->ret = channel_read_pjsip(func_args->session->channel, func_args->type,
func_args->field, func_args->buf,
func_args->len);
} else {
func_args->ret = -1;
}
return 0;
}
int pjsip_acf_channel_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
struct pjsip_func_args func_args = { 0, };
struct ast_sip_channel_pvt *channel;
char *parse = ast_strdupa(data);
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(param);
AST_APP_ARG(type);
AST_APP_ARG(field);
);
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
/* Check for zero arguments */
if (ast_strlen_zero(parse)) {
ast_log(LOG_ERROR, "Cannot call %s without arguments\n", cmd);
return -1;
}
AST_STANDARD_APP_ARGS(args, parse);
ast_channel_lock(chan);
/* Sanity check */
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
ast_channel_unlock(chan);
return 0;
}
channel = ast_channel_tech_pvt(chan);
if (!channel) {
ast_log(LOG_WARNING, "Channel %s has no pvt!\n", ast_channel_name(chan));
ast_channel_unlock(chan);
return -1;
}
if (!channel->session) {
ast_log(LOG_WARNING, "Channel %s has no session\n", ast_channel_name(chan));
ast_channel_unlock(chan);
return -1;
}
func_args.session = ao2_bump(channel->session);
ast_channel_unlock(chan);
memset(buf, 0, len);
func_args.param = args.param;
func_args.type = args.type;
func_args.field = args.field;
func_args.buf = buf;
func_args.len = len;
if (ast_sip_push_task_wait_serializer(func_args.session->serializer, read_pjsip, &func_args)) {
ast_log(LOG_WARNING, "Unable to read properties of channel %s: failed to push task\n", ast_channel_name(chan));
ao2_ref(func_args.session, -1);
return -1;
}
ao2_ref(func_args.session, -1);
return func_args.ret;
}
int pjsip_acf_dial_contacts_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
RAII_VAR(struct ast_str *, dial, NULL, ast_free_ptr);
const char *aor_name;
char *rest;
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(endpoint_name);
AST_APP_ARG(aor_name);
AST_APP_ARG(request_user);
);
AST_STANDARD_APP_ARGS(args, data);
if (ast_strlen_zero(args.endpoint_name)) {
ast_log(LOG_WARNING, "An endpoint name must be specified when using the '%s' dialplan function\n", cmd);
return -1;
} else if (!(endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", args.endpoint_name))) {
ast_log(LOG_WARNING, "Specified endpoint '%s' was not found\n", args.endpoint_name);
return -1;
}
aor_name = S_OR(args.aor_name, endpoint->aors);
if (ast_strlen_zero(aor_name)) {
ast_log(LOG_WARNING, "No AOR has been provided and no AORs are configured on endpoint '%s'\n", args.endpoint_name);
return -1;
} else if (!(dial = ast_str_create(len))) {
ast_log(LOG_WARNING, "Could not get enough buffer space for dialing contacts\n");
return -1;
} else if (!(rest = ast_strdupa(aor_name))) {
ast_log(LOG_WARNING, "Could not duplicate provided AORs\n");
return -1;
}
while ((aor_name = ast_strip(strsep(&rest, ",")))) {
RAII_VAR(struct ast_sip_aor *, aor, ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
struct ao2_iterator it_contacts;
struct ast_sip_contact *contact;
if (!aor) {
/* If the AOR provided is not found skip it, there may be more */
continue;
} else if (!(contacts = ast_sip_location_retrieve_aor_contacts_filtered(aor, AST_SIP_CONTACT_FILTER_REACHABLE))) {
/* No contacts are available, skip it as well */
continue;
} else if (!ao2_container_count(contacts)) {
/* We were given a container but no contacts are in it... */
continue;
}
it_contacts = ao2_iterator_init(contacts, 0);
for (; (contact = ao2_iterator_next(&it_contacts)); ao2_ref(contact, -1)) {
ast_str_append(&dial, -1, "PJSIP/");
if (!ast_strlen_zero(args.request_user)) {
ast_str_append(&dial, -1, "%s@", args.request_user);
}
ast_str_append(&dial, -1, "%s/%s&", args.endpoint_name, contact->uri);
}
ao2_iterator_destroy(&it_contacts);
}
/* Trim the '&' at the end off */
ast_str_truncate(dial, ast_str_strlen(dial) - 1);
ast_copy_string(buf, ast_str_buffer(dial), len);
return 0;
}
/*! \brief Session refresh state information */
struct session_refresh_state {
/*! \brief Created proposed media state */
struct ast_sip_session_media_state *media_state;
};
/*! \brief Destructor for session refresh information */
static void session_refresh_state_destroy(void *obj)
{
struct session_refresh_state *state = obj;
ast_sip_session_media_state_free(state->media_state);
ast_free(obj);
}
/*! \brief Datastore for attaching session refresh state information */
static const struct ast_datastore_info session_refresh_datastore = {
.type = "pjsip_session_refresh",
.destroy = session_refresh_state_destroy,
};
/*! \brief Helper function which retrieves or allocates a session refresh state information datastore */
static struct session_refresh_state *session_refresh_state_get_or_alloc(struct ast_sip_session *session)
{
RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "pjsip_session_refresh"), ao2_cleanup);
struct session_refresh_state *state;
/* While the datastore refcount is decremented this is operating in the serializer so it will remain valid regardless */
if (datastore) {
return datastore->data;
}
if (!(datastore = ast_sip_session_alloc_datastore(&session_refresh_datastore, "pjsip_session_refresh"))
|| !(datastore->data = ast_calloc(1, sizeof(struct session_refresh_state)))
|| ast_sip_session_add_datastore(session, datastore)) {
return NULL;
}
state = datastore->data;
state->media_state = ast_sip_session_media_state_alloc();
if (!state->media_state) {
ast_sip_session_remove_datastore(session, "pjsip_session_refresh");
return NULL;
}
state->media_state->topology = ast_stream_topology_clone(session->endpoint->media.topology);
if (!state->media_state->topology) {
ast_sip_session_remove_datastore(session, "pjsip_session_refresh");
return NULL;
}
datastore->data = state;
return state;
}
/*! \brief Struct used to push PJSIP_PARSE_URI function arguments to task processor */
struct parse_uri_args {
const char *uri;
const char *type;
char *buf;
size_t buflen;
int ret;
};
/*! \internal \brief Taskprocessor callback that handles the PJSIP_PARSE_URI on a PJSIP thread */
static int parse_uri_cb(void *data)
{
struct parse_uri_args *args = data;
pj_pool_t *pool;
pjsip_name_addr *uri;
pjsip_sip_uri *sip_uri;
pj_str_t tmp;
args->ret = 0;
pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "ParseUri", 128, 128);
if (!pool) {
ast_log(LOG_ERROR, "Failed to allocate ParseUri endpoint pool.\n");
args->ret = -1;
return 0;
}
pj_strdup2_with_null(pool, &tmp, args->uri);
uri = (pjsip_name_addr *)pjsip_parse_uri(pool, tmp.ptr, tmp.slen, PJSIP_PARSE_URI_AS_NAMEADDR);
if (!uri || (!PJSIP_URI_SCHEME_IS_SIP(uri) && !PJSIP_URI_SCHEME_IS_SIPS(uri))) {
ast_log(LOG_WARNING, "Failed to parse URI '%s'\n", args->uri);
pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
args->ret = -1;
return 0;
}
if (!strcmp(args->type, "scheme")) {
ast_copy_pj_str(args->buf, pjsip_uri_get_scheme(uri), args->buflen);
pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
return 0;
} else if (!strcmp(args->type, "display")) {
ast_copy_pj_str(args->buf, &uri->display, args->buflen);
pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
return 0;
}
sip_uri = pjsip_uri_get_uri(uri);
if (!sip_uri) {
ast_log(LOG_ERROR, "Failed to get an URI object for '%s'\n", args->uri);
pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
args->ret = -1;
return 0;
}
if (!strcmp(args->type, "user")) {
ast_copy_pj_str(args->buf, &sip_uri->user, args->buflen);
} else if (!strcmp(args->type, "passwd")) {
ast_copy_pj_str(args->buf, &sip_uri->passwd, args->buflen);
} else if (!strcmp(args->type, "host")) {
ast_copy_pj_str(args->buf, &sip_uri->host, args->buflen);
} else if (!strcmp(args->type, "port")) {
snprintf(args->buf, args->buflen, "%d", sip_uri->port);
} else if (!strcmp(args->type, "user_param")) {
ast_copy_pj_str(args->buf, &sip_uri->user_param, args->buflen);
} else if (!strcmp(args->type, "method_param")) {
ast_copy_pj_str(args->buf, &sip_uri->method_param, args->buflen);
} else if (!strcmp(args->type, "transport_param")) {
ast_copy_pj_str(args->buf, &sip_uri->transport_param, args->buflen);
} else if (!strcmp(args->type, "ttl_param")) {
snprintf(args->buf, args->buflen, "%d", sip_uri->ttl_param);
} else if (!strcmp(args->type, "lr_param")) {
snprintf(args->buf, args->buflen, "%d", sip_uri->lr_param);
} else if (!strcmp(args->type, "maddr_param")) {
ast_copy_pj_str(args->buf, &sip_uri->maddr_param, args->buflen);
} else {
ast_log(AST_LOG_WARNING, "Unknown type part '%s' specified\n", args->type);
pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
args->ret = -1;
return 0;
}
pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
return 0;
}
int pjsip_acf_parse_uri_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
{
struct parse_uri_args func_args = { 0, };
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(uri_str);
AST_APP_ARG(type);
);
AST_STANDARD_APP_ARGS(args, data);
if (ast_strlen_zero(args.uri_str)) {
ast_log(LOG_WARNING, "An URI must be specified when using the '%s' dialplan function\n", cmd);
return -1;
}
if (ast_strlen_zero(args.type)) {
ast_log(LOG_WARNING, "A type part of the URI must be specified when using the '%s' dialplan function\n", cmd);
return -1;
}
memset(buf, 0, buflen);
func_args.uri = args.uri_str;
func_args.type = args.type;
func_args.buf = buf;
func_args.buflen = buflen;
if (ast_sip_push_task_wait_serializer(NULL, parse_uri_cb, &func_args)) {
ast_log(LOG_WARNING, "Unable to parse URI: failed to push task\n");
return -1;
}
return func_args.ret;
}
static int media_offer_read_av(struct ast_sip_session *session, char *buf,
size_t len, enum ast_media_type media_type)
{
struct ast_stream_topology *topology;
int idx;
struct ast_stream *stream = NULL;
const struct ast_format_cap *caps;
size_t accum = 0;
if (session->inv_session->dlg->state == PJSIP_DIALOG_STATE_ESTABLISHED) {
struct session_refresh_state *state;
/* As we've already answered we need to store our media state until we are ready to send it */
state = session_refresh_state_get_or_alloc(session);
if (!state) {
return -1;
}
topology = state->media_state->topology;
} else {
/* The session is not yet up so we are initially answering or offering */
if (!session->pending_media_state->topology) {
session->pending_media_state->topology = ast_stream_topology_clone(session->endpoint->media.topology);
if (!session->pending_media_state->topology) {
return -1;
}
}
topology = session->pending_media_state->topology;
}
/* Find the first suitable stream */
for (idx = 0; idx < ast_stream_topology_get_count(topology); ++idx) {
stream = ast_stream_topology_get_stream(topology, idx);
if (ast_stream_get_type(stream) != media_type ||
ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
stream = NULL;
continue;
}
break;
}
/* If no suitable stream then exit early */
if (!stream) {
buf[0] = '\0';
return 0;
}
caps = ast_stream_get_formats(stream);
/* Note: buf is not terminated while the string is being built. */
for (idx = 0; idx < ast_format_cap_count(caps); ++idx) {
struct ast_format *fmt;
size_t size;
fmt = ast_format_cap_get_format(caps, idx);
/* Add one for a comma or terminator */
size = strlen(ast_format_get_name(fmt)) + 1;
if (len < size) {
ao2_ref(fmt, -1);
break;
}
/* Append the format name */
strcpy(buf + accum, ast_format_get_name(fmt));/* Safe */
ao2_ref(fmt, -1);
accum += size;
len -= size;
/* The last comma on the built string will be set to the terminator. */
buf[accum - 1] = ',';
}
/* Remove the trailing comma or terminate an empty buffer. */
buf[accum ? accum - 1 : 0] = '\0';
return 0;
}
struct media_offer_data {
struct ast_sip_session *session;
enum ast_media_type media_type;
const char *value;
};
static int media_offer_write_av(void *obj)
{
struct media_offer_data *data = obj;
struct ast_stream_topology *topology;
struct ast_stream *stream;
struct ast_format_cap *caps;
if (data->session->inv_session->dlg->state == PJSIP_DIALOG_STATE_ESTABLISHED) {
struct session_refresh_state *state;
/* As we've already answered we need to store our media state until we are ready to send it */
state = session_refresh_state_get_or_alloc(data->session);
if (!state) {
return -1;
}
topology = state->media_state->topology;
} else {
/* The session is not yet up so we are initially answering or offering */
if (!data->session->pending_media_state->topology) {
data->session->pending_media_state->topology = ast_stream_topology_clone(data->session->endpoint->media.topology);
if (!data->session->pending_media_state->topology) {
return -1;
}
}
topology = data->session->pending_media_state->topology;
}
/* XXX This method won't work when it comes time to do multistream support. The proper way to do this
* will either be to
* a) Alter all media streams of a particular type.
* b) Change the dialplan function to be able to specify which stream to alter and alter only that
* one stream
*/
stream = ast_stream_topology_get_first_stream_by_type(topology, data->media_type);
if (!stream) {
return 0;
}
caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!caps) {
return -1;
}
ast_format_cap_append_from_cap(caps, ast_stream_get_formats(stream),
AST_MEDIA_TYPE_UNKNOWN);
ast_format_cap_remove_by_type(caps, data->media_type);
ast_format_cap_update_by_allow_disallow(caps, data->value, 1);
ast_stream_set_formats(stream, caps);
ast_stream_set_metadata(stream, "pjsip_session_refresh", "force");
ao2_ref(caps, -1);
return 0;
}
int pjsip_acf_media_offer_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
struct ast_sip_channel_pvt *channel;
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
return -1;
}
channel = ast_channel_tech_pvt(chan);
if (!strcmp(data, "audio")) {
return media_offer_read_av(channel->session, buf, len, AST_MEDIA_TYPE_AUDIO);
} else if (!strcmp(data, "video")) {
return media_offer_read_av(channel->session, buf, len, AST_MEDIA_TYPE_VIDEO);
} else {
/* Ensure that the buffer is empty */
buf[0] = '\0';
}
return 0;
}
int pjsip_acf_media_offer_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
{
struct ast_sip_channel_pvt *channel;
struct media_offer_data mdata = {
.value = value
};
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
return -1;
}
channel = ast_channel_tech_pvt(chan);
mdata.session = channel->session;
if (!strcmp(data, "audio")) {
mdata.media_type = AST_MEDIA_TYPE_AUDIO;
} else if (!strcmp(data, "video")) {
mdata.media_type = AST_MEDIA_TYPE_VIDEO;
}
return ast_sip_push_task_wait_serializer(channel->session->serializer, media_offer_write_av, &mdata);
}
int pjsip_acf_dtmf_mode_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
struct ast_sip_channel_pvt *channel;
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
ast_channel_lock(chan);
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
ast_channel_unlock(chan);
return -1;
}
channel = ast_channel_tech_pvt(chan);
if (ast_sip_dtmf_to_str(channel->session->dtmf, buf, len) < 0) {
ast_log(LOG_WARNING, "Unknown DTMF mode %d on PJSIP channel %s\n", channel->session->dtmf, ast_channel_name(chan));
ast_channel_unlock(chan);
return -1;
}
ast_channel_unlock(chan);
return 0;
}
int pjsip_acf_moh_passthrough_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
struct ast_sip_channel_pvt *channel;
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
if (len < 3) {
ast_log(LOG_WARNING, "%s: buffer too small\n", cmd);
return -1;
}
ast_channel_lock(chan);
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
ast_channel_unlock(chan);
return -1;
}
channel = ast_channel_tech_pvt(chan);
strncpy(buf, AST_YESNO(channel->session->moh_passthrough), len);
ast_channel_unlock(chan);
return 0;
}
struct refresh_data {
struct ast_sip_session *session;
enum ast_sip_session_refresh_method method;
};
static int sip_session_response_cb(struct ast_sip_session *session, pjsip_rx_data *rdata)
{
struct ast_format *fmt;
if (!session->channel) {
/* Egads! */
return 0;
}
fmt = ast_format_cap_get_best_by_type(ast_channel_nativeformats(session->channel), AST_MEDIA_TYPE_AUDIO);
if (!fmt) {
/* No format? That's weird. */
return 0;
}
ast_channel_set_writeformat(session->channel, fmt);
ast_channel_set_rawwriteformat(session->channel, fmt);
ast_channel_set_readformat(session->channel, fmt);
ast_channel_set_rawreadformat(session->channel, fmt);
ao2_ref(fmt, -1);
return 0;
}
static int dtmf_mode_refresh_cb(void *obj)
{
struct refresh_data *data = obj;
if (data->session->inv_session->state == PJSIP_INV_STATE_CONFIRMED) {
ast_debug(3, "Changing DTMF mode on channel %s after OFFER/ANSWER completion. Sending session refresh\n", ast_channel_name(data->session->channel));
ast_sip_session_refresh(data->session, NULL, NULL,
sip_session_response_cb, data->method, 1, NULL);
} else if (data->session->inv_session->state == PJSIP_INV_STATE_INCOMING) {
ast_debug(3, "Changing DTMF mode on channel %s during OFFER/ANSWER exchange. Updating SDP answer\n", ast_channel_name(data->session->channel));
ast_sip_session_regenerate_answer(data->session, NULL);
}
return 0;
}
int pjsip_acf_dtmf_mode_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
{
struct ast_sip_channel_pvt *channel;
struct ast_sip_session_media *media;
int dsp_features = 0;
int dtmf = -1;
struct refresh_data rdata = {
.method = AST_SIP_SESSION_REFRESH_METHOD_INVITE,
};
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
ast_channel_lock(chan);
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
ast_channel_unlock(chan);
return -1;
}
channel = ast_channel_tech_pvt(chan);
rdata.session = channel->session;
dtmf = ast_sip_str_to_dtmf(value);
if (dtmf == -1) {
ast_log(LOG_WARNING, "Cannot set DTMF mode to '%s' on channel '%s' as value is invalid.\n", value,
ast_channel_name(chan));
ast_channel_unlock(chan);
return -1;
}
if (channel->session->dtmf == dtmf) {
/* DTMF mode unchanged, nothing to do! */
ast_channel_unlock(chan);
return 0;
}
channel->session->dtmf = dtmf;
media = channel->session->active_media_state->default_session[AST_MEDIA_TYPE_AUDIO];
if (media && media->rtp) {
if (channel->session->dtmf == AST_SIP_DTMF_RFC_4733) {
ast_rtp_instance_set_prop(media->rtp, AST_RTP_PROPERTY_DTMF, 1);
ast_rtp_instance_dtmf_mode_set(media->rtp, AST_RTP_DTMF_MODE_RFC2833);
} else if (channel->session->dtmf == AST_SIP_DTMF_INFO) {
ast_rtp_instance_set_prop(media->rtp, AST_RTP_PROPERTY_DTMF, 0);
ast_rtp_instance_dtmf_mode_set(media->rtp, AST_RTP_DTMF_MODE_NONE);
} else if (channel->session->dtmf == AST_SIP_DTMF_INBAND) {
ast_rtp_instance_set_prop(media->rtp, AST_RTP_PROPERTY_DTMF, 0);
ast_rtp_instance_dtmf_mode_set(media->rtp, AST_RTP_DTMF_MODE_INBAND);
} else if (channel->session->dtmf == AST_SIP_DTMF_NONE) {
ast_rtp_instance_set_prop(media->rtp, AST_RTP_PROPERTY_DTMF, 0);
ast_rtp_instance_dtmf_mode_set(media->rtp, AST_RTP_DTMF_MODE_NONE);
} else if (channel->session->dtmf == AST_SIP_DTMF_AUTO) {
if (ast_rtp_instance_dtmf_mode_get(media->rtp) != AST_RTP_DTMF_MODE_RFC2833) {
/* no RFC4733 negotiated, enable inband */
ast_rtp_instance_dtmf_mode_set(media->rtp, AST_RTP_DTMF_MODE_INBAND);
}
} else if (channel->session->dtmf == AST_SIP_DTMF_AUTO_INFO) {
ast_rtp_instance_set_prop(media->rtp, AST_RTP_PROPERTY_DTMF, 0);
if (ast_rtp_instance_dtmf_mode_get(media->rtp) == AST_RTP_DTMF_MODE_INBAND) {
/* if inband, switch to INFO */
ast_rtp_instance_dtmf_mode_set(media->rtp, AST_RTP_DTMF_MODE_NONE);
}
}
}
if (channel->session->dsp) {
dsp_features = ast_dsp_get_features(channel->session->dsp);
}
if (channel->session->dtmf == AST_SIP_DTMF_INBAND ||
channel->session->dtmf == AST_SIP_DTMF_AUTO) {
dsp_features |= DSP_FEATURE_DIGIT_DETECT;
} else {
dsp_features &= ~DSP_FEATURE_DIGIT_DETECT;
}
if (dsp_features) {
if (!channel->session->dsp) {
if (!(channel->session->dsp = ast_dsp_new())) {
ast_channel_unlock(chan);
return 0;
}
}
ast_dsp_set_features(channel->session->dsp, dsp_features);
} else if (channel->session->dsp) {
ast_dsp_free(channel->session->dsp);
channel->session->dsp = NULL;
}
ast_channel_unlock(chan);
return ast_sip_push_task_wait_serializer(channel->session->serializer, dtmf_mode_refresh_cb, &rdata);
}
int pjsip_acf_moh_passthrough_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
{
struct ast_sip_channel_pvt *channel;
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
ast_channel_lock(chan);
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
ast_channel_unlock(chan);
return -1;
}
channel = ast_channel_tech_pvt(chan);
channel->session->moh_passthrough = ast_true(value);
ast_channel_unlock(chan);
return 0;
}
static int refresh_write_cb(void *obj)
{
struct refresh_data *data = obj;
struct session_refresh_state *state;
state = session_refresh_state_get_or_alloc(data->session);
if (!state) {
return -1;
}
ast_sip_session_refresh(data->session, NULL, NULL,
sip_session_response_cb, data->method, 1, state->media_state);
state->media_state = NULL;
ast_sip_session_remove_datastore(data->session, "pjsip_session_refresh");
return 0;
}
int pjsip_acf_session_refresh_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
{
struct ast_sip_channel_pvt *channel;
struct refresh_data rdata = {
.method = AST_SIP_SESSION_REFRESH_METHOD_INVITE,
};
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
if (ast_channel_state(chan) != AST_STATE_UP) {
ast_log(LOG_WARNING, "'%s' not allowed on unanswered channel '%s'.\n", cmd, ast_channel_name(chan));
return -1;
}
if (strcmp(ast_channel_tech(chan)->type, "PJSIP")) {
ast_log(LOG_WARNING, "Cannot call %s on a non-PJSIP channel\n", cmd);
return -1;
}
channel = ast_channel_tech_pvt(chan);
rdata.session = channel->session;
if (!strcmp(value, "invite")) {
rdata.method = AST_SIP_SESSION_REFRESH_METHOD_INVITE;
} else if (!strcmp(value, "update")) {
rdata.method = AST_SIP_SESSION_REFRESH_METHOD_UPDATE;
}
return ast_sip_push_task_wait_serializer(channel->session->serializer, refresh_write_cb, &rdata);
}
Reference in new issue View Git Blame Copy Permalink