Allow Asterisk to compile under GCC 4.10
[asterisk/asterisk.git] / funcs / func_channel.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2006, Digium, Inc.
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*! \file
18  *
19  * \brief Channel info dialplan functions
20  *
21  * \author Kevin P. Fleming <kpfleming@digium.com>
22  * \author Ben Winslow
23  *
24  * \ingroup functions
25  */
26
27 /*** MODULEINFO
28         <support_level>core</support_level>
29  ***/
30
31 #include "asterisk.h"
32
33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include <regex.h>
36 #include <ctype.h>
37
38 #include "asterisk/module.h"
39 #include "asterisk/channel.h"
40 #include "asterisk/bridge.h"
41 #include "asterisk/pbx.h"
42 #include "asterisk/utils.h"
43 #include "asterisk/app.h"
44 #include "asterisk/indications.h"
45 #include "asterisk/stringfields.h"
46 #include "asterisk/global_datastores.h"
47 #include "asterisk/bridge_basic.h"
48 #include "asterisk/bridge_after.h"
49
50 /*** DOCUMENTATION
51         <function name="CHANNELS" language="en_US">
52                 <synopsis>
53                         Gets the list of channels, optionally filtering by a regular expression.
54                 </synopsis>
55                 <syntax>
56                         <parameter name="regular_expression" />
57                 </syntax>
58                 <description>
59                         <para>Gets the list of channels, optionally filtering by a <replaceable>regular_expression</replaceable>. If
60                         no argument is provided, all known channels are returned. The
61                         <replaceable>regular_expression</replaceable> must correspond to
62                         the POSIX.2 specification, as shown in <emphasis>regex(7)</emphasis>. The list returned
63                         will be space-delimited.</para>
64                 </description>
65         </function>
66         <function name="MASTER_CHANNEL" language="en_US">
67                 <synopsis>
68                         Gets or sets variables on the master channel
69                 </synopsis>
70                 <description>
71                         <para>Allows access to the channel which created the current channel, if any.  If the channel is already
72                         a master channel, then accesses local channel variables.</para>
73                 </description>
74         </function>
75         <function name="CHANNEL" language="en_US">
76                 <synopsis>
77                         Gets/sets various pieces of information about the channel.
78                 </synopsis>
79                 <syntax>
80                         <parameter name="item" required="true">
81                                 <para>Standard items (provided by all channel technologies) are:</para>
82                                 <enumlist>
83                                         <enum name="amaflags">
84                                                 <para>R/W the Automatic Message Accounting (AMA) flags on the channel.
85                                                 When read from a channel, the integer value will always be returned.
86                                                 When written to a channel, both the string format or integer value
87                                                 is accepted.</para>
88                                                 <enumlist>
89                                                         <enum name="1"><para><literal>OMIT</literal></para></enum>
90                                                         <enum name="2"><para><literal>BILLING</literal></para></enum>
91                                                         <enum name="3"><para><literal>DOCUMENTATION</literal></para></enum>
92                                                 </enumlist>
93                                         </enum>
94                                         <enum name="accountcode">
95                                                 <para>R/W the channel's account code.</para>
96                                         </enum>
97                                         <enum name="audioreadformat">
98                                                 <para>R/O format currently being read.</para>
99                                         </enum>
100                                         <enum name="audionativeformat">
101                                                 <para>R/O format used natively for audio.</para>
102                                         </enum>
103                                         <enum name="audiowriteformat">
104                                                 <para>R/O format currently being written.</para>
105                                         </enum>
106                                         <enum name="dtmf_features">
107                                                 <para>R/W The channel's DTMF bridge features.
108                                                 May include one or more of 'T' 'K' 'H' 'W' and 'X' in a similar manner to options
109                                                 in the <literal>Dial</literal> application. When setting it, the features string
110                                                 must be all upper case.</para>
111                                         </enum>
112                                         <enum name="callgroup">
113                                                 <para>R/W numeric call pickup groups that this channel is a member.</para>
114                                         </enum>
115                                         <enum name="pickupgroup">
116                                                 <para>R/W numeric call pickup groups this channel can pickup.</para>
117                                         </enum>
118                                         <enum name="namedcallgroup">
119                                                 <para>R/W named call pickup groups that this channel is a member.</para>
120                                         </enum>
121                                         <enum name="namedpickupgroup">
122                                                 <para>R/W named call pickup groups this channel can pickup.</para>
123                                         </enum>
124                                         <enum name="channeltype">
125                                                 <para>R/O technology used for channel.</para>
126                                         </enum>
127                                         <enum name="checkhangup">
128                                                 <para>R/O Whether the channel is hanging up (1/0)</para>
129                                         </enum>
130                                         <enum name="after_bridge_goto">
131                                                 <para>R/W the parseable goto string indicating where the channel is
132                                                 expected to return to in the PBX after exiting the next bridge it joins
133                                                 on the condition that it doesn't hang up. The parseable goto string uses
134                                                 the same syntax as the <literal>Goto</literal> application.</para>
135                                         </enum>
136                                         <enum name="hangup_handler_pop">
137                                                 <para>W/O Replace the most recently added hangup handler
138                                                 with a new hangup handler on the channel if supplied.  The
139                                                 assigned string is passed to the Gosub application when
140                                                 the channel is hung up.  Any optionally omitted context
141                                                 and exten are supplied by the channel pushing the handler
142                                                 before it is pushed.</para>
143                                         </enum>
144                                         <enum name="hangup_handler_push">
145                                                 <para>W/O Push a hangup handler onto the channel hangup
146                                                 handler stack.  The assigned string is passed to the
147                                                 Gosub application when the channel is hung up.  Any
148                                                 optionally omitted context and exten are supplied by the
149                                                 channel pushing the handler before it is pushed.</para>
150                                         </enum>
151                                         <enum name="hangup_handler_wipe">
152                                                 <para>W/O Wipe the entire hangup handler stack and replace
153                                                 with a new hangup handler on the channel if supplied.  The
154                                                 assigned string is passed to the Gosub application when
155                                                 the channel is hung up.  Any optionally omitted context
156                                                 and exten are supplied by the channel pushing the handler
157                                                 before it is pushed.</para>
158                                         </enum>
159                                         <enum name="language">
160                                                 <para>R/W language for sounds played.</para>
161                                         </enum>
162                                         <enum name="musicclass">
163                                                 <para>R/W class (from musiconhold.conf) for hold music.</para>
164                                         </enum>
165                                         <enum name="name">
166                                                 <para>The name of the channel</para>
167                                         </enum>
168                                         <enum name="parkinglot">
169                                                 <para>R/W parkinglot for parking.</para>
170                                         </enum>
171                                         <enum name="rxgain">
172                                                 <para>R/W set rxgain level on channel drivers that support it.</para>
173                                         </enum>
174                                         <enum name="secure_bridge_signaling">
175                                                 <para>Whether or not channels bridged to this channel require secure signaling</para>
176                                         </enum>
177                                         <enum name="secure_bridge_media">
178                                                 <para>Whether or not channels bridged to this channel require secure media</para>
179                                         </enum>
180                                         <enum name="state">
181                                                 <para>R/O state for channel</para>
182                                         </enum>
183                                         <enum name="tonezone">
184                                                 <para>R/W zone for indications played</para>
185                                         </enum>
186                                         <enum name="transfercapability">
187                                                 <para>R/W ISDN Transfer Capability, one of:</para>
188                                                 <enumlist>
189                                                         <enum name="SPEECH" />
190                                                         <enum name="DIGITAL" />
191                                                         <enum name="RESTRICTED_DIGITAL" />
192                                                         <enum name="3K1AUDIO" />
193                                                         <enum name="DIGITAL_W_TONES" />
194                                                         <enum name="VIDEO" />
195                                                 </enumlist>
196                                         </enum>
197                                         <enum name="txgain">
198                                                 <para>R/W set txgain level on channel drivers that support it.</para>
199                                         </enum>
200                                         <enum name="videonativeformat">
201                                                 <para>R/O format used natively for video</para>
202                                         </enum>
203                                         <enum name="trace">
204                                                 <para>R/W whether or not context tracing is enabled, only available
205                                                 <emphasis>if CHANNEL_TRACE is defined</emphasis>.</para>
206                                         </enum>
207                                 </enumlist>
208                                 <para><emphasis>chan_sip</emphasis> provides the following additional options:</para>
209                                 <enumlist>
210                                         <enum name="peerip">
211                                                 <para>R/O Get the IP address of the peer.</para>
212                                         </enum>
213                                         <enum name="recvip">
214                                                 <para>R/O Get the source IP address of the peer.</para>
215                                         </enum>
216                                         <enum name="from">
217                                                 <para>R/O Get the URI from the From: header.</para>
218                                         </enum>
219                                         <enum name="uri">
220                                                 <para>R/O Get the URI from the Contact: header.</para>
221                                         </enum>
222                                         <enum name="useragent">
223                                                 <para>R/O Get the useragent.</para>
224                                         </enum>
225                                         <enum name="peername">
226                                                 <para>R/O Get the name of the peer.</para>
227                                         </enum>
228                                         <enum name="t38passthrough">
229                                                 <para>R/O <literal>1</literal> if T38 is offered or enabled in this channel,
230                                                 otherwise <literal>0</literal></para>
231                                         </enum>
232                                         <enum name="rtpqos">
233                                                 <para>R/O Get QOS information about the RTP stream</para>
234                                                 <para>    This option takes two additional arguments:</para>
235                                                 <para>    Argument 1:</para>
236                                                 <para>     <literal>audio</literal>             Get data about the audio stream</para>
237                                                 <para>     <literal>video</literal>             Get data about the video stream</para>
238                                                 <para>     <literal>text</literal>              Get data about the text stream</para>
239                                                 <para>    Argument 2:</para>
240                                                 <para>     <literal>local_ssrc</literal>        Local SSRC (stream ID)</para>
241                                                 <para>     <literal>local_lostpackets</literal> Local lost packets</para>
242                                                 <para>     <literal>local_jitter</literal>      Local calculated jitter</para>
243                                                 <para>     <literal>local_maxjitter</literal>   Local calculated jitter (maximum)</para>
244                                                 <para>     <literal>local_minjitter</literal>   Local calculated jitter (minimum)</para>
245                                                 <para>     <literal>local_normdevjitter</literal>Local calculated jitter (normal deviation)</para>
246                                                 <para>     <literal>local_stdevjitter</literal> Local calculated jitter (standard deviation)</para>
247                                                 <para>     <literal>local_count</literal>       Number of received packets</para>
248                                                 <para>     <literal>remote_ssrc</literal>       Remote SSRC (stream ID)</para>
249                                                 <para>     <literal>remote_lostpackets</literal>Remote lost packets</para>
250                                                 <para>     <literal>remote_jitter</literal>     Remote reported jitter</para>
251                                                 <para>     <literal>remote_maxjitter</literal>  Remote calculated jitter (maximum)</para>
252                                                 <para>     <literal>remote_minjitter</literal>  Remote calculated jitter (minimum)</para>
253                                                 <para>     <literal>remote_normdevjitter</literal>Remote calculated jitter (normal deviation)</para>
254                                                 <para>     <literal>remote_stdevjitter</literal>Remote calculated jitter (standard deviation)</para>
255                                                 <para>     <literal>remote_count</literal>      Number of transmitted packets</para>
256                                                 <para>     <literal>rtt</literal>               Round trip time</para>
257                                                 <para>     <literal>maxrtt</literal>            Round trip time (maximum)</para>
258                                                 <para>     <literal>minrtt</literal>            Round trip time (minimum)</para>
259                                                 <para>     <literal>normdevrtt</literal>        Round trip time (normal deviation)</para>
260                                                 <para>     <literal>stdevrtt</literal>          Round trip time (standard deviation)</para>
261                                                 <para>     <literal>all</literal>               All statistics (in a form suited to logging,
262                                                 but not for parsing)</para>
263                                         </enum>
264                                         <enum name="rtpdest">
265                                                 <para>R/O Get remote RTP destination information.</para>
266                                                 <para>   This option takes one additional argument:</para>
267                                                 <para>    Argument 1:</para>
268                                                 <para>     <literal>audio</literal>             Get audio destination</para>
269                                                 <para>     <literal>video</literal>             Get video destination</para>
270                                                 <para>     <literal>text</literal>              Get text destination</para>
271                                                 <para>   Defaults to <literal>audio</literal> if unspecified.</para>
272                                         </enum>
273                                         <enum name="rtpsource">
274                                                 <para>R/O Get source RTP destination information.</para>
275                                                 <para>   This option takes one additional argument:</para>
276                                                 <para>    Argument 1:</para>
277                                                 <para>     <literal>audio</literal>             Get audio destination</para>
278                                                 <para>     <literal>video</literal>             Get video destination</para>
279                                                 <para>     <literal>text</literal>              Get text destination</para>
280                                                 <para>   Defaults to <literal>audio</literal> if unspecified.</para>
281                                         </enum>
282                                 </enumlist>
283                                 <xi:include xpointer="xpointer(/docs/info[@name='PJSIPCHANNEL'])" />
284                                 <para><emphasis>chan_iax2</emphasis> provides the following additional options:</para>
285                                 <enumlist>
286                                         <enum name="osptoken">
287                                                 <para>R/O Get the peer's osptoken.</para>
288                                         </enum>
289                                         <enum name="peerip">
290                                                 <para>R/O Get the peer's ip address.</para>
291                                         </enum>
292                                         <enum name="peername">
293                                                 <para>R/O Get the peer's username.</para>
294                                         </enum>
295                                         <enum name="secure_signaling">
296                                                 <para>R/O Get the if the IAX channel is secured.</para>
297                                         </enum>
298                                         <enum name="secure_media">
299                                                 <para>R/O Get the if the IAX channel is secured.</para>
300                                         </enum>
301                                 </enumlist>
302                                 <para><emphasis>chan_dahdi</emphasis> provides the following additional options:</para>
303                                 <enumlist>
304                                         <enum name="dahdi_channel">
305                                                 <para>R/O DAHDI channel related to this channel.</para>
306                                         </enum>
307                                         <enum name="dahdi_span">
308                                                 <para>R/O DAHDI span related to this channel.</para>
309                                         </enum>
310                                         <enum name="dahdi_type">
311                                                 <para>R/O DAHDI channel type, one of:</para>
312                                                 <enumlist>
313                                                         <enum name="analog" />
314                                                         <enum name="mfc/r2" />
315                                                         <enum name="pri" />
316                                                         <enum name="pseudo" />
317                                                         <enum name="ss7" />
318                                                 </enumlist>
319                                         </enum>
320                                         <enum name="keypad_digits">
321                                                 <para>R/O PRI Keypad digits that came in with the SETUP message.</para>
322                                         </enum>
323                                         <enum name="reversecharge">
324                                                 <para>R/O PRI Reverse Charging Indication, one of:</para>
325                                                 <enumlist>
326                                                         <enum name="-1"> <para>None</para></enum>
327                                                         <enum name=" 1"> <para>Reverse Charging Requested</para></enum>
328                                                 </enumlist>
329                                         </enum>
330                                         <enum name="no_media_path">
331                                                 <para>R/O PRI Nonzero if the channel has no B channel.
332                                                 The channel is either on hold or a call waiting call.</para>
333                                         </enum>
334                                         <enum name="buffers">
335                                                 <para>W/O Change the channel's buffer policy (for the current call only)</para>
336                                                 <para>This option takes two arguments:</para>
337                                                 <para>  Number of buffers,</para>
338                                                 <para>  Buffer policy being one of:</para>
339                                                 <para>      <literal>full</literal></para>
340                                                 <para>      <literal>immediate</literal></para>
341                                                 <para>      <literal>half</literal></para>
342                                         </enum>
343                                         <enum name="echocan_mode">
344                                                 <para>W/O Change the configuration of the active echo
345                                                 canceller on the channel (if any), for the current call
346                                                 only.</para>
347                                                 <para>Possible values are:</para>
348                                                 <para>  <literal>on</literal>   Normal mode (the echo canceller is actually reinitalized)</para>
349                                                 <para>  <literal>off</literal>  Disabled</para>
350                                                 <para>  <literal>fax</literal>  FAX/data mode (NLP disabled if possible, otherwise
351                                                         completely disabled)</para>
352                                                 <para>  <literal>voice</literal>        Voice mode (returns from FAX mode, reverting the changes that were made)</para>
353                                         </enum>
354                                 </enumlist>
355                                 <para><emphasis>chan_ooh323</emphasis> provides the following additional options:</para>
356                                 <enumlist>
357                                         <enum name="faxdetect">
358                                                 <para>R/W Fax Detect</para>
359                                                 <para>Returns 0 or 1</para>
360                                                 <para>Write yes or no</para>
361                                         </enum>
362                                         <enum name="t38support">
363                                                 <para>R/W t38support</para>
364                                                 <para>Returns 0 or 1</para>
365                                                 <para>Write yes or no</para>
366                                         </enum>
367                                         <enum name="h323id_url">
368                                                 <para>R/0 Returns caller URL</para>
369                                         </enum>
370                                         <enum name="caller_h323id">
371                                                 <para>R/0 Returns caller h323id</para>
372                                         </enum>
373                                         <enum name="caller_dialeddigits">
374                                                 <para>R/0 Returns caller dialed digits</para>
375                                         </enum>
376                                         <enum name="caller_email">
377                                                 <para>R/0 Returns caller email</para>
378                                         </enum>
379                                         <enum name="callee_email">
380                                                 <para>R/0 Returns callee email</para>
381                                         </enum>
382                                         <enum name="callee_dialeddigits">
383                                                 <para>R/0 Returns callee dialed digits</para>
384                                         </enum>
385                                         <enum name="caller_url">
386                                                 <para>R/0 Returns caller URL</para>
387                                         </enum>
388                                 </enumlist>
389                         </parameter>
390                 </syntax>
391                 <description>
392                         <para>Gets/sets various pieces of information about the channel, additional <replaceable>item</replaceable> may
393                         be available from the channel driver; see its documentation for details. Any <replaceable>item</replaceable>
394                         requested that is not available on the current channel will return an empty string.</para>
395                 </description>
396         </function>
397  ***/
398
399 #define locked_copy_string(chan, dest, source, len) \
400         do { \
401                 ast_channel_lock(chan); \
402                 ast_copy_string(dest, source, len); \
403                 ast_channel_unlock(chan); \
404         } while (0)
405 #define locked_string_field_set(chan, field, source) \
406         do { \
407                 ast_channel_lock(chan); \
408                 ast_channel_##field##_set(chan, source); \
409                 ast_channel_unlock(chan); \
410         } while (0)
411
412 static const char * const transfercapability_table[0x20] = {
413         "SPEECH", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK",
414         "DIGITAL", "RESTRICTED_DIGITAL", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK",
415         "3K1AUDIO", "DIGITAL_W_TONES", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK",
416         "VIDEO", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK", "UNK", };
417
418 static int func_channel_read(struct ast_channel *chan, const char *function,
419                              char *data, char *buf, size_t len)
420 {
421         int ret = 0;
422         struct ast_format_cap *tmpcap;
423
424         if (!chan) {
425                 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
426                 return -1;
427         }
428
429         if (!strcasecmp(data, "audionativeformat")) {
430                 char tmp[512];
431
432                 if ((tmpcap = ast_format_cap_get_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_AUDIO))) {
433                         ast_copy_string(buf, ast_getformatname_multiple(tmp, sizeof(tmp), tmpcap), len);
434                         tmpcap = ast_format_cap_destroy(tmpcap);
435                 }
436         } else if (!strcasecmp(data, "videonativeformat")) {
437                 char tmp[512];
438
439                 if ((tmpcap = ast_format_cap_get_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_VIDEO))) {
440                         ast_copy_string(buf, ast_getformatname_multiple(tmp, sizeof(tmp), tmpcap), len);
441                         tmpcap = ast_format_cap_destroy(tmpcap);
442                 }
443         } else if (!strcasecmp(data, "audioreadformat")) {
444                 ast_copy_string(buf, ast_getformatname(ast_channel_readformat(chan)), len);
445         } else if (!strcasecmp(data, "audiowriteformat")) {
446                 ast_copy_string(buf, ast_getformatname(ast_channel_writeformat(chan)), len);
447 #ifdef CHANNEL_TRACE
448         } else if (!strcasecmp(data, "trace")) {
449                 ast_channel_lock(chan);
450                 ast_copy_string(buf, ast_channel_trace_is_enabled(chan) ? "1" : "0", len);
451                 ast_channel_unlock(chan);
452 #endif
453         } else if (!strcasecmp(data, "tonezone") && ast_channel_zone(chan)) {
454                 locked_copy_string(chan, buf, ast_channel_zone(chan)->country, len);
455         } else if (!strcasecmp(data, "dtmf_features")) {
456                 if (ast_bridge_features_ds_get_string(chan, buf, len)) {
457                         buf[0] = '\0';
458                 }
459         } else if (!strcasecmp(data, "language"))
460                 locked_copy_string(chan, buf, ast_channel_language(chan), len);
461         else if (!strcasecmp(data, "musicclass"))
462                 locked_copy_string(chan, buf, ast_channel_musicclass(chan), len);
463         else if (!strcasecmp(data, "name")) {
464                 locked_copy_string(chan, buf, ast_channel_name(chan), len);
465         } else if (!strcasecmp(data, "parkinglot"))
466                 locked_copy_string(chan, buf, ast_channel_parkinglot(chan), len);
467         else if (!strcasecmp(data, "state"))
468                 locked_copy_string(chan, buf, ast_state2str(ast_channel_state(chan)), len);
469         else if (!strcasecmp(data, "channeltype"))
470                 locked_copy_string(chan, buf, ast_channel_tech(chan)->type, len);
471         else if (!strcasecmp(data, "accountcode"))
472                 locked_copy_string(chan, buf, ast_channel_accountcode(chan), len);
473         else if (!strcasecmp(data, "checkhangup")) {
474                 ast_channel_lock(chan);
475                 ast_copy_string(buf, ast_check_hangup(chan) ? "1" : "0", len);
476                 ast_channel_unlock(chan);
477         } else if (!strcasecmp(data, "peeraccount"))
478                 locked_copy_string(chan, buf, ast_channel_peeraccount(chan), len);
479         else if (!strcasecmp(data, "hangupsource"))
480                 locked_copy_string(chan, buf, ast_channel_hangupsource(chan), len);
481         else if (!strcasecmp(data, "appname") && ast_channel_appl(chan))
482                 locked_copy_string(chan, buf, ast_channel_appl(chan), len);
483         else if (!strcasecmp(data, "appdata") && ast_channel_data(chan))
484                 locked_copy_string(chan, buf, ast_channel_data(chan), len);
485         else if (!strcasecmp(data, "exten") && ast_channel_data(chan))
486                 locked_copy_string(chan, buf, ast_channel_exten(chan), len);
487         else if (!strcasecmp(data, "context") && ast_channel_data(chan))
488                 locked_copy_string(chan, buf, ast_channel_context(chan), len);
489         else if (!strcasecmp(data, "userfield") && ast_channel_data(chan))
490                 locked_copy_string(chan, buf, ast_channel_userfield(chan), len);
491         else if (!strcasecmp(data, "channame") && ast_channel_data(chan))
492                 locked_copy_string(chan, buf, ast_channel_name(chan), len);
493         else if (!strcasecmp(data, "linkedid")) {
494                 ast_channel_lock(chan);
495                 if (ast_strlen_zero(ast_channel_linkedid(chan))) {
496                         /* fall back on the channel's uniqueid if linkedid is unset */
497                         ast_copy_string(buf, ast_channel_uniqueid(chan), len);
498                 }
499                 else {
500                         ast_copy_string(buf, ast_channel_linkedid(chan), len);
501                 }
502                 ast_channel_unlock(chan);
503         } else if (!strcasecmp(data, "peer")) {
504                 RAII_VAR(struct ast_channel *, p, NULL, ast_channel_cleanup);
505
506                 ast_channel_lock(chan);
507                 p = ast_channel_bridge_peer(chan);
508                 if (p || ast_channel_tech(chan)) /* dummy channel? if so, we hid the peer name in the language */
509                         ast_copy_string(buf, (p ? ast_channel_name(p) : ""), len);
510                 else {
511                         /* a dummy channel can still pass along bridged peer info via
512                            the BRIDGEPEER variable */
513                         const char *pname = pbx_builtin_getvar_helper(chan, "BRIDGEPEER");
514                         if (!ast_strlen_zero(pname))
515                                 ast_copy_string(buf, pname, len); /* a horrible kludge, but... how else? */
516                         else
517                                 buf[0] = 0;
518                 }
519                 ast_channel_unlock(chan);
520         } else if (!strcasecmp(data, "uniqueid")) {
521                 locked_copy_string(chan, buf, ast_channel_uniqueid(chan), len);
522         } else if (!strcasecmp(data, "transfercapability")) {
523                 locked_copy_string(chan, buf, transfercapability_table[ast_channel_transfercapability(chan) & 0x1f], len);
524         } else if (!strcasecmp(data, "callgroup")) {
525                 char groupbuf[256];
526
527                 locked_copy_string(chan, buf,  ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_callgroup(chan)), len);
528         } else if (!strcasecmp(data, "pickupgroup")) {
529                 char groupbuf[256];
530
531                 locked_copy_string(chan, buf,  ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_pickupgroup(chan)), len);
532         } else if (!strcasecmp(data, "namedcallgroup")) {
533                 struct ast_str *tmp_str = ast_str_alloca(1024);
534
535                 locked_copy_string(chan, buf,  ast_print_namedgroups(&tmp_str, ast_channel_named_callgroups(chan)), len);
536         } else if (!strcasecmp(data, "namedpickupgroup")) {
537                 struct ast_str *tmp_str = ast_str_alloca(1024);
538
539                 locked_copy_string(chan, buf,  ast_print_namedgroups(&tmp_str, ast_channel_named_pickupgroups(chan)), len);
540         } else if (!strcasecmp(data, "after_bridge_goto")) {
541                 ast_bridge_read_after_goto(chan, buf, len);
542         } else if (!strcasecmp(data, "amaflags")) {
543                 ast_channel_lock(chan);
544                 snprintf(buf, len, "%u", ast_channel_amaflags(chan));
545                 ast_channel_unlock(chan);
546         } else if (!strncasecmp(data, "secure_bridge_", 14)) {
547                 struct ast_datastore *ds;
548
549                 ast_channel_lock(chan);
550                 if ((ds = ast_channel_datastore_find(chan, &secure_call_info, NULL))) {
551                         struct ast_secure_call_store *encrypt = ds->data;
552                         if (!strcasecmp(data, "secure_bridge_signaling")) {
553                                 snprintf(buf, len, "%s", encrypt->signaling ? "1" : "");
554                         } else if (!strcasecmp(data, "secure_bridge_media")) {
555                                 snprintf(buf, len, "%s", encrypt->media ? "1" : "");
556                         }
557                 }
558                 ast_channel_unlock(chan);
559         } 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)) {
560                 ast_log(LOG_WARNING, "Unknown or unavailable item requested: '%s'\n", data);
561                 ret = -1;
562         }
563
564         return ret;
565 }
566
567 static int func_channel_write_real(struct ast_channel *chan, const char *function,
568                               char *data, const char *value)
569 {
570         int ret = 0;
571         signed char gainset;
572
573         if (!strcasecmp(data, "language"))
574                 locked_string_field_set(chan, language, value);
575         else if (!strcasecmp(data, "parkinglot"))
576                 locked_string_field_set(chan, parkinglot, value);
577         else if (!strcasecmp(data, "musicclass"))
578                 locked_string_field_set(chan, musicclass, value);
579         else if (!strcasecmp(data, "accountcode"))
580                 locked_string_field_set(chan, accountcode, value);
581         else if (!strcasecmp(data, "userfield"))
582                 locked_string_field_set(chan, userfield, value);
583         else if (!strcasecmp(data, "after_bridge_goto")) {
584                 if (ast_strlen_zero(value)) {
585                         ast_bridge_discard_after_goto(chan);
586                 } else {
587                         ast_bridge_set_after_go_on(chan, ast_channel_context(chan), ast_channel_exten(chan), ast_channel_priority(chan), value);
588                 }
589         } else if (!strcasecmp(data, "amaflags")) {
590                 ast_channel_lock(chan);
591                 if (isdigit(*value)) {
592                         int amaflags;
593                         sscanf(value, "%30d", &amaflags);
594                         ast_channel_amaflags_set(chan, amaflags);
595                 } else if (!strcasecmp(value,"OMIT")){
596                         ast_channel_amaflags_set(chan, 1);
597                 } else if (!strcasecmp(value,"BILLING")){
598                         ast_channel_amaflags_set(chan, 2);
599                 } else if (!strcasecmp(value,"DOCUMENTATION")){
600                         ast_channel_amaflags_set(chan, 3);
601                 }
602                 ast_channel_unlock(chan);
603         } else if (!strcasecmp(data, "peeraccount"))
604                 locked_string_field_set(chan, peeraccount, value);
605         else if (!strcasecmp(data, "hangupsource"))
606                 /* XXX - should we be forcing this here? */
607                 ast_set_hangupsource(chan, value, 0);
608 #ifdef CHANNEL_TRACE
609         else if (!strcasecmp(data, "trace")) {
610                 ast_channel_lock(chan);
611                 if (ast_true(value))
612                         ret = ast_channel_trace_enable(chan);
613                 else if (ast_false(value))
614                         ret = ast_channel_trace_disable(chan);
615                 else {
616                         ret = -1;
617                         ast_log(LOG_WARNING, "Invalid value for CHANNEL(trace).\n");
618                 }
619                 ast_channel_unlock(chan);
620         }
621 #endif
622         else if (!strcasecmp(data, "tonezone")) {
623                 struct ast_tone_zone *new_zone;
624                 if (!(new_zone = ast_get_indication_zone(value))) {
625                         ast_log(LOG_ERROR, "Unknown country code '%s' for tonezone. Check indications.conf for available country codes.\n", value);
626                         ret = -1;
627                 } else {
628                         ast_channel_lock(chan);
629                         if (ast_channel_zone(chan)) {
630                                 ast_channel_zone_set(chan, ast_tone_zone_unref(ast_channel_zone(chan)));
631                         }
632                         ast_channel_zone_set(chan, ast_tone_zone_ref(new_zone));
633                         ast_channel_unlock(chan);
634                         new_zone = ast_tone_zone_unref(new_zone);
635                 }
636         } else if (!strcasecmp(data, "dtmf_features")) {
637                 ret = ast_bridge_features_ds_set_string(chan, value);
638         } else if (!strcasecmp(data, "callgroup")) {
639                 ast_channel_lock(chan);
640                 ast_channel_callgroup_set(chan, ast_get_group(value));
641                 ast_channel_unlock(chan);
642         } else if (!strcasecmp(data, "pickupgroup")) {
643                 ast_channel_lock(chan);
644                 ast_channel_pickupgroup_set(chan, ast_get_group(value));
645                 ast_channel_unlock(chan);
646         } else if (!strcasecmp(data, "namedcallgroup")) {
647                 struct ast_namedgroups *groups = ast_get_namedgroups(value);
648
649                 ast_channel_lock(chan);
650                 ast_channel_named_callgroups_set(chan, groups);
651                 ast_channel_unlock(chan);
652                 ast_unref_namedgroups(groups);
653         } else if (!strcasecmp(data, "namedpickupgroup")) {
654                 struct ast_namedgroups *groups = ast_get_namedgroups(value);
655
656                 ast_channel_lock(chan);
657                 ast_channel_named_pickupgroups_set(chan, groups);
658                 ast_channel_unlock(chan);
659                 ast_unref_namedgroups(groups);
660         } else if (!strcasecmp(data, "txgain")) {
661                 sscanf(value, "%4hhd", &gainset);
662                 ast_channel_setoption(chan, AST_OPTION_TXGAIN, &gainset, sizeof(gainset), 0);
663         } else if (!strcasecmp(data, "rxgain")) {
664                 sscanf(value, "%4hhd", &gainset);
665                 ast_channel_setoption(chan, AST_OPTION_RXGAIN, &gainset, sizeof(gainset), 0);
666         } else if (!strcasecmp(data, "transfercapability")) {
667                 unsigned short i;
668
669                 ast_channel_lock(chan);
670                 for (i = 0; i < 0x20; i++) {
671                         if (!strcasecmp(transfercapability_table[i], value) && strcmp(value, "UNK")) {
672                                 ast_channel_transfercapability_set(chan, i);
673                                 break;
674                         }
675                 }
676                 ast_channel_unlock(chan);
677         } else if (!strcasecmp(data, "hangup_handler_pop")) {
678                 /* Pop one hangup handler before pushing the new handler. */
679                 ast_pbx_hangup_handler_pop(chan);
680                 ast_pbx_hangup_handler_push(chan, value);
681         } else if (!strcasecmp(data, "hangup_handler_push")) {
682                 ast_pbx_hangup_handler_push(chan, value);
683         } else if (!strcasecmp(data, "hangup_handler_wipe")) {
684                 /* Pop all hangup handlers before pushing the new handler. */
685                 while (ast_pbx_hangup_handler_pop(chan)) {
686                 }
687                 ast_pbx_hangup_handler_push(chan, value);
688         } else if (!strncasecmp(data, "secure_bridge_", 14)) {
689                 struct ast_datastore *ds;
690                 struct ast_secure_call_store *store;
691
692                 if (!chan || !value) {
693                         return -1;
694                 }
695
696                 ast_channel_lock(chan);
697                 if (!(ds = ast_channel_datastore_find(chan, &secure_call_info, NULL))) {
698                         if (!(ds = ast_datastore_alloc(&secure_call_info, NULL))) {
699                                 ast_channel_unlock(chan);
700                                 return -1;
701                         }
702                         if (!(store = ast_calloc(1, sizeof(*store)))) {
703                                 ast_channel_unlock(chan);
704                                 ast_free(ds);
705                                 return -1;
706                         }
707                         ds->data = store;
708                         ast_channel_datastore_add(chan, ds);
709                 } else {
710                         store = ds->data;
711                 }
712
713                 if (!strcasecmp(data, "secure_bridge_signaling")) {
714                         store->signaling = ast_true(value) ? 1 : 0;
715                 } else if (!strcasecmp(data, "secure_bridge_media")) {
716                         store->media = ast_true(value) ? 1 : 0;
717                 }
718                 ast_channel_unlock(chan);
719         } else if (!ast_channel_tech(chan)->func_channel_write
720                  || ast_channel_tech(chan)->func_channel_write(chan, function, data, value)) {
721                 ast_log(LOG_WARNING, "Unknown or unavailable item requested: '%s'\n",
722                                 data);
723                 ret = -1;
724         }
725
726         return ret;
727 }
728
729 static int func_channel_write(struct ast_channel *chan, const char *function, char *data, const char *value)
730 {
731         int res;
732         ast_chan_write_info_t write_info = {
733                 .version = AST_CHAN_WRITE_INFO_T_VERSION,
734                 .write_fn = func_channel_write_real,
735                 .chan = chan,
736                 .function = function,
737                 .data = data,
738                 .value = value,
739         };
740
741         if (!chan) {
742                 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
743                 return -1;
744         }
745
746         res = func_channel_write_real(chan, function, data, value);
747         ast_channel_setoption(chan, AST_OPTION_CHANNEL_WRITE, &write_info, sizeof(write_info), 0);
748
749         return res;
750 }
751
752 static struct ast_custom_function channel_function = {
753         .name = "CHANNEL",
754         .read = func_channel_read,
755         .write = func_channel_write,
756 };
757
758 static int func_channels_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t maxlen)
759 {
760         struct ast_channel *c = NULL;
761         regex_t re;
762         int res;
763         size_t buflen = 0;
764         struct ast_channel_iterator *iter;
765
766         buf[0] = '\0';
767
768         if (!ast_strlen_zero(data)) {
769                 if ((res = regcomp(&re, data, REG_EXTENDED | REG_ICASE | REG_NOSUB))) {
770                         regerror(res, &re, buf, maxlen);
771                         ast_log(LOG_WARNING, "Error compiling regular expression for %s(%s): %s\n", function, data, buf);
772                         return -1;
773                 }
774         }
775
776         if (!(iter = ast_channel_iterator_all_new())) {
777                 if (!ast_strlen_zero(data)) {
778                         regfree(&re);
779                 }
780                 return -1;
781         }
782
783         while ((c = ast_channel_iterator_next(iter))) {
784                 ast_channel_lock(c);
785                 if (ast_strlen_zero(data) || regexec(&re, ast_channel_name(c), 0, NULL, 0) == 0) {
786                         size_t namelen = strlen(ast_channel_name(c));
787                         if (buflen + namelen + (ast_strlen_zero(buf) ? 0 : 1) + 1 < maxlen) {
788                                 if (!ast_strlen_zero(buf)) {
789                                         strcat(buf, " ");
790                                         buflen++;
791                                 }
792                                 strcat(buf, ast_channel_name(c));
793                                 buflen += namelen;
794                         } else {
795                                 ast_log(LOG_WARNING, "Number of channels exceeds the available buffer space.  Output will be truncated!\n");
796                         }
797                 }
798                 ast_channel_unlock(c);
799                 c = ast_channel_unref(c);
800         }
801
802         ast_channel_iterator_destroy(iter);
803
804         if (!ast_strlen_zero(data)) {
805                 regfree(&re);
806         }
807
808         return 0;
809 }
810
811 static struct ast_custom_function channels_function = {
812         .name = "CHANNELS",
813         .read = func_channels_read,
814 };
815
816 static int func_mchan_read(struct ast_channel *chan, const char *function,
817                              char *data, struct ast_str **buf, ssize_t len)
818 {
819         struct ast_channel *mchan;
820         char *template = ast_alloca(4 + strlen(data));
821
822         if (!chan) {
823                 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
824                 return -1;
825         }
826
827         mchan = ast_channel_get_by_name(ast_channel_linkedid(chan));
828         sprintf(template, "${%s}", data); /* SAFE */
829         ast_str_substitute_variables(buf, len, mchan ? mchan : chan, template);
830         if (mchan) {
831                 ast_channel_unref(mchan);
832         }
833         return 0;
834 }
835
836 static int func_mchan_write(struct ast_channel *chan, const char *function,
837                               char *data, const char *value)
838 {
839         struct ast_channel *mchan;
840
841         if (!chan) {
842                 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
843                 return -1;
844         }
845
846         mchan = ast_channel_get_by_name(ast_channel_linkedid(chan));
847         pbx_builtin_setvar_helper(mchan ? mchan : chan, data, value);
848         if (mchan) {
849                 ast_channel_unref(mchan);
850         }
851         return 0;
852 }
853
854 static struct ast_custom_function mchan_function = {
855         .name = "MASTER_CHANNEL",
856         .read2 = func_mchan_read,
857         .write = func_mchan_write,
858 };
859
860 static int unload_module(void)
861 {
862         int res = 0;
863
864         res |= ast_custom_function_unregister(&channel_function);
865         res |= ast_custom_function_unregister(&channels_function);
866         res |= ast_custom_function_unregister(&mchan_function);
867
868         return res;
869 }
870
871 static int load_module(void)
872 {
873         int res = 0;
874
875         res |= ast_custom_function_register(&channel_function);
876         res |= ast_custom_function_register(&channels_function);
877         res |= ast_custom_function_register(&mchan_function);
878
879         return res;
880 }
881
882 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Channel information dialplan functions");