2006-02-12 04:28:58 +00:00
|
|
|
/*
|
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006, 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
|
|
|
|
*
|
2008-06-03 23:17:33 +00:00
|
|
|
* \brief Channel info dialplan functions
|
2006-02-12 04:28:58 +00:00
|
|
|
*
|
|
|
|
* \author Kevin P. Fleming <kpfleming@digium.com>
|
2008-06-03 23:17:33 +00:00
|
|
|
* \author Ben Winslow
|
2013-07-21 22:09:23 +00:00
|
|
|
*
|
2007-01-24 09:05:29 +00:00
|
|
|
* \ingroup functions
|
2006-02-12 04:28:58 +00:00
|
|
|
*/
|
|
|
|
|
2011-07-14 20:28:54 +00:00
|
|
|
/*** MODULEINFO
|
|
|
|
<support_level>core</support_level>
|
|
|
|
***/
|
|
|
|
|
2006-06-07 18:54:56 +00:00
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
#include <regex.h>
|
2009-06-26 15:28:53 +00:00
|
|
|
#include <ctype.h>
|
2008-06-03 23:17:33 +00:00
|
|
|
|
2006-02-12 04:28:58 +00:00
|
|
|
#include "asterisk/module.h"
|
|
|
|
#include "asterisk/channel.h"
|
2013-07-25 04:06:32 +00:00
|
|
|
#include "asterisk/bridge.h"
|
2006-02-12 04:28:58 +00:00
|
|
|
#include "asterisk/pbx.h"
|
|
|
|
#include "asterisk/utils.h"
|
|
|
|
#include "asterisk/app.h"
|
|
|
|
#include "asterisk/indications.h"
|
|
|
|
#include "asterisk/stringfields.h"
|
2010-06-08 05:29:08 +00:00
|
|
|
#include "asterisk/global_datastores.h"
|
2013-07-25 04:06:32 +00:00
|
|
|
#include "asterisk/bridge_basic.h"
|
|
|
|
#include "asterisk/bridge_after.h"
|
2006-06-07 18:54:56 +00:00
|
|
|
|
2008-11-01 21:10:07 +00:00
|
|
|
/*** DOCUMENTATION
|
|
|
|
<function name="CHANNELS" language="en_US">
|
|
|
|
<synopsis>
|
|
|
|
Gets the list of channels, optionally filtering by a regular expression.
|
|
|
|
</synopsis>
|
|
|
|
<syntax>
|
|
|
|
<parameter name="regular_expression" />
|
|
|
|
</syntax>
|
|
|
|
<description>
|
|
|
|
<para>Gets the list of channels, optionally filtering by a <replaceable>regular_expression</replaceable>. If
|
|
|
|
no argument is provided, all known channels are returned. The
|
|
|
|
<replaceable>regular_expression</replaceable> must correspond to
|
|
|
|
the POSIX.2 specification, as shown in <emphasis>regex(7)</emphasis>. The list returned
|
|
|
|
will be space-delimited.</para>
|
|
|
|
</description>
|
|
|
|
</function>
|
2009-09-01 23:41:06 +00:00
|
|
|
<function name="MASTER_CHANNEL" language="en_US">
|
|
|
|
<synopsis>
|
|
|
|
Gets or sets variables on the master channel
|
|
|
|
</synopsis>
|
|
|
|
<description>
|
|
|
|
<para>Allows access to the channel which created the current channel, if any. If the channel is already
|
|
|
|
a master channel, then accesses local channel variables.</para>
|
|
|
|
</description>
|
|
|
|
</function>
|
2008-11-01 21:10:07 +00:00
|
|
|
<function name="CHANNEL" language="en_US">
|
|
|
|
<synopsis>
|
|
|
|
Gets/sets various pieces of information about the channel.
|
|
|
|
</synopsis>
|
|
|
|
<syntax>
|
|
|
|
<parameter name="item" required="true">
|
|
|
|
<para>Standard items (provided by all channel technologies) are:</para>
|
|
|
|
<enumlist>
|
2013-04-03 17:17:33 +00:00
|
|
|
<enum name="amaflags">
|
|
|
|
<para>R/W the Automatic Message Accounting (AMA) flags on the channel.
|
|
|
|
When read from a channel, the integer value will always be returned.
|
|
|
|
When written to a channel, both the string format or integer value
|
|
|
|
is accepted.</para>
|
|
|
|
<enumlist>
|
|
|
|
<enum name="1"><para><literal>OMIT</literal></para></enum>
|
|
|
|
<enum name="2"><para><literal>BILLING</literal></para></enum>
|
|
|
|
<enum name="3"><para><literal>DOCUMENTATION</literal></para></enum>
|
|
|
|
</enumlist>
|
|
|
|
</enum>
|
|
|
|
<enum name="accountcode">
|
|
|
|
<para>R/W the channel's account code.</para>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="audioreadformat">
|
|
|
|
<para>R/O format currently being read.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="audionativeformat">
|
|
|
|
<para>R/O format used natively for audio.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="audiowriteformat">
|
|
|
|
<para>R/O format currently being written.</para>
|
|
|
|
</enum>
|
2013-07-23 21:32:33 +00:00
|
|
|
<enum name="dtmf_features">
|
|
|
|
<para>R/W The channel's DTMF bridge features.
|
|
|
|
May include one or more of 'T' 'K' 'H' 'W' and 'X' in a similar manner to options
|
|
|
|
in the <literal>Dial</literal> application. When setting it, the features string
|
|
|
|
must be all upper case.</para>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="callgroup">
|
2012-09-20 17:22:41 +00:00
|
|
|
<para>R/W numeric call pickup groups that this channel is a member.</para>
|
2008-11-01 21:10:07 +00:00
|
|
|
</enum>
|
2011-05-25 15:43:28 +00:00
|
|
|
<enum name="pickupgroup">
|
2012-09-20 17:22:41 +00:00
|
|
|
<para>R/W numeric call pickup groups this channel can pickup.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="namedcallgroup">
|
|
|
|
<para>R/W named call pickup groups that this channel is a member.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="namedpickupgroup">
|
|
|
|
<para>R/W named call pickup groups this channel can pickup.</para>
|
2011-05-25 15:43:28 +00:00
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="channeltype">
|
|
|
|
<para>R/O technology used for channel.</para>
|
|
|
|
</enum>
|
2010-09-07 21:14:54 +00:00
|
|
|
<enum name="checkhangup">
|
2010-09-08 07:15:19 +00:00
|
|
|
<para>R/O Whether the channel is hanging up (1/0)</para>
|
2010-09-07 21:14:54 +00:00
|
|
|
</enum>
|
2013-06-26 20:59:14 +00:00
|
|
|
<enum name="after_bridge_goto">
|
|
|
|
<para>R/W the parseable goto string indicating where the channel is
|
|
|
|
expected to return to in the PBX after exiting the next bridge it joins
|
|
|
|
on the condition that it doesn't hang up. The parseable goto string uses
|
|
|
|
the same syntax as the <literal>Goto</literal> application.</para>
|
|
|
|
</enum>
|
2012-06-29 17:02:32 +00:00
|
|
|
<enum name="hangup_handler_pop">
|
|
|
|
<para>W/O Replace the most recently added hangup handler
|
|
|
|
with a new hangup handler on the channel if supplied. The
|
|
|
|
assigned string is passed to the Gosub application when
|
|
|
|
the channel is hung up. Any optionally omitted context
|
|
|
|
and exten are supplied by the channel pushing the handler
|
|
|
|
before it is pushed.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="hangup_handler_push">
|
|
|
|
<para>W/O Push a hangup handler onto the channel hangup
|
|
|
|
handler stack. The assigned string is passed to the
|
|
|
|
Gosub application when the channel is hung up. Any
|
|
|
|
optionally omitted context and exten are supplied by the
|
|
|
|
channel pushing the handler before it is pushed.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="hangup_handler_wipe">
|
|
|
|
<para>W/O Wipe the entire hangup handler stack and replace
|
|
|
|
with a new hangup handler on the channel if supplied. The
|
|
|
|
assigned string is passed to the Gosub application when
|
|
|
|
the channel is hung up. Any optionally omitted context
|
|
|
|
and exten are supplied by the channel pushing the handler
|
|
|
|
before it is pushed.</para>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="language">
|
|
|
|
<para>R/W language for sounds played.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="musicclass">
|
|
|
|
<para>R/W class (from musiconhold.conf) for hold music.</para>
|
|
|
|
</enum>
|
2009-03-17 21:28:04 +00:00
|
|
|
<enum name="name">
|
|
|
|
<para>The name of the channel</para>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="parkinglot">
|
|
|
|
<para>R/W parkinglot for parking.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="rxgain">
|
|
|
|
<para>R/W set rxgain level on channel drivers that support it.</para>
|
|
|
|
</enum>
|
2010-06-08 05:29:08 +00:00
|
|
|
<enum name="secure_bridge_signaling">
|
|
|
|
<para>Whether or not channels bridged to this channel require secure signaling</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="secure_bridge_media">
|
|
|
|
<para>Whether or not channels bridged to this channel require secure media</para>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="state">
|
|
|
|
<para>R/O state for channel</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="tonezone">
|
|
|
|
<para>R/W zone for indications played</para>
|
|
|
|
</enum>
|
2009-05-11 18:01:44 +00:00
|
|
|
<enum name="transfercapability">
|
|
|
|
<para>R/W ISDN Transfer Capability, one of:</para>
|
|
|
|
<enumlist>
|
|
|
|
<enum name="SPEECH" />
|
|
|
|
<enum name="DIGITAL" />
|
|
|
|
<enum name="RESTRICTED_DIGITAL" />
|
|
|
|
<enum name="3K1AUDIO" />
|
|
|
|
<enum name="DIGITAL_W_TONES" />
|
|
|
|
<enum name="VIDEO" />
|
|
|
|
</enumlist>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="txgain">
|
|
|
|
<para>R/W set txgain level on channel drivers that support it.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="videonativeformat">
|
|
|
|
<para>R/O format used natively for video</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="trace">
|
|
|
|
<para>R/W whether or not context tracing is enabled, only available
|
|
|
|
<emphasis>if CHANNEL_TRACE is defined</emphasis>.</para>
|
|
|
|
</enum>
|
|
|
|
</enumlist>
|
|
|
|
<para><emphasis>chan_sip</emphasis> provides the following additional options:</para>
|
|
|
|
<enumlist>
|
|
|
|
<enum name="peerip">
|
|
|
|
<para>R/O Get the IP address of the peer.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="recvip">
|
|
|
|
<para>R/O Get the source IP address of the peer.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="from">
|
|
|
|
<para>R/O Get the URI from the From: header.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="uri">
|
|
|
|
<para>R/O Get the URI from the Contact: header.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="useragent">
|
|
|
|
<para>R/O Get the useragent.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="peername">
|
|
|
|
<para>R/O Get the name of the peer.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="t38passthrough">
|
|
|
|
<para>R/O <literal>1</literal> if T38 is offered or enabled in this channel,
|
|
|
|
otherwise <literal>0</literal></para>
|
|
|
|
</enum>
|
|
|
|
<enum name="rtpqos">
|
|
|
|
<para>R/O Get QOS information about the RTP stream</para>
|
|
|
|
<para> This option takes two additional arguments:</para>
|
|
|
|
<para> Argument 1:</para>
|
|
|
|
<para> <literal>audio</literal> Get data about the audio stream</para>
|
|
|
|
<para> <literal>video</literal> Get data about the video stream</para>
|
|
|
|
<para> <literal>text</literal> Get data about the text stream</para>
|
|
|
|
<para> Argument 2:</para>
|
|
|
|
<para> <literal>local_ssrc</literal> Local SSRC (stream ID)</para>
|
|
|
|
<para> <literal>local_lostpackets</literal> Local lost packets</para>
|
|
|
|
<para> <literal>local_jitter</literal> Local calculated jitter</para>
|
|
|
|
<para> <literal>local_maxjitter</literal> Local calculated jitter (maximum)</para>
|
|
|
|
<para> <literal>local_minjitter</literal> Local calculated jitter (minimum)</para>
|
|
|
|
<para> <literal>local_normdevjitter</literal>Local calculated jitter (normal deviation)</para>
|
|
|
|
<para> <literal>local_stdevjitter</literal> Local calculated jitter (standard deviation)</para>
|
|
|
|
<para> <literal>local_count</literal> Number of received packets</para>
|
|
|
|
<para> <literal>remote_ssrc</literal> Remote SSRC (stream ID)</para>
|
|
|
|
<para> <literal>remote_lostpackets</literal>Remote lost packets</para>
|
|
|
|
<para> <literal>remote_jitter</literal> Remote reported jitter</para>
|
|
|
|
<para> <literal>remote_maxjitter</literal> Remote calculated jitter (maximum)</para>
|
|
|
|
<para> <literal>remote_minjitter</literal> Remote calculated jitter (minimum)</para>
|
|
|
|
<para> <literal>remote_normdevjitter</literal>Remote calculated jitter (normal deviation)</para>
|
|
|
|
<para> <literal>remote_stdevjitter</literal>Remote calculated jitter (standard deviation)</para>
|
|
|
|
<para> <literal>remote_count</literal> Number of transmitted packets</para>
|
|
|
|
<para> <literal>rtt</literal> Round trip time</para>
|
|
|
|
<para> <literal>maxrtt</literal> Round trip time (maximum)</para>
|
|
|
|
<para> <literal>minrtt</literal> Round trip time (minimum)</para>
|
|
|
|
<para> <literal>normdevrtt</literal> Round trip time (normal deviation)</para>
|
|
|
|
<para> <literal>stdevrtt</literal> Round trip time (standard deviation)</para>
|
|
|
|
<para> <literal>all</literal> All statistics (in a form suited to logging,
|
|
|
|
but not for parsing)</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="rtpdest">
|
|
|
|
<para>R/O Get remote RTP destination information.</para>
|
|
|
|
<para> This option takes one additional argument:</para>
|
|
|
|
<para> Argument 1:</para>
|
|
|
|
<para> <literal>audio</literal> Get audio destination</para>
|
|
|
|
<para> <literal>video</literal> Get video destination</para>
|
2010-03-04 20:12:26 +00:00
|
|
|
<para> <literal>text</literal> Get text destination</para>
|
2013-07-21 22:09:23 +00:00
|
|
|
<para> Defaults to <literal>audio</literal> if unspecified.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="rtpsource">
|
|
|
|
<para>R/O Get source RTP destination information.</para>
|
|
|
|
<para> This option takes one additional argument:</para>
|
|
|
|
<para> Argument 1:</para>
|
|
|
|
<para> <literal>audio</literal> Get audio destination</para>
|
|
|
|
<para> <literal>video</literal> Get video destination</para>
|
|
|
|
<para> <literal>text</literal> Get text destination</para>
|
|
|
|
<para> Defaults to <literal>audio</literal> if unspecified.</para>
|
2008-11-01 21:10:07 +00:00
|
|
|
</enum>
|
|
|
|
</enumlist>
|
2013-12-11 13:06:30 +00:00
|
|
|
<xi:include xpointer="xpointer(/docs/info[@name='PJSIPCHANNEL'])" />
|
2008-11-01 21:10:07 +00:00
|
|
|
<para><emphasis>chan_iax2</emphasis> provides the following additional options:</para>
|
|
|
|
<enumlist>
|
2013-07-21 22:09:23 +00:00
|
|
|
<enum name="osptoken">
|
|
|
|
<para>R/O Get the peer's osptoken.</para>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
<enum name="peerip">
|
|
|
|
<para>R/O Get the peer's ip address.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="peername">
|
|
|
|
<para>R/O Get the peer's username.</para>
|
|
|
|
</enum>
|
2013-07-21 22:09:23 +00:00
|
|
|
<enum name="secure_signaling">
|
|
|
|
<para>R/O Get the if the IAX channel is secured.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="secure_media">
|
|
|
|
<para>R/O Get the if the IAX channel is secured.</para>
|
|
|
|
</enum>
|
2008-11-01 21:10:07 +00:00
|
|
|
</enumlist>
|
2009-07-02 17:46:14 +00:00
|
|
|
<para><emphasis>chan_dahdi</emphasis> provides the following additional options:</para>
|
|
|
|
<enumlist>
|
2011-03-04 15:28:20 +00:00
|
|
|
<enum name="dahdi_channel">
|
|
|
|
<para>R/O DAHDI channel related to this channel.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="dahdi_span">
|
|
|
|
<para>R/O DAHDI span related to this channel.</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="dahdi_type">
|
|
|
|
<para>R/O DAHDI channel type, one of:</para>
|
|
|
|
<enumlist>
|
|
|
|
<enum name="analog" />
|
|
|
|
<enum name="mfc/r2" />
|
|
|
|
<enum name="pri" />
|
|
|
|
<enum name="pseudo" />
|
|
|
|
<enum name="ss7" />
|
|
|
|
</enumlist>
|
|
|
|
</enum>
|
2011-03-01 21:57:58 +00:00
|
|
|
<enum name="keypad_digits">
|
|
|
|
<para>R/O PRI Keypad digits that came in with the SETUP message.</para>
|
|
|
|
</enum>
|
2009-07-02 17:46:14 +00:00
|
|
|
<enum name="reversecharge">
|
2011-03-01 21:57:58 +00:00
|
|
|
<para>R/O PRI Reverse Charging Indication, one of:</para>
|
2009-07-02 17:46:14 +00:00
|
|
|
<enumlist>
|
2011-03-01 21:57:58 +00:00
|
|
|
<enum name="-1"> <para>None</para></enum>
|
|
|
|
<enum name=" 1"> <para>Reverse Charging Requested</para></enum>
|
2009-07-02 17:46:14 +00:00
|
|
|
</enumlist>
|
|
|
|
</enum>
|
2011-03-01 21:57:58 +00:00
|
|
|
<enum name="no_media_path">
|
|
|
|
<para>R/O PRI Nonzero if the channel has no B channel.
|
|
|
|
The channel is either on hold or a call waiting call.</para>
|
|
|
|
</enum>
|
2012-06-01 03:30:01 +00:00
|
|
|
<enum name="buffers">
|
|
|
|
<para>W/O Change the channel's buffer policy (for the current call only)</para>
|
|
|
|
<para>This option takes two arguments:</para>
|
|
|
|
<para> Number of buffers,</para>
|
|
|
|
<para> Buffer policy being one of:</para>
|
|
|
|
<para> <literal>full</literal></para>
|
|
|
|
<para> <literal>immediate</literal></para>
|
|
|
|
<para> <literal>half</literal></para>
|
|
|
|
</enum>
|
|
|
|
<enum name="echocan_mode">
|
|
|
|
<para>W/O Change the configuration of the active echo
|
|
|
|
canceller on the channel (if any), for the current call
|
|
|
|
only.</para>
|
|
|
|
<para>Possible values are:</para>
|
|
|
|
<para> <literal>on</literal> Normal mode (the echo canceller is actually reinitalized)</para>
|
|
|
|
<para> <literal>off</literal> Disabled</para>
|
|
|
|
<para> <literal>fax</literal> FAX/data mode (NLP disabled if possible, otherwise
|
|
|
|
completely disabled)</para>
|
|
|
|
<para> <literal>voice</literal> Voice mode (returns from FAX mode, reverting the changes that were made)</para>
|
|
|
|
</enum>
|
2009-07-02 17:46:14 +00:00
|
|
|
</enumlist>
|
2011-10-03 14:24:45 +00:00
|
|
|
<para><emphasis>chan_ooh323</emphasis> provides the following additional options:</para>
|
|
|
|
<enumlist>
|
|
|
|
<enum name="faxdetect">
|
2013-07-21 22:09:23 +00:00
|
|
|
<para>R/W Fax Detect</para>
|
2011-10-03 14:24:45 +00:00
|
|
|
<para>Returns 0 or 1</para>
|
|
|
|
<para>Write yes or no</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="t38support">
|
2013-07-21 22:09:23 +00:00
|
|
|
<para>R/W t38support</para>
|
2011-10-03 14:24:45 +00:00
|
|
|
<para>Returns 0 or 1</para>
|
|
|
|
<para>Write yes or no</para>
|
|
|
|
</enum>
|
2013-07-21 22:09:23 +00:00
|
|
|
<enum name="h323id_url">
|
|
|
|
<para>R/0 Returns caller URL</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="caller_h323id">
|
|
|
|
<para>R/0 Returns caller h323id</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="caller_dialeddigits">
|
|
|
|
<para>R/0 Returns caller dialed digits</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="caller_email">
|
|
|
|
<para>R/0 Returns caller email</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="callee_email">
|
|
|
|
<para>R/0 Returns callee email</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="callee_dialeddigits">
|
|
|
|
<para>R/0 Returns callee dialed digits</para>
|
|
|
|
</enum>
|
|
|
|
<enum name="caller_url">
|
|
|
|
<para>R/0 Returns caller URL</para>
|
2011-10-03 14:24:45 +00:00
|
|
|
</enum>
|
|
|
|
</enumlist>
|
2008-11-01 21:10:07 +00:00
|
|
|
</parameter>
|
|
|
|
</syntax>
|
|
|
|
<description>
|
|
|
|
<para>Gets/sets various pieces of information about the channel, additional <replaceable>item</replaceable> may
|
|
|
|
be available from the channel driver; see its documentation for details. Any <replaceable>item</replaceable>
|
|
|
|
requested that is not available on the current channel will return an empty string.</para>
|
|
|
|
</description>
|
|
|
|
</function>
|
|
|
|
***/
|
|
|
|
|
2006-02-12 04:28:58 +00:00
|
|
|
#define locked_copy_string(chan, dest, source, len) \
|
|
|
|
do { \
|
2006-05-10 15:30:59 +00:00
|
|
|
ast_channel_lock(chan); \
|
2006-02-12 04:28:58 +00:00
|
|
|
ast_copy_string(dest, source, len); \
|
2006-05-10 15:30:59 +00:00
|
|
|
ast_channel_unlock(chan); \
|
2006-02-12 04:28:58 +00:00
|
|
|
} while (0)
|
|
|
|
#define locked_string_field_set(chan, field, source) \
|
|
|
|
do { \
|
2006-05-10 15:30:59 +00:00
|
|
|
ast_channel_lock(chan); \
|
2012-01-24 20:12:09 +00:00
|
|
|
ast_channel_##field##_set(chan, source); \
|
2006-05-10 15:30:59 +00:00
|
|
|
ast_channel_unlock(chan); \
|
2006-02-12 04:28:58 +00:00
|
|
|
} while (0)
|
|
|
|
|
2009-06-15 17:34:30 +00:00
|
|
|
static const char * const transfercapability_table[0x20] = {
|
2006-05-25 19:07:31 +00:00
|
|
|
"SPEECH", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK",
|
|
|
|
"DIGITAL", "RESTRICTED_DIGITAL", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK",
|
|
|
|
"3K1AUDIO", "DIGITAL_W_TONES", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK",
|
|
|
|
"VIDEO", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK", };
|
|
|
|
|
2007-01-06 00:13:33 +00:00
|
|
|
static int func_channel_read(struct ast_channel *chan, const char *function,
|
2006-02-12 04:28:58 +00:00
|
|
|
char *data, char *buf, size_t len)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2011-02-03 16:22:10 +00:00
|
|
|
struct ast_format_cap *tmpcap;
|
2006-02-12 04:28:58 +00:00
|
|
|
|
2011-02-03 16:22:10 +00:00
|
|
|
if (!strcasecmp(data, "audionativeformat")) {
|
2012-09-20 17:22:41 +00:00
|
|
|
char tmp[512];
|
|
|
|
|
2012-02-20 23:43:27 +00:00
|
|
|
if ((tmpcap = ast_format_cap_get_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_AUDIO))) {
|
2011-02-03 16:22:10 +00:00
|
|
|
ast_copy_string(buf, ast_getformatname_multiple(tmp, sizeof(tmp), tmpcap), len);
|
|
|
|
tmpcap = ast_format_cap_destroy(tmpcap);
|
|
|
|
}
|
|
|
|
} else if (!strcasecmp(data, "videonativeformat")) {
|
2012-09-20 17:22:41 +00:00
|
|
|
char tmp[512];
|
|
|
|
|
2012-02-20 23:43:27 +00:00
|
|
|
if ((tmpcap = ast_format_cap_get_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_VIDEO))) {
|
2011-02-03 16:22:10 +00:00
|
|
|
ast_copy_string(buf, ast_getformatname_multiple(tmp, sizeof(tmp), tmpcap), len);
|
|
|
|
tmpcap = ast_format_cap_destroy(tmpcap);
|
|
|
|
}
|
|
|
|
} else if (!strcasecmp(data, "audioreadformat")) {
|
2012-02-24 00:32:20 +00:00
|
|
|
ast_copy_string(buf, ast_getformatname(ast_channel_readformat(chan)), len);
|
2011-02-03 16:22:10 +00:00
|
|
|
} else if (!strcasecmp(data, "audiowriteformat")) {
|
2012-02-24 00:32:20 +00:00
|
|
|
ast_copy_string(buf, ast_getformatname(ast_channel_writeformat(chan)), len);
|
2008-02-18 04:43:33 +00:00
|
|
|
#ifdef CHANNEL_TRACE
|
2011-02-03 16:22:10 +00:00
|
|
|
} else if (!strcasecmp(data, "trace")) {
|
2008-02-18 04:43:33 +00:00
|
|
|
ast_channel_lock(chan);
|
|
|
|
ast_copy_string(buf, ast_channel_trace_is_enabled(chan) ? "1" : "0", len);
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
#endif
|
2013-07-23 21:32:33 +00:00
|
|
|
} else if (!strcasecmp(data, "tonezone") && ast_channel_zone(chan)) {
|
2012-02-20 23:43:27 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_zone(chan)->country, len);
|
2013-07-23 21:32:33 +00:00
|
|
|
} else if (!strcasecmp(data, "dtmf_features")) {
|
|
|
|
if (ast_bridge_features_ds_get_string(chan, buf, len)) {
|
|
|
|
buf[0] = '\0';
|
|
|
|
}
|
|
|
|
} else if (!strcasecmp(data, "language"))
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_language(chan), len);
|
2006-02-12 04:28:58 +00:00
|
|
|
else if (!strcasecmp(data, "musicclass"))
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_musicclass(chan), len);
|
2009-03-17 21:28:04 +00:00
|
|
|
else if (!strcasecmp(data, "name")) {
|
2012-01-09 22:15:50 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_name(chan), len);
|
2009-03-17 21:28:04 +00:00
|
|
|
} else if (!strcasecmp(data, "parkinglot"))
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_parkinglot(chan), len);
|
2006-03-25 05:24:52 +00:00
|
|
|
else if (!strcasecmp(data, "state"))
|
2012-02-20 23:43:27 +00:00
|
|
|
locked_copy_string(chan, buf, ast_state2str(ast_channel_state(chan)), len);
|
2006-03-25 05:24:52 +00:00
|
|
|
else if (!strcasecmp(data, "channeltype"))
|
2012-02-20 23:43:27 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_tech(chan)->type, len);
|
2009-06-26 15:28:53 +00:00
|
|
|
else if (!strcasecmp(data, "accountcode"))
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_accountcode(chan), len);
|
2010-09-07 21:14:54 +00:00
|
|
|
else if (!strcasecmp(data, "checkhangup")) {
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
ast_copy_string(buf, ast_check_hangup(chan) ? "1" : "0", len);
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
} else if (!strcasecmp(data, "peeraccount"))
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_peeraccount(chan), len);
|
2009-06-26 15:28:53 +00:00
|
|
|
else if (!strcasecmp(data, "hangupsource"))
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_hangupsource(chan), len);
|
2012-02-13 17:27:06 +00:00
|
|
|
else if (!strcasecmp(data, "appname") && ast_channel_appl(chan))
|
|
|
|
locked_copy_string(chan, buf, ast_channel_appl(chan), len);
|
|
|
|
else if (!strcasecmp(data, "appdata") && ast_channel_data(chan))
|
|
|
|
locked_copy_string(chan, buf, ast_channel_data(chan), len);
|
|
|
|
else if (!strcasecmp(data, "exten") && ast_channel_data(chan))
|
|
|
|
locked_copy_string(chan, buf, ast_channel_exten(chan), len);
|
|
|
|
else if (!strcasecmp(data, "context") && ast_channel_data(chan))
|
|
|
|
locked_copy_string(chan, buf, ast_channel_context(chan), len);
|
|
|
|
else if (!strcasecmp(data, "userfield") && ast_channel_data(chan))
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_userfield(chan), len);
|
2012-02-13 17:27:06 +00:00
|
|
|
else if (!strcasecmp(data, "channame") && ast_channel_data(chan))
|
2012-01-09 22:15:50 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_name(chan), len);
|
2009-06-26 15:28:53 +00:00
|
|
|
else if (!strcasecmp(data, "linkedid")) {
|
|
|
|
ast_channel_lock(chan);
|
2012-01-24 20:12:09 +00:00
|
|
|
if (ast_strlen_zero(ast_channel_linkedid(chan))) {
|
2009-06-26 15:28:53 +00:00
|
|
|
/* fall back on the channel's uniqueid if linkedid is unset */
|
2012-01-24 20:12:09 +00:00
|
|
|
ast_copy_string(buf, ast_channel_uniqueid(chan), len);
|
2009-06-26 15:28:53 +00:00
|
|
|
}
|
|
|
|
else {
|
2012-01-24 20:12:09 +00:00
|
|
|
ast_copy_string(buf, ast_channel_linkedid(chan), len);
|
2009-06-26 15:28:53 +00:00
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
} else if (!strcasecmp(data, "peer")) {
|
2013-08-02 14:05:07 +00:00
|
|
|
RAII_VAR(struct ast_channel *, p, NULL, ast_channel_cleanup);
|
2012-09-20 17:22:41 +00:00
|
|
|
|
2009-06-26 15:28:53 +00:00
|
|
|
ast_channel_lock(chan);
|
2013-08-02 14:05:07 +00:00
|
|
|
p = ast_channel_bridge_peer(chan);
|
2013-06-17 03:00:38 +00:00
|
|
|
if (p || ast_channel_tech(chan)) /* dummy channel? if so, we hid the peer name in the language */
|
2012-01-09 22:15:50 +00:00
|
|
|
ast_copy_string(buf, (p ? ast_channel_name(p) : ""), len);
|
2009-06-26 15:28:53 +00:00
|
|
|
else {
|
|
|
|
/* a dummy channel can still pass along bridged peer info via
|
|
|
|
the BRIDGEPEER variable */
|
|
|
|
const char *pname = pbx_builtin_getvar_helper(chan, "BRIDGEPEER");
|
|
|
|
if (!ast_strlen_zero(pname))
|
|
|
|
ast_copy_string(buf, pname, len); /* a horrible kludge, but... how else? */
|
|
|
|
else
|
|
|
|
buf[0] = 0;
|
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
} else if (!strcasecmp(data, "uniqueid")) {
|
2012-01-24 20:12:09 +00:00
|
|
|
locked_copy_string(chan, buf, ast_channel_uniqueid(chan), len);
|
2011-02-03 16:22:10 +00:00
|
|
|
} else if (!strcasecmp(data, "transfercapability")) {
|
2012-02-20 23:43:27 +00:00
|
|
|
locked_copy_string(chan, buf, transfercapability_table[ast_channel_transfercapability(chan) & 0x1f], len);
|
2011-02-03 16:22:10 +00:00
|
|
|
} else if (!strcasecmp(data, "callgroup")) {
|
2006-03-25 05:24:52 +00:00
|
|
|
char groupbuf[256];
|
2012-09-20 17:22:41 +00:00
|
|
|
|
2012-03-01 22:09:18 +00:00
|
|
|
locked_copy_string(chan, buf, ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_callgroup(chan)), len);
|
2011-05-25 15:43:28 +00:00
|
|
|
} else if (!strcasecmp(data, "pickupgroup")) {
|
|
|
|
char groupbuf[256];
|
2012-09-20 17:22:41 +00:00
|
|
|
|
2012-03-01 22:09:18 +00:00
|
|
|
locked_copy_string(chan, buf, ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_pickupgroup(chan)), len);
|
2012-09-20 17:22:41 +00:00
|
|
|
} else if (!strcasecmp(data, "namedcallgroup")) {
|
|
|
|
struct ast_str *tmp_str = ast_str_alloca(1024);
|
|
|
|
|
|
|
|
locked_copy_string(chan, buf, ast_print_namedgroups(&tmp_str, ast_channel_named_callgroups(chan)), len);
|
|
|
|
} else if (!strcasecmp(data, "namedpickupgroup")) {
|
|
|
|
struct ast_str *tmp_str = ast_str_alloca(1024);
|
|
|
|
|
|
|
|
locked_copy_string(chan, buf, ast_print_namedgroups(&tmp_str, ast_channel_named_pickupgroups(chan)), len);
|
2013-06-26 20:59:14 +00:00
|
|
|
} else if (!strcasecmp(data, "after_bridge_goto")) {
|
2013-07-25 02:20:23 +00:00
|
|
|
ast_bridge_read_after_goto(chan, buf, len);
|
2009-06-26 15:28:53 +00:00
|
|
|
} else if (!strcasecmp(data, "amaflags")) {
|
2012-09-20 17:22:41 +00:00
|
|
|
ast_channel_lock(chan);
|
|
|
|
snprintf(buf, len, "%d", ast_channel_amaflags(chan));
|
|
|
|
ast_channel_unlock(chan);
|
2010-06-08 05:29:08 +00:00
|
|
|
} else if (!strncasecmp(data, "secure_bridge_", 14)) {
|
|
|
|
struct ast_datastore *ds;
|
2012-09-20 17:22:41 +00:00
|
|
|
|
2010-06-08 05:29:08 +00:00
|
|
|
ast_channel_lock(chan);
|
|
|
|
if ((ds = ast_channel_datastore_find(chan, &secure_call_info, NULL))) {
|
|
|
|
struct ast_secure_call_store *encrypt = ds->data;
|
|
|
|
if (!strcasecmp(data, "secure_bridge_signaling")) {
|
|
|
|
snprintf(buf, len, "%s", encrypt->signaling ? "1" : "");
|
|
|
|
} else if (!strcasecmp(data, "secure_bridge_media")) {
|
|
|
|
snprintf(buf, len, "%s", encrypt->media ? "1" : "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
2012-02-20 23:43:27 +00:00
|
|
|
} else if (!ast_channel_tech(chan) || !ast_channel_tech(chan)->func_channel_read || ast_channel_tech(chan)->func_channel_read(chan, function, data, buf, len)) {
|
2006-02-12 04:28:58 +00:00
|
|
|
ast_log(LOG_WARNING, "Unknown or unavailable item requested: '%s'\n", data);
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-09-10 22:15:47 +00:00
|
|
|
static int func_channel_write_real(struct ast_channel *chan, const char *function,
|
2006-02-12 04:28:58 +00:00
|
|
|
char *data, const char *value)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2006-05-03 22:02:50 +00:00
|
|
|
signed char gainset;
|
2006-02-12 04:28:58 +00:00
|
|
|
|
|
|
|
if (!strcasecmp(data, "language"))
|
|
|
|
locked_string_field_set(chan, language, value);
|
2008-04-21 23:42:45 +00:00
|
|
|
else if (!strcasecmp(data, "parkinglot"))
|
|
|
|
locked_string_field_set(chan, parkinglot, value);
|
2006-02-12 04:28:58 +00:00
|
|
|
else if (!strcasecmp(data, "musicclass"))
|
|
|
|
locked_string_field_set(chan, musicclass, value);
|
2009-06-26 15:28:53 +00:00
|
|
|
else if (!strcasecmp(data, "accountcode"))
|
|
|
|
locked_string_field_set(chan, accountcode, value);
|
|
|
|
else if (!strcasecmp(data, "userfield"))
|
|
|
|
locked_string_field_set(chan, userfield, value);
|
2013-06-26 20:59:14 +00:00
|
|
|
else if (!strcasecmp(data, "after_bridge_goto")) {
|
|
|
|
if (ast_strlen_zero(value)) {
|
2013-07-25 02:20:23 +00:00
|
|
|
ast_bridge_discard_after_goto(chan);
|
2013-06-26 20:59:14 +00:00
|
|
|
} else {
|
2013-07-25 02:20:23 +00:00
|
|
|
ast_bridge_set_after_go_on(chan, ast_channel_context(chan), ast_channel_exten(chan), ast_channel_priority(chan), value);
|
2013-06-26 20:59:14 +00:00
|
|
|
}
|
|
|
|
} else if (!strcasecmp(data, "amaflags")) {
|
2009-06-26 15:28:53 +00:00
|
|
|
ast_channel_lock(chan);
|
2013-06-17 03:00:38 +00:00
|
|
|
if (isdigit(*value)) {
|
2012-02-20 23:43:27 +00:00
|
|
|
int amaflags;
|
|
|
|
sscanf(value, "%30d", &amaflags);
|
|
|
|
ast_channel_amaflags_set(chan, amaflags);
|
2009-06-26 15:28:53 +00:00
|
|
|
} else if (!strcasecmp(value,"OMIT")){
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_amaflags_set(chan, 1);
|
2009-06-26 15:28:53 +00:00
|
|
|
} else if (!strcasecmp(value,"BILLING")){
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_amaflags_set(chan, 2);
|
2009-06-26 15:28:53 +00:00
|
|
|
} else if (!strcasecmp(value,"DOCUMENTATION")){
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_amaflags_set(chan, 3);
|
2009-06-26 15:28:53 +00:00
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
} else if (!strcasecmp(data, "peeraccount"))
|
|
|
|
locked_string_field_set(chan, peeraccount, value);
|
|
|
|
else if (!strcasecmp(data, "hangupsource"))
|
|
|
|
/* XXX - should we be forcing this here? */
|
|
|
|
ast_set_hangupsource(chan, value, 0);
|
2008-02-18 04:43:33 +00:00
|
|
|
#ifdef CHANNEL_TRACE
|
|
|
|
else if (!strcasecmp(data, "trace")) {
|
|
|
|
ast_channel_lock(chan);
|
2013-07-21 22:09:23 +00:00
|
|
|
if (ast_true(value))
|
2008-02-18 04:43:33 +00:00
|
|
|
ret = ast_channel_trace_enable(chan);
|
2009-06-26 15:28:53 +00:00
|
|
|
else if (ast_false(value))
|
2008-02-18 04:43:33 +00:00
|
|
|
ret = ast_channel_trace_disable(chan);
|
|
|
|
else {
|
|
|
|
ret = -1;
|
2012-04-06 18:19:03 +00:00
|
|
|
ast_log(LOG_WARNING, "Invalid value for CHANNEL(trace).\n");
|
2008-02-18 04:43:33 +00:00
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
}
|
|
|
|
#endif
|
2006-06-04 11:47:51 +00:00
|
|
|
else if (!strcasecmp(data, "tonezone")) {
|
2009-02-17 20:41:24 +00:00
|
|
|
struct ast_tone_zone *new_zone;
|
2006-11-16 08:18:41 +00:00
|
|
|
if (!(new_zone = ast_get_indication_zone(value))) {
|
|
|
|
ast_log(LOG_ERROR, "Unknown country code '%s' for tonezone. Check indications.conf for available country codes.\n", value);
|
2013-07-21 22:09:23 +00:00
|
|
|
ret = -1;
|
2009-02-17 20:41:24 +00:00
|
|
|
} else {
|
|
|
|
ast_channel_lock(chan);
|
2012-02-20 23:43:27 +00:00
|
|
|
if (ast_channel_zone(chan)) {
|
|
|
|
ast_channel_zone_set(chan, ast_tone_zone_unref(ast_channel_zone(chan)));
|
2009-02-17 20:41:24 +00:00
|
|
|
}
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_zone_set(chan, ast_tone_zone_ref(new_zone));
|
2009-02-17 20:41:24 +00:00
|
|
|
ast_channel_unlock(chan);
|
|
|
|
new_zone = ast_tone_zone_unref(new_zone);
|
|
|
|
}
|
2013-07-23 21:32:33 +00:00
|
|
|
} else if (!strcasecmp(data, "dtmf_features")) {
|
|
|
|
ret = ast_bridge_features_ds_set_string(chan, value);
|
2011-05-25 15:43:28 +00:00
|
|
|
} else if (!strcasecmp(data, "callgroup")) {
|
2012-09-20 17:22:41 +00:00
|
|
|
ast_channel_lock(chan);
|
2012-03-01 22:09:18 +00:00
|
|
|
ast_channel_callgroup_set(chan, ast_get_group(value));
|
2012-09-20 17:22:41 +00:00
|
|
|
ast_channel_unlock(chan);
|
2011-05-25 15:43:28 +00:00
|
|
|
} else if (!strcasecmp(data, "pickupgroup")) {
|
2012-09-20 17:22:41 +00:00
|
|
|
ast_channel_lock(chan);
|
2012-03-01 22:09:18 +00:00
|
|
|
ast_channel_pickupgroup_set(chan, ast_get_group(value));
|
2012-09-20 17:22:41 +00:00
|
|
|
ast_channel_unlock(chan);
|
|
|
|
} else if (!strcasecmp(data, "namedcallgroup")) {
|
|
|
|
struct ast_namedgroups *groups = ast_get_namedgroups(value);
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
ast_channel_named_callgroups_set(chan, groups);
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
ast_unref_namedgroups(groups);
|
|
|
|
} else if (!strcasecmp(data, "namedpickupgroup")) {
|
|
|
|
struct ast_namedgroups *groups = ast_get_namedgroups(value);
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
ast_channel_named_pickupgroups_set(chan, groups);
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
ast_unref_namedgroups(groups);
|
2011-05-25 15:43:28 +00:00
|
|
|
} else if (!strcasecmp(data, "txgain")) {
|
2009-08-10 19:20:57 +00:00
|
|
|
sscanf(value, "%4hhd", &gainset);
|
2006-05-03 22:02:50 +00:00
|
|
|
ast_channel_setoption(chan, AST_OPTION_TXGAIN, &gainset, sizeof(gainset), 0);
|
|
|
|
} else if (!strcasecmp(data, "rxgain")) {
|
2009-08-10 19:20:57 +00:00
|
|
|
sscanf(value, "%4hhd", &gainset);
|
2006-05-25 19:07:31 +00:00
|
|
|
ast_channel_setoption(chan, AST_OPTION_RXGAIN, &gainset, sizeof(gainset), 0);
|
|
|
|
} else if (!strcasecmp(data, "transfercapability")) {
|
|
|
|
unsigned short i;
|
2012-09-20 17:22:41 +00:00
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
2006-05-25 19:07:31 +00:00
|
|
|
for (i = 0; i < 0x20; i++) {
|
|
|
|
if (!strcasecmp(transfercapability_table[i], value) && strcmp(value, "UNK")) {
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_transfercapability_set(chan, i);
|
2006-05-25 19:07:31 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-09-20 17:22:41 +00:00
|
|
|
ast_channel_unlock(chan);
|
2012-06-29 17:02:32 +00:00
|
|
|
} else if (!strcasecmp(data, "hangup_handler_pop")) {
|
|
|
|
/* Pop one hangup handler before pushing the new handler. */
|
|
|
|
ast_pbx_hangup_handler_pop(chan);
|
|
|
|
ast_pbx_hangup_handler_push(chan, value);
|
|
|
|
} else if (!strcasecmp(data, "hangup_handler_push")) {
|
|
|
|
ast_pbx_hangup_handler_push(chan, value);
|
|
|
|
} else if (!strcasecmp(data, "hangup_handler_wipe")) {
|
|
|
|
/* Pop all hangup handlers before pushing the new handler. */
|
|
|
|
while (ast_pbx_hangup_handler_pop(chan)) {
|
|
|
|
}
|
|
|
|
ast_pbx_hangup_handler_push(chan, value);
|
2010-06-08 05:29:08 +00:00
|
|
|
} else if (!strncasecmp(data, "secure_bridge_", 14)) {
|
|
|
|
struct ast_datastore *ds;
|
|
|
|
struct ast_secure_call_store *store;
|
|
|
|
|
|
|
|
if (!chan || !value) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
if (!(ds = ast_channel_datastore_find(chan, &secure_call_info, NULL))) {
|
|
|
|
if (!(ds = ast_datastore_alloc(&secure_call_info, NULL))) {
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!(store = ast_calloc(1, sizeof(*store)))) {
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
ast_free(ds);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
ds->data = store;
|
|
|
|
ast_channel_datastore_add(chan, ds);
|
|
|
|
} else {
|
|
|
|
store = ds->data;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcasecmp(data, "secure_bridge_signaling")) {
|
|
|
|
store->signaling = ast_true(value) ? 1 : 0;
|
|
|
|
} else if (!strcasecmp(data, "secure_bridge_media")) {
|
|
|
|
store->media = ast_true(value) ? 1 : 0;
|
|
|
|
}
|
2012-09-20 17:22:41 +00:00
|
|
|
ast_channel_unlock(chan);
|
2012-02-20 23:43:27 +00:00
|
|
|
} else if (!ast_channel_tech(chan)->func_channel_write
|
|
|
|
|| ast_channel_tech(chan)->func_channel_write(chan, function, data, value)) {
|
2006-02-12 04:28:58 +00:00
|
|
|
ast_log(LOG_WARNING, "Unknown or unavailable item requested: '%s'\n",
|
|
|
|
data);
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-09-10 22:15:47 +00:00
|
|
|
static int func_channel_write(struct ast_channel *chan, const char *function, char *data, const char *value)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
ast_chan_write_info_t write_info = {
|
|
|
|
.version = AST_CHAN_WRITE_INFO_T_VERSION,
|
|
|
|
.write_fn = func_channel_write_real,
|
|
|
|
.chan = chan,
|
|
|
|
.function = function,
|
|
|
|
.data = data,
|
|
|
|
.value = value,
|
|
|
|
};
|
|
|
|
|
|
|
|
res = func_channel_write_real(chan, function, data, value);
|
|
|
|
ast_channel_setoption(chan, AST_OPTION_CHANNEL_WRITE, &write_info, sizeof(write_info), 0);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-02-12 04:28:58 +00:00
|
|
|
static struct ast_custom_function channel_function = {
|
|
|
|
.name = "CHANNEL",
|
|
|
|
.read = func_channel_read,
|
|
|
|
.write = func_channel_write,
|
|
|
|
};
|
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
static int func_channels_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t maxlen)
|
|
|
|
{
|
|
|
|
struct ast_channel *c = NULL;
|
|
|
|
regex_t re;
|
|
|
|
int res;
|
|
|
|
size_t buflen = 0;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
struct ast_channel_iterator *iter;
|
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
buf[0] = '\0';
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(data)) {
|
|
|
|
if ((res = regcomp(&re, data, REG_EXTENDED | REG_ICASE | REG_NOSUB))) {
|
|
|
|
regerror(res, &re, buf, maxlen);
|
|
|
|
ast_log(LOG_WARNING, "Error compiling regular expression for %s(%s): %s\n", function, data, buf);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-21 21:08:47 +00:00
|
|
|
if (!(iter = ast_channel_iterator_all_new())) {
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
if (!ast_strlen_zero(data)) {
|
|
|
|
regfree(&re);
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((c = ast_channel_iterator_next(iter))) {
|
|
|
|
ast_channel_lock(c);
|
2012-01-09 22:15:50 +00:00
|
|
|
if (ast_strlen_zero(data) || regexec(&re, ast_channel_name(c), 0, NULL, 0) == 0) {
|
|
|
|
size_t namelen = strlen(ast_channel_name(c));
|
2008-06-03 23:17:33 +00:00
|
|
|
if (buflen + namelen + (ast_strlen_zero(buf) ? 0 : 1) + 1 < maxlen) {
|
|
|
|
if (!ast_strlen_zero(buf)) {
|
|
|
|
strcat(buf, " ");
|
|
|
|
buflen++;
|
|
|
|
}
|
2012-01-09 22:15:50 +00:00
|
|
|
strcat(buf, ast_channel_name(c));
|
2008-06-03 23:17:33 +00:00
|
|
|
buflen += namelen;
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_WARNING, "Number of channels exceeds the available buffer space. Output will be truncated!\n");
|
|
|
|
}
|
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
ast_channel_unlock(c);
|
|
|
|
c = ast_channel_unref(c);
|
2008-06-03 23:17:33 +00:00
|
|
|
}
|
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
ast_channel_iterator_destroy(iter);
|
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
if (!ast_strlen_zero(data)) {
|
|
|
|
regfree(&re);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ast_custom_function channels_function = {
|
|
|
|
.name = "CHANNELS",
|
|
|
|
.read = func_channels_read,
|
|
|
|
};
|
|
|
|
|
2009-09-01 23:41:06 +00:00
|
|
|
static int func_mchan_read(struct ast_channel *chan, const char *function,
|
|
|
|
char *data, struct ast_str **buf, ssize_t len)
|
|
|
|
{
|
2012-01-24 20:12:09 +00:00
|
|
|
struct ast_channel *mchan = ast_channel_get_by_name(ast_channel_linkedid(chan));
|
2012-07-31 20:21:43 +00:00
|
|
|
char *template = ast_alloca(4 + strlen(data));
|
2009-09-01 23:41:06 +00:00
|
|
|
sprintf(template, "${%s}", data); /* SAFE */
|
|
|
|
ast_str_substitute_variables(buf, len, mchan ? mchan : chan, template);
|
|
|
|
if (mchan) {
|
|
|
|
ast_channel_unref(mchan);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int func_mchan_write(struct ast_channel *chan, const char *function,
|
|
|
|
char *data, const char *value)
|
|
|
|
{
|
2012-01-24 20:12:09 +00:00
|
|
|
struct ast_channel *mchan = ast_channel_get_by_name(ast_channel_linkedid(chan));
|
2009-09-01 23:41:06 +00:00
|
|
|
pbx_builtin_setvar_helper(mchan ? mchan : chan, data, value);
|
|
|
|
if (mchan) {
|
|
|
|
ast_channel_unref(mchan);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ast_custom_function mchan_function = {
|
|
|
|
.name = "MASTER_CHANNEL",
|
|
|
|
.read2 = func_mchan_read,
|
|
|
|
.write = func_mchan_write,
|
|
|
|
};
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
static int unload_module(void)
|
2006-02-12 04:28:58 +00:00
|
|
|
{
|
2008-06-03 23:17:33 +00:00
|
|
|
int res = 0;
|
2009-09-01 23:41:06 +00:00
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
res |= ast_custom_function_unregister(&channel_function);
|
|
|
|
res |= ast_custom_function_unregister(&channels_function);
|
2009-09-01 23:41:06 +00:00
|
|
|
res |= ast_custom_function_unregister(&mchan_function);
|
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
return res;
|
2006-02-12 04:28:58 +00:00
|
|
|
}
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
static int load_module(void)
|
2006-02-12 04:28:58 +00:00
|
|
|
{
|
2008-06-03 23:17:33 +00:00
|
|
|
int res = 0;
|
2009-09-01 23:41:06 +00:00
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
res |= ast_custom_function_register(&channel_function);
|
|
|
|
res |= ast_custom_function_register(&channels_function);
|
2009-09-01 23:41:06 +00:00
|
|
|
res |= ast_custom_function_register(&mchan_function);
|
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
return res;
|
2006-02-12 04:28:58 +00:00
|
|
|
}
|
|
|
|
|
2008-06-03 23:17:33 +00:00
|
|
|
AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Channel information dialplan functions");
|