resource_channels.c File Reference

Implementation for ARI stubs. More...

#include "asterisk.h"
#include "asterisk/file.h"
#include "asterisk/pbx.h"
#include "asterisk/bridge.h"
#include "asterisk/callerid.h"
#include "asterisk/stasis_app.h"
#include "asterisk/stasis_app_playback.h"
#include "asterisk/stasis_app_recording.h"
#include "asterisk/stasis_app_snoop.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/causes.h"
#include "asterisk/format_cache.h"
#include "asterisk/core_local.h"
#include "asterisk/dial.h"
#include "asterisk/max_forwards.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/websocket_client.h"
#include "resource_channels.h"
#include <limits.h>
#include "asterisk/config.h"
#include "asterisk/netsock2.h"

Include dependency graph for resource_channels.c:

Go to the source code of this file.

Data Structures
struct	ari_channel_thread_data
struct	ari_origination
	Structure used for origination. More...

Functions
static void *	ari_channel_thread (void *data)
	Thread that owns stasis-created channel.
static struct ast_channel *	ari_channels_handle_originate_with_id (const char *args_endpoint, const char *args_extension, const char *args_context, long args_priority, const char *args_label, const char *args_app, const char *args_app_args, const char *args_caller_id, int args_timeout, struct ast_variable *variables, struct ast_variable *report_event_variables, const char *args_channel_id, const char *args_other_channel_id, const char *args_originator, const char *args_formats, struct ast_ari_response *response)
static void	ari_channels_handle_play (const char *args_channel_id, const char **args_media, size_t args_media_count, const char *args_lang, int args_offsetms, int args_skipms, const char *args_playback_id, struct ast_ari_response *response)
static void	ari_channels_handle_snoop_channel (const char *args_channel_id, const char *args_spy, const char *args_whisper, const char *args_app, const char *args_app_args, const char *args_snoop_id, struct ast_ari_response *response)
static void *	ari_originate_dial (void *data)
	Thread which dials and executes upon answer.
void	ast_ari_channels_answer (struct ast_variable *headers, struct ast_ari_channels_answer_args *args, struct ast_ari_response *response)
	Answer a channel.
void	ast_ari_channels_continue_in_dialplan (struct ast_variable *headers, struct ast_ari_channels_continue_in_dialplan_args *args, struct ast_ari_response *response)
	Exit application; continue execution in the dialplan.
void	ast_ari_channels_create (struct ast_variable *headers, struct ast_ari_channels_create_args *args, struct ast_ari_response *response)
	Create channel.
void	ast_ari_channels_dial (struct ast_variable *headers, struct ast_ari_channels_dial_args *args, struct ast_ari_response *response)
	Dial a created channel.
void	ast_ari_channels_external_media (struct ast_variable *headers, struct ast_ari_channels_external_media_args *args, struct ast_ari_response *response)
	Start an External Media session.
void	ast_ari_channels_get (struct ast_variable *headers, struct ast_ari_channels_get_args *args, struct ast_ari_response *response)
	Channel details.
void	ast_ari_channels_get_channel_var (struct ast_variable *headers, struct ast_ari_channels_get_channel_var_args *args, struct ast_ari_response *response)
	Get the value of a channel variable or function.
void	ast_ari_channels_get_channel_vars (struct ast_variable *headers, struct ast_ari_channels_get_channel_vars_args *args, struct ast_ari_response *response)
	Get the value of multiple channel variables or functions.
void	ast_ari_channels_hangup (struct ast_variable *headers, struct ast_ari_channels_hangup_args *args, struct ast_ari_response *response)
	Delete (i.e. hangup) a channel.
void	ast_ari_channels_hold (struct ast_variable *headers, struct ast_ari_channels_hold_args *args, struct ast_ari_response *response)
	Hold a channel.
void	ast_ari_channels_list (struct ast_variable *headers, struct ast_ari_channels_list_args *args, struct ast_ari_response *response)
	List all active channels in Asterisk.
void	ast_ari_channels_move (struct ast_variable *headers, struct ast_ari_channels_move_args *args, struct ast_ari_response *response)
	Move the channel from one Stasis application to another.
void	ast_ari_channels_mute (struct ast_variable *headers, struct ast_ari_channels_mute_args *args, struct ast_ari_response *response)
	Mute a channel.
void	ast_ari_channels_originate (struct ast_variable *headers, struct ast_ari_channels_originate_args *args, struct ast_ari_response *response)
	Create a new channel (originate).
void	ast_ari_channels_originate_with_id (struct ast_variable *headers, struct ast_ari_channels_originate_with_id_args *args, struct ast_ari_response *response)
	Create a new channel (originate with id).
void	ast_ari_channels_play (struct ast_variable *headers, struct ast_ari_channels_play_args *args, struct ast_ari_response *response)
	Start playback of media.
void	ast_ari_channels_play_with_id (struct ast_variable *headers, struct ast_ari_channels_play_with_id_args *args, struct ast_ari_response *response)
	Start playback of media and specify the playbackId.
void	ast_ari_channels_progress (struct ast_variable *headers, struct ast_ari_channels_progress_args *args, struct ast_ari_response *response)
	Indicate progress on a channel.
void	ast_ari_channels_record (struct ast_variable *headers, struct ast_ari_channels_record_args *args, struct ast_ari_response *response)
	Start a recording.
void	ast_ari_channels_redirect (struct ast_variable *headers, struct ast_ari_channels_redirect_args *args, struct ast_ari_response *response)
	Redirect the channel to a different location.
void	ast_ari_channels_ring (struct ast_variable *headers, struct ast_ari_channels_ring_args *args, struct ast_ari_response *response)
	Indicate ringing to a channel.
void	ast_ari_channels_ring_stop (struct ast_variable *headers, struct ast_ari_channels_ring_stop_args *args, struct ast_ari_response *response)
	Stop ringing indication on a channel if locally generated.
void	ast_ari_channels_rtpstatistics (struct ast_variable *headers, struct ast_ari_channels_rtpstatistics_args *args, struct ast_ari_response *response)
	RTP stats on a channel.
void	ast_ari_channels_send_dtmf (struct ast_variable *headers, struct ast_ari_channels_send_dtmf_args *args, struct ast_ari_response *response)
	Send provided DTMF to a given channel.
void	ast_ari_channels_set_channel_var (struct ast_variable *headers, struct ast_ari_channels_set_channel_var_args *args, struct ast_ari_response *response)
	Set the value of a channel variable or function.
void	ast_ari_channels_set_channel_vars (struct ast_variable *headers, struct ast_ari_channels_set_channel_vars_args *args, struct ast_ari_response *response)
	Set the values of multiple channel variables or functions.
void	ast_ari_channels_snoop_channel (struct ast_variable *headers, struct ast_ari_channels_snoop_channel_args *args, struct ast_ari_response *response)
	Start snooping.
void	ast_ari_channels_snoop_channel_with_id (struct ast_variable *headers, struct ast_ari_channels_snoop_channel_with_id_args *args, struct ast_ari_response *response)
	Start snooping.
void	ast_ari_channels_start_moh (struct ast_variable *headers, struct ast_ari_channels_start_moh_args *args, struct ast_ari_response *response)
	Play music on hold to a channel.
void	ast_ari_channels_start_silence (struct ast_variable *headers, struct ast_ari_channels_start_silence_args *args, struct ast_ari_response *response)
	Play silence to a channel.
void	ast_ari_channels_stop_moh (struct ast_variable *headers, struct ast_ari_channels_stop_moh_args *args, struct ast_ari_response *response)
	Stop playing music on hold to a channel.
void	ast_ari_channels_stop_silence (struct ast_variable *headers, struct ast_ari_channels_stop_silence_args *args, struct ast_ari_response *response)
	Stop playing silence to a channel.
void	ast_ari_channels_transfer_progress (struct ast_variable *headers, struct ast_ari_channels_transfer_progress_args *args, struct ast_ari_response *response)
	Inform the channel about the progress of the attended/blind transfer.
void	ast_ari_channels_unhold (struct ast_variable *headers, struct ast_ari_channels_unhold_args *args, struct ast_ari_response *response)
	Remove a channel from hold.
void	ast_ari_channels_unmute (struct ast_variable *headers, struct ast_ari_channels_unmute_args *args, struct ast_ari_response *response)
	Unmute a channel.
static void	chan_data_destroy (struct ari_channel_thread_data *chan_data)
static int	channel_state_invalid (struct stasis_app_control *control, struct ast_ari_response *response)
	Ensure channel is in a state that allows operation to be performed.
static int	convert_reason_to_hangup_code (const char *reason)
	Return the corresponded hangup code of the given reason.
static int	external_media_audiosocket_tcp (struct ast_ari_channels_external_media_args *args, struct ast_variable *variables, struct ast_variable *report_event_variables, struct ast_ari_response *response)
static int	external_media_rtp_udp (struct ast_ari_channels_external_media_args *args, struct ast_variable *variables, struct ast_variable *report_event_variables, struct ast_ari_response *response)
static int	external_media_websocket (struct ast_ari_channels_external_media_args *args, struct ast_variable *variables, struct ast_variable *report_event_variables, struct ast_ari_response *response)
static struct stasis_app_control *	find_control (struct ast_ari_response *response, const char *channel_id)
	Finds the control object for a channel, filling the response with an error, if appropriate.
static int	json_to_ast_variables (struct ast_ari_response *response, struct ast_json *json_variables, struct ast_variable **variables, struct ast_variable **report_event_variables)
static char *	restore_dialstring (struct ast_channel *chan)
	Retrieve the dialstring from the channel datastore.
static int	save_dialstring (struct ast_channel *chan, const char *dialstring)
	Save dialstring onto a channel datastore.

Variables
struct ast_datastore_info	dialstring_info

Detailed Description

Implementation for ARI stubs.

Author

David M. Lee, II dlee@.nosp@m.digi.nosp@m.um.co.nosp@m.m

Definition in file resource_channels.c.

Function Documentation

ari_channel_thread()

static void * ari_channel_thread ( void *  data )

static

Thread that owns stasis-created channel.

The channel enters into a Stasis application immediately upon creation. In this way, the channel can be manipulated by the Stasis application. Once the channel exits the Stasis application, it is hung up.

Definition at line 2009 of file resource_channels.c.

{
    struct ari_channel_thread_data *chan_data = data;
    struct ast_app *stasis_app;
 
    stasis_app = pbx_findapp("Stasis");
    if (!stasis_app) {
        ast_log(LOG_ERROR, "Stasis dialplan application is not registered");
        chan_data_destroy(chan_data);
        return NULL;
    }
 
    pbx_exec(chan_data->chan, stasis_app, ast_str_buffer(chan_data->stasis_stuff));
 
    chan_data_destroy(chan_data);
 
    return NULL;
}

References ast_log, ast_str_buffer(), ari_channel_thread_data::chan, chan_data_destroy(), LOG_ERROR, NULL, pbx_exec(), pbx_findapp(), and ari_channel_thread_data::stasis_stuff.

Referenced by ast_ari_channels_create().

ari_channels_handle_originate_with_id()

static struct ast_channel * ari_channels_handle_originate_with_id ( const char *  args_endpoint, const char *  args_extension, const char *  args_context, long  args_priority, const char *  args_label, const char *  args_app, const char *  args_app_args, const char *  args_caller_id, int  args_timeout, struct ast_variable *  variables, struct ast_variable *  report_event_variables, const char *  args_channel_id, const char *  args_other_channel_id, const char *  args_originator, const char *  args_formats, struct ast_ari_response *  response  )

static

Definition at line 1115 of file resource_channels.c.

{
    char *dialtech;
    char *dialdevice = NULL;
    struct ast_dial *dial;
    char *caller_id = NULL;
    char *cid_num = NULL;
    char *cid_name = NULL;
    char *stuff;
    struct ast_channel *other = NULL;
    struct ast_channel *chan = NULL;
    RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
    struct ast_assigned_ids assignedids = {
        .uniqueid = args_channel_id,
        .uniqueid2 = args_other_channel_id,
    };
    struct ari_origination *origination;
    pthread_t thread;
    struct ast_format_cap *format_cap = NULL;
 
    if ((assignedids.uniqueid && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid))
        || (assignedids.uniqueid2 && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid2))) {
        ast_ari_response_error(response, 400, "Bad Request",
            "Uniqueid length exceeds maximum of %d", AST_MAX_PUBLIC_UNIQUEID);
        return NULL;
    }
 
    if (ast_strlen_zero(args_endpoint)) {
        ast_ari_response_error(response, 400, "Bad Request",
            "Endpoint must be specified");
        return NULL;
    }
 
    if (!ast_strlen_zero(args_originator) && !ast_strlen_zero(args_formats)) {
        ast_ari_response_error(response, 400, "Bad Request",
            "Originator and formats can't both be specified");
        return NULL;
    }
 
    dialtech = ast_strdupa(args_endpoint);
    if ((stuff = strchr(dialtech, '/'))) {
        *stuff++ = '\0';
        dialdevice = stuff;
    }
 
    if (ast_strlen_zero(dialtech) || ast_strlen_zero(dialdevice)) {
        ast_ari_response_error(response, 400, "Bad Request",
            "Invalid endpoint specified");
        return NULL;
    }
 
    if (!ast_strlen_zero(args_app)) {
        RAII_VAR(struct ast_str *, appdata, ast_str_create(64), ast_free);
 
        if (!appdata) {
            ast_ari_response_alloc_failed(response);
            return NULL;
        }
 
        ast_str_set(&appdata, 0, "%s", args_app);
        if (!ast_strlen_zero(args_app_args)) {
            ast_str_append(&appdata, 0, ",%s", args_app_args);
        }
 
        origination = ast_calloc(1, sizeof(*origination) + ast_str_size(appdata) + 1);
        if (!origination) {
            ast_ari_response_alloc_failed(response);
            return NULL;
        }
 
        strcpy(origination->appdata, ast_str_buffer(appdata));
    } else if (!ast_strlen_zero(args_extension)) {
        origination = ast_calloc(1, sizeof(*origination) + 1);
        if (!origination) {
            ast_ari_response_alloc_failed(response);
            return NULL;
        }
 
        ast_copy_string(origination->context, S_OR(args_context, "default"), sizeof(origination->context));
        ast_copy_string(origination->exten, args_extension, sizeof(origination->exten));
 
        if (!ast_strlen_zero(args_label)) {
            /* A label was provided in the request, use that */
            int ipri = 1;
            if (sscanf(args_label, "%30d", &ipri) != 1) {
                ipri = ast_findlabel_extension(chan, origination->context, origination->exten, args_label, args_caller_id);
 
                if (ipri == -1) {
                    ast_log(AST_LOG_ERROR, "Requested label: %s can not be found in context: %s\n", args_label, args_context);
                    ast_ari_response_error(response, 404, "Not Found", "Requested label can not be found");
                    return NULL;
                }
            } else {
                ast_debug(3, "Numeric value provided for label, jumping to that priority\n");
            }
 
            if (ipri == 0) {
                ast_log(AST_LOG_ERROR, "Invalid priority label '%s' specified for extension %s in context: %s\n",
                        args_label, args_extension, args_context);
                ast_ari_response_error(response, 400, "Bad Request", "Requested priority is illegal");
                return NULL;
            }
 
            /* Our priority was provided by a label */
            origination->priority =  ipri;
        } else {
            /* No label provided, use provided priority */
            origination->priority = args_priority ? args_priority : 1;
        }
 
        origination->appdata[0] = '\0';
    } else {
        ast_ari_response_error(response, 400, "Bad Request",
            "Application or extension must be specified");
        return NULL;
    }
 
    dial = ast_dial_create();
    if (!dial) {
        ast_ari_response_alloc_failed(response);
        ast_free(origination);
        return NULL;
    }
    ast_dial_set_user_data(dial, origination);
 
    if (ast_dial_append(dial, dialtech, dialdevice, &assignedids)) {
        ast_ari_response_alloc_failed(response);
        ast_dial_destroy(dial);
        ast_free(origination);
        return NULL;
    }
 
    if (args_timeout > 0) {
        ast_dial_set_global_timeout(dial, args_timeout * 1000);
    } else if (args_timeout == -1) {
        ast_dial_set_global_timeout(dial, -1);
    } else {
        ast_dial_set_global_timeout(dial, 30000);
    }
 
    if (!ast_strlen_zero(args_caller_id)) {
        caller_id = ast_strdupa(args_caller_id);
        ast_callerid_parse(caller_id, &cid_name, &cid_num);
 
        if (ast_is_shrinkable_phonenumber(cid_num)) {
            ast_shrink_phone_number(cid_num);
        }
    }
 
    if (!ast_strlen_zero(args_originator)) {
        other = ast_channel_get_by_name(args_originator);
        if (!other) {
            ast_ari_response_error(
                response, 400, "Bad Request",
                "Provided originator channel was not found");
            ast_dial_destroy(dial);
            ast_free(origination);
            return NULL;
        }
    }
 
    if (!ast_strlen_zero(args_formats)) {
        char *format_name;
        char *formats_copy = ast_strdupa(args_formats);
 
        if (!(format_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
            ast_ari_response_alloc_failed(response);
            ast_dial_destroy(dial);
            ast_free(origination);
            ast_channel_cleanup(other);
            return NULL;
        }
 
        while ((format_name = ast_strip(strsep(&formats_copy, ",")))) {
            struct ast_format *fmt = ast_format_cache_get(format_name);
 
            if (!fmt || ast_format_cap_append(format_cap, fmt, 0)) {
                if (!fmt) {
                    ast_ari_response_error(
                        response, 400, "Bad Request",
                        "Provided format (%s) was not found", format_name);
                } else {
                    ast_ari_response_alloc_failed(response);
                }
                ast_dial_destroy(dial);
                ast_free(origination);
                ast_channel_cleanup(other);
                ao2_ref(format_cap, -1);
                ao2_cleanup(fmt);
                return NULL;
            }
            ao2_ref(fmt, -1);
        }
    }
 
    if (ast_dial_prerun(dial, other, format_cap)) {
        if (ast_channel_errno() == AST_CHANNEL_ERROR_ID_EXISTS) {
            ast_ari_response_error(response, 409, "Conflict",
                "Channel with given unique ID already exists");
        } else {
            ast_ari_response_alloc_failed(response);
        }
        ast_dial_destroy(dial);
        ast_free(origination);
        ast_channel_cleanup(other);
        return NULL;
    }
 
    ast_channel_cleanup(other);
    ao2_cleanup(format_cap);
 
    chan = ast_dial_get_channel(dial, 0);
    if (!chan) {
        ast_ari_response_alloc_failed(response);
        ast_dial_destroy(dial);
        ast_free(origination);
        return NULL;
    }
 
    if (!ast_strlen_zero(cid_num) || !ast_strlen_zero(cid_name)) {
        struct ast_party_connected_line connected;
 
        /*
         * It seems strange to set the CallerID on an outgoing call leg
         * to whom we are calling, but this function's callers are doing
         * various Originate methods.  This call leg goes to the local
         * user.  Once the called party answers, the dialplan needs to
         * be able to access the CallerID from the CALLERID function as
         * if the called party had placed this call.
         */
        ast_set_callerid(chan, cid_num, cid_name, cid_num);
 
        ast_party_connected_line_set_init(&connected, ast_channel_connected(chan));
        if (!ast_strlen_zero(cid_num)) {
            connected.id.number.valid = 1;
            connected.id.number.str = (char *) cid_num;
            connected.id.number.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
        }
        if (!ast_strlen_zero(cid_name)) {
            connected.id.name.valid = 1;
            connected.id.name.str = (char *) cid_name;
            connected.id.name.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
        }
        ast_channel_set_connected_line(chan, &connected, NULL);
    }
 
    if (variables) {
        ast_set_variables(chan, variables);
    }
    ast_set_flag(ast_channel_flags(chan), AST_FLAG_ORIGINATED);
 
    if (!ast_strlen_zero(args_app)) {
        struct ast_channel *local_peer;
 
        stasis_app_subscribe_channel(args_app, chan);
 
        /* Subscribe to the Local channel peer also. */
        local_peer = ast_local_get_peer(chan);
        if (local_peer) {
            stasis_app_subscribe_channel(args_app, local_peer);
            ast_channel_unref(local_peer);
        }
    }
 
    if (report_event_variables) {
        struct ast_variable *var;
 
        for (var = report_event_variables; var; var = var->next) {
            if (ast_channel_set_ari_var_reportable(chan, var->name, 1)) {
                ast_ari_response_alloc_failed(response);
                ast_dial_destroy(dial);
                ast_free(origination);
                return NULL;
            }
        }
    }
    snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan));
 
    /* Before starting the async dial bump the ref in case the dial quickly goes away and takes
     * the reference with it
     */
    ast_channel_ref(chan);
 
    if (ast_pthread_create_detached(&thread, NULL, ari_originate_dial, dial)) {
        ast_ari_response_alloc_failed(response);
        ast_dial_destroy(dial);
        ast_free(origination);
    } else {
        ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot, NULL));
    }
 
    return chan;
}

References ao2_cleanup, ao2_ref, ari_origination::appdata, ari_originate_dial(), ast_ari_response_alloc_failed(), ast_ari_response_error(), ast_ari_response_ok(), ast_callerid_parse(), ast_calloc, ast_channel_cleanup, ast_channel_connected(), ast_channel_errno(), AST_CHANNEL_ERROR_ID_EXISTS, ast_channel_flags(), ast_channel_get_by_name(), ast_channel_ref, ast_channel_set_ari_var_reportable(), ast_channel_set_connected_line(), ast_channel_snapshot_get_latest(), ast_channel_snapshot_to_json(), ast_channel_uniqueid(), ast_channel_unref, ast_copy_string(), ast_debug, ast_dial_append(), ast_dial_create(), ast_dial_destroy(), ast_dial_get_channel(), ast_dial_prerun(), ast_dial_set_global_timeout(), ast_dial_set_user_data(), ast_findlabel_extension(), AST_FLAG_ORIGINATED, ast_format_cache_get, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_free, ast_is_shrinkable_phonenumber(), ast_local_get_peer(), ast_log, AST_LOG_ERROR, AST_MAX_PUBLIC_UNIQUEID, ast_party_connected_line_set_init(), AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, ast_pthread_create_detached, ast_set_callerid(), ast_set_flag, ast_set_variables(), ast_shrink_phone_number(), ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_str_size(), ast_strdupa, ast_strip(), ast_strlen_zero(), connected, ari_origination::context, ari_origination::exten, ast_variable::next, NULL, ari_origination::priority, RAII_VAR, S_OR, ast_channel::snapshot, stasis_app_subscribe_channel(), strsep(), thread, ast_assigned_ids::uniqueid, ast_assigned_ids::uniqueid2, and var.

Referenced by ast_ari_channels_originate(), ast_ari_channels_originate_with_id(), external_media_audiosocket_tcp(), external_media_rtp_udp(), and external_media_websocket().

ari_channels_handle_play()

static void ari_channels_handle_play ( const char *  args_channel_id, const char **  args_media, size_t  args_media_count, const char *  args_lang, int  args_offsetms, int  args_skipms, const char *  args_playback_id, struct ast_ari_response *  response  )

static

Definition at line 657 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_app_playback *, playback, NULL, ao2_cleanup);
    RAII_VAR(char *, playback_url, NULL, ast_free);
    struct ast_json *json;
    const char *language;
 
    ast_assert(response != NULL);
 
    control = find_control(response, args_channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    snapshot = stasis_app_control_get_snapshot(control);
    if (!snapshot) {
        ast_ari_response_error(
            response, 404, "Not Found",
            "Channel not found");
        return;
    }
 
    if (args_skipms < 0) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "skipms cannot be negative");
        return;
    }
 
    if (args_offsetms < 0) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "offsetms cannot be negative");
        return;
    }
 
    language = S_OR(args_lang, snapshot->base->language);
 
    playback = stasis_app_control_play_uri(control, args_media, args_media_count, language,
        args_channel_id, STASIS_PLAYBACK_TARGET_CHANNEL, args_skipms, args_offsetms, args_playback_id);
    if (!playback) {
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Failed to queue media for playback");
        return;
    }
 
    if (ast_asprintf(&playback_url, "/playbacks/%s",
            stasis_app_playback_get_id(playback)) == -1) {
        playback_url = NULL;
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Out of memory");
        return;
    }
 
    json = stasis_app_playback_to_json(playback);
    if (!json) {
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Out of memory");
        return;
    }
 
    ast_ari_response_created(response, playback_url, json);
}

References ao2_cleanup, ast_ari_response_created(), ast_ari_response_error(), ast_asprintf, ast_assert, ast_free, channel_state_invalid(), find_control(), language, NULL, RAII_VAR, S_OR, stasis_app_control_get_snapshot(), stasis_app_control_play_uri(), stasis_app_playback_get_id(), stasis_app_playback_to_json(), and STASIS_PLAYBACK_TARGET_CHANNEL.

Referenced by ast_ari_channels_play(), and ast_ari_channels_play_with_id().

ari_channels_handle_snoop_channel()

static void ari_channels_handle_snoop_channel ( const char *  args_channel_id, const char *  args_spy, const char *  args_whisper, const char *  args_app, const char *  args_app_args, const char *  args_snoop_id, struct ast_ari_response *  response  )

static

Definition at line 1883 of file resource_channels.c.

{
    enum stasis_app_snoop_direction spy, whisper;
    RAII_VAR(struct ast_channel *, chan, NULL, ast_channel_cleanup);
    RAII_VAR(struct ast_channel *, snoop, NULL, ast_channel_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
 
    ast_assert(response != NULL);
 
    if (ast_strlen_zero(args_spy) || !strcmp(args_spy, "none")) {
        spy = STASIS_SNOOP_DIRECTION_NONE;
    } else if (!strcmp(args_spy, "both")) {
        spy = STASIS_SNOOP_DIRECTION_BOTH;
    } else if (!strcmp(args_spy, "out")) {
        spy = STASIS_SNOOP_DIRECTION_OUT;
    } else if (!strcmp(args_spy, "in")) {
        spy = STASIS_SNOOP_DIRECTION_IN;
    } else {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Invalid direction specified for spy");
        return;
    }
 
    if (ast_strlen_zero(args_whisper) || !strcmp(args_whisper, "none")) {
        whisper = STASIS_SNOOP_DIRECTION_NONE;
    } else if (!strcmp(args_whisper, "both")) {
        whisper = STASIS_SNOOP_DIRECTION_BOTH;
    } else if (!strcmp(args_whisper, "out")) {
        whisper = STASIS_SNOOP_DIRECTION_OUT;
    } else if (!strcmp(args_whisper, "in")) {
        whisper = STASIS_SNOOP_DIRECTION_IN;
    } else {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Invalid direction specified for whisper");
        return;
    }
 
    if (spy == STASIS_SNOOP_DIRECTION_NONE && whisper == STASIS_SNOOP_DIRECTION_NONE) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Direction must be specified for at least spy or whisper");
        return;
    } else if (ast_strlen_zero(args_app)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Application name is required");
        return;
    }
 
    chan = ast_channel_get_by_name(args_channel_id);
    if (chan == NULL) {
        ast_ari_response_error(
            response, 404, "Channel Not Found",
            "Provided channel was not found");
        return;
    }
 
    snoop = stasis_app_control_snoop(chan, spy, whisper, args_app, args_app_args,
        args_snoop_id);
    if (snoop == NULL) {
        ast_ari_response_error(
            response, 500, "Internal error",
            "Snoop channel could not be created");
        return;
    }
 
    snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(snoop));
    ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot, NULL));
}

References ao2_cleanup, ast_ari_response_error(), ast_ari_response_ok(), ast_assert, ast_channel_cleanup, ast_channel_get_by_name(), ast_channel_snapshot_get_latest(), ast_channel_snapshot_to_json(), ast_channel_uniqueid(), ast_strlen_zero(), NULL, RAII_VAR, stasis_app_control_snoop(), STASIS_SNOOP_DIRECTION_BOTH, STASIS_SNOOP_DIRECTION_IN, STASIS_SNOOP_DIRECTION_NONE, and STASIS_SNOOP_DIRECTION_OUT.

Referenced by ast_ari_channels_snoop_channel(), and ast_ari_channels_snoop_channel_with_id().

ari_originate_dial()

static void * ari_originate_dial ( void *  data )

static

Thread which dials and executes upon answer.

Definition at line 1065 of file resource_channels.c.

{
    struct ast_dial *dial = data;
    struct ari_origination *origination = ast_dial_get_user_data(dial);
    enum ast_dial_result res;
 
    res = ast_dial_run(dial, NULL, 0);
    if (res != AST_DIAL_RESULT_ANSWERED) {
        goto end;
    }
 
    if (!ast_strlen_zero(origination->appdata)) {
        struct ast_app *app = pbx_findapp("Stasis");
 
        if (app) {
            ast_verb(4, "Launching Stasis(%s) on %s\n", origination->appdata,
                ast_channel_name(ast_dial_answered(dial)));
            pbx_exec(ast_dial_answered(dial), app, origination->appdata);
        } else {
            ast_log(LOG_WARNING, "No such application 'Stasis'\n");
        }
    } else {
        struct ast_channel *answered = ast_dial_answered(dial);
 
        if (!ast_strlen_zero(origination->context)) {
            ast_channel_context_set(answered, origination->context);
        }
 
        if (!ast_strlen_zero(origination->exten)) {
            ast_channel_exten_set(answered, origination->exten);
        }
 
        if (origination->priority > 0) {
            ast_channel_priority_set(answered, origination->priority);
        }
 
        if (ast_pbx_run(answered)) {
            ast_log(LOG_ERROR, "Failed to start PBX on %s\n", ast_channel_name(answered));
        } else {
            /* PBX will have taken care of hanging up, so we steal the answered channel so dial doesn't do it */
            ast_dial_answered_steal(dial);
        }
    }
 
end:
    ast_dial_destroy(dial);
    ast_free(origination);
    return NULL;
}

References app, ari_origination::appdata, ast_channel_context_set(), ast_channel_exten_set(), ast_channel_name(), ast_channel_priority_set(), ast_dial_answered(), ast_dial_answered_steal(), ast_dial_destroy(), ast_dial_get_user_data(), AST_DIAL_RESULT_ANSWERED, ast_dial_run(), ast_free, ast_log, ast_pbx_run(), ast_strlen_zero(), ast_verb, ari_origination::context, end, ari_origination::exten, LOG_ERROR, LOG_WARNING, NULL, pbx_exec(), pbx_findapp(), and ari_origination::priority.

Referenced by ari_channels_handle_originate_with_id().

ast_ari_channels_answer()

void ast_ari_channels_answer	(	struct ast_variable *	headers,
		struct ast_ari_channels_answer_args *	args,
		struct ast_ari_response *	response
	)

Answer a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 339 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    if (stasis_app_control_answer(control) != 0) {
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Failed to answer channel");
        return;
    }
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_answer().

Referenced by ast_ari_channels_answer_cb().

ast_ari_channels_continue_in_dialplan()

void ast_ari_channels_continue_in_dialplan	(	struct ast_variable *	headers,
		struct ast_ari_channels_continue_in_dialplan_args *	args,
		struct ast_ari_response *	response
	)

Exit application; continue execution in the dialplan.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 181 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
    int ipri;
    const char *context;
    const char *exten;
 
    ast_assert(response != NULL);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    snapshot = stasis_app_control_get_snapshot(control);
    if (!snapshot) {
        ast_ari_response_error(response, 404, "Not Found", "Channel not found");
        return;
    }
 
    if (ast_strlen_zero(args->context)) {
        context = snapshot->dialplan->context;
        exten = S_OR(args->extension, snapshot->dialplan->exten);
    } else {
        context = args->context;
        exten = S_OR(args->extension, "s");
    }
 
    if (!ast_strlen_zero(args->label)) {
        /* A label was provided in the request, use that */
 
        if (sscanf(args->label, "%30d", &ipri) != 1) {
            ipri = ast_findlabel_extension(NULL, context, exten, args->label, NULL);
            if (ipri == -1) {
                ast_log(AST_LOG_ERROR, "Requested label: %s can not be found in context: %s\n", args->label, context);
                ast_ari_response_error(response, 404, "Not Found", "Requested label can not be found");
                return;
            }
        } else {
            ast_debug(3, "Numeric value provided for label, jumping to that priority\n");
        }
 
        if (ipri == 0) {
            ast_log(AST_LOG_ERROR, "Invalid priority label '%s' specified for extension %s in context: %s\n",
                    args->label, exten, context);
            ast_ari_response_error(response, 400, "Bad Request", "Requested priority is illegal");
            return;
        }
 
    } else if (args->priority) {
        /* No label provided, use provided priority */
        ipri = args->priority;
    } else if (ast_strlen_zero(args->context) && ast_strlen_zero(args->extension)) {
        /* Special case. No exten, context, or priority provided, then move on to the next priority */
        ipri = snapshot->dialplan->priority + 1;
    } else {
        ipri = 1;
    }
 
 
    if (stasis_app_control_continue(control, context, exten, ipri)) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_alloc_failed(), ast_ari_response_error(), ast_ari_response_no_content(), ast_assert, ast_debug, ast_findlabel_extension(), ast_log, AST_LOG_ERROR, ast_strlen_zero(), channel_state_invalid(), find_control(), NULL, RAII_VAR, S_OR, stasis_app_control_continue(), and stasis_app_control_get_snapshot().

Referenced by ast_ari_channels_continue_in_dialplan_cb().

ast_ari_channels_create()

void ast_ari_channels_create	(	struct ast_variable *	headers,
		struct ast_ari_channels_create_args *	args,
		struct ast_ari_response *	response
	)

Create channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 2089 of file resource_channels.c.

{
    RAII_VAR(struct ast_variable *, variables, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_variable *, report_event_variables, NULL, ast_variables_destroy);
    struct ast_assigned_ids assignedids;
    struct ari_channel_thread_data *chan_data;
    struct ast_channel_snapshot *snapshot;
    pthread_t thread;
    char *dialtech;
    char *dialdevice = NULL;
    char *stuff;
    int cause;
    struct ast_format_cap *request_cap;
    struct ast_channel *originator = NULL;
 
    /* Parse any query parameters out of the body parameter */
    if (args->variables) {
        struct ast_json *json_variables;
 
        ast_ari_channels_create_parse_body(args->variables, args);
        json_variables = ast_json_object_get(args->variables, "variables");
        if (json_variables &&
            json_to_ast_variables(response, json_variables, &variables, &report_event_variables)) {
            ast_log(LOG_ERROR, "Failed to parse variables from request body for channel creation\n");
            return;
        }
    }
 
    assignedids.uniqueid = args->channel_id;
    assignedids.uniqueid2 = args->other_channel_id;
 
    if (!ast_strlen_zero(args->originator) && !ast_strlen_zero(args->formats)) {
        ast_ari_response_error(response, 400, "Bad Request",
            "Originator and formats can't both be specified");
        return;
    }
 
    if (ast_strlen_zero(args->endpoint)) {
        ast_ari_response_error(response, 400, "Bad Request",
            "Endpoint must be specified");
        return;
    }
 
    chan_data = ast_calloc(1, sizeof(*chan_data));
    if (!chan_data) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    chan_data->stasis_stuff = ast_str_create(32);
    if (!chan_data->stasis_stuff) {
        ast_ari_response_alloc_failed(response);
        chan_data_destroy(chan_data);
        return;
    }
 
    ast_str_append(&chan_data->stasis_stuff, 0, "%s", args->app);
    if (!ast_strlen_zero(args->app_args)) {
        ast_str_append(&chan_data->stasis_stuff, 0, ",%s", args->app_args);
    }
 
    dialtech = ast_strdupa(args->endpoint);
    if ((stuff = strchr(dialtech, '/'))) {
        *stuff++ = '\0';
        dialdevice = stuff;
    }
 
    if (ast_strlen_zero(dialtech) || ast_strlen_zero(dialdevice)) {
        ast_ari_response_error(response, 400, "Bad Request",
            "Invalid endpoint specified");
        chan_data_destroy(chan_data);
        return;
    }
 
    if (!ast_strlen_zero(args->originator)) {
        originator = ast_channel_get_by_name(args->originator);
    }
 
    if (originator) {
        request_cap = ao2_bump(ast_channel_nativeformats(originator));
        if (!ast_strlen_zero(args->app)) {
            stasis_app_subscribe_channel(args->app, originator);
        }
    } else if (!ast_strlen_zero(args->formats)) {
        char *format_name;
        char *formats_copy = ast_strdupa(args->formats);
 
        if (!(request_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
            ast_ari_response_alloc_failed(response);
            chan_data_destroy(chan_data);
            return;
        }
 
        while ((format_name = ast_strip(strsep(&formats_copy, ",")))) {
            struct ast_format *fmt = ast_format_cache_get(format_name);
 
            if (!fmt || ast_format_cap_append(request_cap, fmt, 0)) {
                if (!fmt) {
                    ast_ari_response_error(
                        response, 400, "Bad Request",
                        "Provided format (%s) was not found", format_name);
                } else {
                    ast_ari_response_alloc_failed(response);
                }
                ao2_ref(request_cap, -1);
                ao2_cleanup(fmt);
                chan_data_destroy(chan_data);
                return;
            }
            ao2_ref(fmt, -1);
        }
    } else {
        if (!(request_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
            ast_ari_response_alloc_failed(response);
            chan_data_destroy(chan_data);
            return;
        }
 
        ast_format_cap_append_by_type(request_cap, AST_MEDIA_TYPE_AUDIO);
    }
 
    chan_data->chan = ast_request(dialtech, request_cap, &assignedids, originator, dialdevice, &cause);
    ao2_cleanup(request_cap);
 
    if (!chan_data->chan) {
        if (ast_channel_errno() == AST_CHANNEL_ERROR_ID_EXISTS) {
            ast_ari_response_error(response, 409, "Conflict",
                "Channel with given unique ID already exists");
        } else {
            ast_ari_response_alloc_failed(response);
        }
        ast_channel_cleanup(originator);
        chan_data_destroy(chan_data);
        return;
    }
 
    if (!ast_strlen_zero(args->app)) {
        stasis_app_subscribe_channel(args->app, chan_data->chan);
    }
 
    if (variables) {
        ast_set_variables(chan_data->chan, variables);
    }
    if (report_event_variables) {
        struct ast_variable *var;
 
        for (var = report_event_variables; var; var = var->next) {
            if (ast_channel_set_ari_var_reportable(chan_data->chan, var->name, 1)) {
                ast_ari_response_alloc_failed(response);
                ast_channel_cleanup(originator);
                chan_data_destroy(chan_data);
                return;
            }
        }
    }
 
    ast_channel_cleanup(originator);
 
    if (save_dialstring(chan_data->chan, stuff)) {
        ast_ari_response_alloc_failed(response);
        chan_data_destroy(chan_data);
        return;
    }
 
    snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan_data->chan));
 
    if (ast_pthread_create_detached(&thread, NULL, ari_channel_thread, chan_data)) {
        ast_ari_response_alloc_failed(response);
        chan_data_destroy(chan_data);
    } else {
        ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot, NULL));
    }
 
    ao2_ref(snapshot, -1);
}

References ao2_bump, ao2_cleanup, ao2_ref, args, ari_channel_thread(), ast_ari_channels_create_parse_body(), ast_ari_response_alloc_failed(), ast_ari_response_error(), ast_ari_response_ok(), ast_calloc, ast_channel_cleanup, ast_channel_errno(), AST_CHANNEL_ERROR_ID_EXISTS, ast_channel_get_by_name(), ast_channel_nativeformats(), ast_channel_set_ari_var_reportable(), ast_channel_snapshot_get_latest(), ast_channel_snapshot_to_json(), ast_channel_uniqueid(), ast_format_cache_get, ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_append_by_type(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_json_object_get(), ast_log, AST_MEDIA_TYPE_AUDIO, ast_pthread_create_detached, ast_request(), ast_set_variables(), ast_str_append(), ast_str_create, ast_strdupa, ast_strip(), ast_strlen_zero(), ast_variables_destroy(), ari_channel_thread_data::chan, chan_data_destroy(), json_to_ast_variables(), LOG_ERROR, NULL, RAII_VAR, save_dialstring(), stasis_app_subscribe_channel(), ari_channel_thread_data::stasis_stuff, strsep(), ast_variable::stuff, thread, ast_assigned_ids::uniqueid, ast_assigned_ids::uniqueid2, and var.

Referenced by ast_ari_channels_create_cb().

ast_ari_channels_dial()

void ast_ari_channels_dial	(	struct ast_variable *	headers,
		struct ast_ari_channels_dial_args *	args,
		struct ast_ari_response *	response
	)

Dial a created channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 2267 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel *, caller, NULL, ast_channel_cleanup);
    RAII_VAR(struct ast_channel *, callee, NULL, ast_channel_cleanup);
    char *dialstring;
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (!ast_strlen_zero(args->caller)) {
        caller = ast_channel_get_by_name(args->caller);
    }
 
    callee = ast_channel_get_by_name(args->channel_id);
    if (!callee) {
        ast_ari_response_error(response, 404, "Not Found",
            "Callee not found");
        return;
    }
 
    if (ast_channel_state(callee) != AST_STATE_DOWN
        && ast_channel_state(callee) != AST_STATE_RESERVED) {
        ast_ari_response_error(response, 409, "Conflict",
            "Channel is not in the 'Down' state");
        return;
    }
 
    /* XXX This is straight up copied from main/dial.c. It's probably good
     * to separate this to some common method.
     */
    if (caller) {
        ast_channel_lock_both(caller, callee);
    } else {
        ast_channel_lock(callee);
    }
 
    dialstring = restore_dialstring(callee);
    if (!dialstring) {
        ast_channel_unlock(callee);
        if (caller) {
            ast_channel_unlock(caller);
        }
        ast_ari_response_error(response, 409, "Conflict",
            "Dialing a channel not created by ARI");
        return;
    }
    /* Make a copy of the dialstring just in case some jerk tries to hang up the
     * channel before we can actually dial
     */
    dialstring = ast_strdupa(dialstring);
 
    ast_channel_stage_snapshot(callee);
    if (caller) {
        ast_channel_inherit_variables(caller, callee);
        ast_channel_datastore_inherit(caller, callee);
        ast_max_forwards_decrement(callee);
 
        /* Copy over callerid information */
        ast_party_redirecting_copy(ast_channel_redirecting(callee), ast_channel_redirecting(caller));
 
        ast_channel_dialed(callee)->transit_network_select = ast_channel_dialed(caller)->transit_network_select;
 
        ast_connected_line_copy_from_caller(ast_channel_connected(callee), ast_channel_caller(caller));
 
        ast_channel_language_set(callee, ast_channel_language(caller));
        ast_channel_req_accountcodes(callee, caller, AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
        if (ast_strlen_zero(ast_channel_musicclass(callee)))
            ast_channel_musicclass_set(callee, ast_channel_musicclass(caller));
 
        ast_channel_adsicpe_set(callee, ast_channel_adsicpe(caller));
        ast_channel_transfercapability_set(callee, ast_channel_transfercapability(caller));
        ast_channel_unlock(caller);
    }
 
    ast_channel_stage_snapshot_done(callee);
    ast_channel_unlock(callee);
 
    if (stasis_app_control_dial(control, dialstring, args->timeout)) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_alloc_failed(), ast_ari_response_error(), ast_ari_response_no_content(), ast_channel_adsicpe_set(), ast_channel_caller(), ast_channel_cleanup, ast_channel_connected(), ast_channel_datastore_inherit(), ast_channel_dialed(), ast_channel_get_by_name(), ast_channel_inherit_variables(), ast_channel_language(), ast_channel_lock, ast_channel_lock_both, ast_channel_musicclass(), ast_channel_redirecting(), ast_channel_req_accountcodes(), AST_CHANNEL_REQUESTOR_BRIDGE_PEER, ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_transfercapability(), ast_channel_transfercapability_set(), ast_channel_unlock, ast_connected_line_copy_from_caller(), ast_max_forwards_decrement(), ast_party_redirecting_copy(), AST_STATE_DOWN, AST_STATE_RESERVED, ast_strdupa, ast_strlen_zero(), find_control(), NULL, RAII_VAR, restore_dialstring(), stasis_app_control_dial(), and ast_party_dialed::transit_network_select.

Referenced by ast_ari_channels_dial_cb().

ast_ari_channels_external_media()

void ast_ari_channels_external_media	(	struct ast_variable *	headers,
		struct ast_ari_channels_external_media_args *	args,
		struct ast_ari_response *	response
	)

Start an External Media session.

Create a channel to an External Media source/sink. The combination of transport and encapsulation will select one of chan_rtp(udp/rtp), chan_audiosocket(tcp/audiosocket) or chan_websocket(websocket/none) channel drivers.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 2574 of file resource_channels.c.

{
    RAII_VAR(struct ast_variable *, variables, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_variable *, report_event_variables, NULL, ast_variables_destroy);
    char *external_host;
    char *host = NULL;
    char *port = NULL;
 
    ast_assert(response != NULL);
 
    /* Parse any query parameters out of the body parameter */
    if (args->variables) {
        struct ast_json *json_variables;
 
        ast_ari_channels_external_media_parse_body(args->variables, args);
        json_variables = ast_json_object_get(args->variables, "variables");
        if (json_variables
            && json_to_ast_variables(response, json_variables, &variables,
                &report_event_variables)) {
            return;
        }
    }
 
    if (ast_strlen_zero(args->app)) {
        ast_ari_response_error(response, 400, "Bad Request", "app cannot be empty");
        return;
    }
 
    if (ast_strlen_zero(args->transport)) {
        args->transport = "udp";
    }
 
    if (ast_strlen_zero(args->encapsulation)) {
        args->encapsulation = "rtp";
    }
    if (ast_strings_equal(args->transport, "websocket")) {
        if (!ast_strings_equal(args->encapsulation, "none")) {
            ast_ari_response_error(response, 400, "Bad Request", "encapsulation must be 'none' for websocket transport");
            return;
        }
    }
 
    if (ast_strings_equal(args->encapsulation, "rtp")) {
        if (!ast_strings_equal(args->transport, "udp")) {
            ast_ari_response_error(response, 400, "Bad Request", "transport must be 'udp' for rtp encapsulation");
            return;
        }
    }
 
    if (ast_strings_equal(args->encapsulation, "audiosocket")) {
        if (!ast_strings_equal(args->transport, "tcp")) {
            ast_ari_response_error(response, 400, "Bad Request", "transport must be 'tcp' for audiosocket encapsulation");
            return;
        }
    }
 
    if (ast_strlen_zero(args->connection_type)) {
        args->connection_type = "client";
    }
    if (!ast_strings_equal(args->transport, "websocket")) {
        if (ast_strings_equal(args->connection_type, "server")) {
            ast_ari_response_error(response, 400, "Bad Request", "'server' connection_type can only be used with the websocket transport");
            return;
        }
    }
 
    if (ast_strlen_zero(args->external_host)) {
        if (ast_strings_equal(args->connection_type, "client")) {
            ast_ari_response_error(response, 400, "Bad Request", "external_host is required for all but websocket server connections");
            return;
        } else {
            /* server is only valid for websocket, enforced above */
            args->external_host = "INCOMING";
        }
    }
 
    if (ast_strings_equal(args->transport, "websocket")) {
        if (ast_strings_equal(args->connection_type, "client")) {
            struct ast_websocket_client *ws_client =
                ast_websocket_client_retrieve_by_id(args->external_host);
            ao2_cleanup(ws_client);
            if (!ws_client) {
                ast_ari_response_error(response, 400, "Bad Request", "external_host must be a valid websocket_client connection id.");
                return;
            }
        }
    } else {
        external_host = ast_strdupa(args->external_host);
        if (!ast_sockaddr_split_hostport(external_host, &host, &port, PARSE_PORT_REQUIRE)) {
            ast_ari_response_error(response, 400, "Bad Request", "external_host must be <host>:<port> for all transports other than websocket");
            return;
        }
    }
 
    if (ast_strlen_zero(args->format)) {
        ast_ari_response_error(response, 400, "Bad Request", "format cannot be empty");
        return;
    }
 
    if (!ast_strlen_zero(args->direction)) {
        if (strcmp(args->direction, "both") && strcmp(args->direction, "in")
            && strcmp(args->direction, "out")) {
            ast_ari_response_error(
                response, 400, "Bad Request",
                "Invalid direction specified");
            return;
        }
    }
 
    if (strcasecmp(args->encapsulation, "rtp") == 0 && strcasecmp(args->transport, "udp") == 0) {
        if (external_media_rtp_udp(args, variables, report_event_variables, response)) {
            ast_ari_response_error(
                response, 500, "Internal Server Error",
                "An internal error prevented this request from being handled");
        }
    } else if (strcasecmp(args->encapsulation, "audiosocket") == 0 && strcasecmp(args->transport, "tcp") == 0) {
        if (ast_strlen_zero(args->data)) {
            ast_ari_response_error(response, 400, "Bad Request", "data can not be empty");
        } else if (external_media_audiosocket_tcp(args, variables, report_event_variables, response)) {
            ast_ari_response_error(
                response, 500, "Internal Server Error",
                "An internal error prevented this request from being handled");
        }
    } else if (strcasecmp(args->encapsulation, "none") == 0 && strcasecmp(args->transport, "websocket") == 0) {
        if (external_media_websocket(args, variables, report_event_variables, response)) {
            ast_ari_response_error(
                response, 500, "Internal Server Error",
                "An internal error prevented this request from being handled");
        }
    } else {
        ast_ari_response_error(
            response, 501, "Not Implemented",
            "The encapsulation and/or transport is not supported");
    }
}

References ao2_cleanup, args, ast_ari_channels_external_media_parse_body(), ast_ari_response_error(), ast_assert, ast_json_object_get(), ast_sockaddr_split_hostport(), ast_strdupa, ast_strings_equal(), ast_strlen_zero(), ast_variables_destroy(), ast_websocket_client_retrieve_by_id(), external_media_audiosocket_tcp(), external_media_rtp_udp(), external_media_websocket(), json_to_ast_variables(), NULL, PARSE_PORT_REQUIRE, and RAII_VAR.

Referenced by ast_ari_channels_external_media_cb().

ast_ari_channels_get()

void ast_ari_channels_get	(	struct ast_variable *	headers,
		struct ast_ari_channels_get_args *	args,
		struct ast_ari_response *	response
	)

Channel details.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 909 of file resource_channels.c.

{
    struct ast_channel_snapshot *snapshot;
 
    snapshot = ast_channel_snapshot_get_latest(args->channel_id);
    if (!snapshot) {
        ast_ari_response_error(
            response, 404, "Not Found",
            "Channel not found");
        return;
    }
 
    ast_ari_response_ok(response,
                ast_channel_snapshot_to_json(snapshot, NULL));
    ao2_ref(snapshot, -1);
}

References ao2_ref, args, ast_ari_response_error(), ast_ari_response_ok(), ast_channel_snapshot_get_latest(), ast_channel_snapshot_to_json(), and NULL.

Referenced by ast_ari_channels_get_cb().

ast_ari_channels_get_channel_var()

void ast_ari_channels_get_channel_var	(	struct ast_variable *	headers,
		struct ast_ari_channels_get_channel_var_args *	args,
		struct ast_ari_response *	response
	)

Get the value of a channel variable or function.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1613 of file resource_channels.c.

{
    RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    RAII_VAR(struct ast_str *, value, ast_str_create(32), ast_free);
    RAII_VAR(struct ast_channel *, channel, NULL, ast_channel_cleanup);
 
    ast_assert(response != NULL);
 
    if (!value) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    if (ast_strlen_zero(args->variable)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Variable name is required");
        return;
    }
 
    if (ast_strlen_zero(args->channel_id)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Channel ID is required");
        return;
    }
 
    channel = ast_channel_get_by_name(args->channel_id);
    if (!channel) {
        ast_ari_response_error(
            response, 404, "Channel Not Found",
            "Provided channel was not found");
        return;
    }
 
    /* You may be tempted to lock the channel you're about to read from. You
     * would be wrong. Some dialplan functions put the channel into
     * autoservice, which deadlocks if the channel is already locked.
     * ast_str_retrieve_variable() does its own locking, and the dialplan
     * functions need to as well. We should be fine without the lock.
     */
 
    if (args->variable[strlen(args->variable) - 1] == ')') {
        if (ast_func_read2(channel, args->variable, &value, 0)) {
            ast_ari_response_error(
                response, 500, "Error With Function",
                "Unable to read provided function");
            return;
        }
    } else {
        if (!ast_str_retrieve_variable(&value, 0, channel, NULL, args->variable)) {
            ast_ari_response_error(
                response, 404, "Variable Not Found",
                "Provided variable was not found");
            return;
        }
    }
 
    if (!(json = ast_json_pack("{s: s}", "value", S_OR(ast_str_buffer(value), "")))) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    ast_ari_response_ok(response, ast_json_ref(json));
}

References ao2_cleanup, args, ast_ari_response_alloc_failed(), ast_ari_response_error(), ast_ari_response_ok(), ast_assert, ast_channel_cleanup, ast_channel_get_by_name(), ast_free, ast_func_read2(), ast_json_pack(), ast_json_ref(), ast_json_unref(), ast_str_buffer(), ast_str_create, ast_str_retrieve_variable(), ast_strlen_zero(), NULL, RAII_VAR, S_OR, and value.

Referenced by ast_ari_channels_get_channel_var_cb().

ast_ari_channels_get_channel_vars()

void ast_ari_channels_get_channel_vars	(	struct ast_variable *	headers,
		struct ast_ari_channels_get_channel_vars_args *	args,
		struct ast_ari_response *	response
	)

Get the value of multiple channel variables or functions.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1682 of file resource_channels.c.

{
    int res;
    RAII_VAR(struct ast_json *, json, ast_json_object_create(), ast_json_unref);
    RAII_VAR(struct ast_json *, inner_json, ast_json_object_create(), ast_json_unref);
    RAII_VAR(struct ast_str *, value, ast_str_create(32), ast_free);
    RAII_VAR(struct ast_channel *, channel, NULL, ast_channel_cleanup);
 
    ast_assert(response != NULL);
 
    if (!json || !inner_json || !value) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    if (args->variables_count == 0) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "At least one variable name is required");
        return;
    }
 
    if (ast_strlen_zero(args->channel_id)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Channel ID is required");
        return;
    }
 
    channel = ast_channel_get_by_name(args->channel_id);
    if (!channel) {
        ast_ari_response_error(
            response, 404, "Channel Not Found",
            "Provided channel was not found");
        return;
    }
 
    for (int i = 0; i < args->variables_count; i++) {
        struct ast_json *json_str;
        char buf[strlen(args->variables[i]) + 1];
        char *variable;
 
        strcpy(buf, args->variables[i]);
        variable = ast_strip(buf);
        if (ast_strlen_zero(variable)) {
            ast_ari_response_error(
                response, 400, "Bad Request",
                "Variable names are required");
            return;
        }
 
        if (variable[strlen(variable) - 1] == ')') {
            if (ast_func_read2(channel, variable, &value, 0)) {
                ast_ari_response_error(
                    response, 500, "Error With Function",
                    "Unable to read provided function");
                return;
            }
        } else {
            if (!ast_str_retrieve_variable(&value, 0, channel, NULL, variable)) {
                ast_ari_response_error(
                    response, 404, "Variable Not Found",
                    "Provided variable was not found");
                return;
            }
        }
 
        json_str = ast_json_string_create(ast_str_buffer(value));
        if (!json_str) {
            ast_ari_response_alloc_failed(response);
            return;
        }
 
        res = ast_json_object_set(inner_json, variable, json_str);
        if (res) {
            ast_ari_response_alloc_failed(response);
            ast_json_unref(json_str);
            return;
        }
    }
 
    res = ast_json_object_set(json, "variables", ast_json_ref(inner_json));
    if (res) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    ast_ari_response_ok(response, ast_json_ref(json));
}

References args, ast_ari_response_alloc_failed(), ast_ari_response_error(), ast_ari_response_ok(), ast_assert, ast_channel_cleanup, ast_channel_get_by_name(), ast_free, ast_func_read2(), ast_json_object_create(), ast_json_object_set(), ast_json_ref(), ast_json_string_create(), ast_json_unref(), ast_str_buffer(), ast_str_create, ast_str_retrieve_variable(), ast_strip(), ast_strlen_zero(), buf, NULL, RAII_VAR, and value.

Referenced by ast_ari_channels_get_channel_vars_cb().

ast_ari_channels_hangup()

void ast_ari_channels_hangup	(	struct ast_variable *	headers,
		struct ast_ari_channels_hangup_args *	args,
		struct ast_ari_response *	response
	)

Delete (i.e. hangup) a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 928 of file resource_channels.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
    int cause;
    struct ast_rtp_glue *glue;
    struct ast_rtp_instance *rtp = NULL;
    const struct ast_channel_tech *tech;
 
    chan = ast_channel_get_by_name(args->channel_id);
    if (chan == NULL) {
        ast_ari_response_error(
            response, 404, "Not Found",
            "Channel not found");
        return;
    }
 
    if (!ast_strlen_zero(args->reason) && !ast_strlen_zero(args->reason_code)) {
        ast_ari_response_error(response, 400, "Bad Request",
            "The reason and reason_code can't both be specified");
        return;
    }
 
    if (!ast_strlen_zero(args->reason_code)) {
        /* reason_code allows any hangup code */
        if (sscanf(args->reason_code, "%30d", &cause) != 1) {
            ast_ari_response_error(
                response, 400, "Invalid Reason Code",
                "Invalid reason for hangup reason code provided");
            return;
        }
    } else if (!ast_strlen_zero(args->reason)) {
        /* reason allows only listed hangup reason */
        cause = convert_reason_to_hangup_code(args->reason);
        if (cause == -1) {
            ast_ari_response_error(
                response, 400, "Invalid Reason",
                "Invalid reason for hangup reason provided");
            return;
        }
    } else {
        /* not specified. set default hangup */
        cause = AST_CAUSE_NORMAL;
    }
 
    ast_channel_hangupcause_set(chan, cause);
 
    /*
     * Only hold the channel lock long enough to get the rtp instance.
     * glue->get_rtp_info() will bump the refcount on it.
     */
    ast_channel_lock(chan);
    tech = ast_channel_tech(chan);
    glue = ast_rtp_instance_get_glue(tech->type);
    if (glue) {
        glue->get_rtp_info(chan, &rtp);
    }
    ast_channel_unlock(chan);
    /*
     * If this channel is in a bridge, ast_rtp_instance_set_stats_vars() will
     * attempt to lock the bridge peer as well as this channel.  This can cause
     * a lock inversion if we already have this channel locked and another
     * thread tries to set bridge variables on the peer because it will have
     * locked the peer first, then this channel.  For this reason, we must
     * NOT have the channel locked when we call ast_rtp_instance_set_stats_vars().
     * This should be safe since glue->get_rtp_info() will have bumped the
     * refcount on the rtp instance so it can't go away while the channel
     * is unlocked.
     */
    if (rtp) {
        ast_rtp_instance_set_stats_vars(chan, rtp);
        ao2_ref(rtp, -1);
    }
 
    ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, ao2_ref, args, ast_ari_response_error(), ast_ari_response_no_content(), AST_CAUSE_NORMAL, ast_channel_get_by_name(), ast_channel_hangupcause_set(), ast_channel_lock, ast_channel_unlock, ast_rtp_instance_get_glue(), ast_rtp_instance_set_stats_vars(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_strlen_zero(), convert_reason_to_hangup_code(), ast_rtp_glue::get_rtp_info, NULL, RAII_VAR, and ast_channel_tech::type.

Referenced by ast_ari_channels_hangup_cb().

ast_ari_channels_hold()

void ast_ari_channels_hold	(	struct ast_variable *	headers,
		struct ast_ari_channels_hold_args *	args,
		struct ast_ari_response *	response
	)

Hold a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 535 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_hold(control);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_hold().

Referenced by ast_ari_channels_hold_cb().

ast_ari_channels_list()

void ast_ari_channels_list	(	struct ast_variable *	headers,
		struct ast_ari_channels_list_args *	args,
		struct ast_ari_response *	response
	)

List all active channels in Asterisk.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1008 of file resource_channels.c.

{
    RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
    RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
    struct ao2_iterator i;
    void *obj;
    struct stasis_message_sanitizer *sanitize = stasis_app_get_sanitizer();
 
    snapshots = ast_channel_cache_all();
 
    json = ast_json_array_create();
    if (!json) {
        ast_ari_response_alloc_failed(response);
        return;
    }
 
    i = ao2_iterator_init(snapshots, 0);
    while ((obj = ao2_iterator_next(&i))) {
        struct ast_channel_snapshot *snapshot = obj;
        int r;
 
        if (sanitize && sanitize->channel_snapshot
            && sanitize->channel_snapshot(snapshot)) {
            ao2_ref(snapshot, -1);
            continue;
        }
 
        r = ast_json_array_append(
            json, ast_channel_snapshot_to_json(snapshot, NULL));
        if (r != 0) {
            ast_ari_response_alloc_failed(response);
            ao2_iterator_destroy(&i);
            ao2_ref(snapshot, -1);
            return;
        }
        ao2_ref(snapshot, -1);
    }
    ao2_iterator_destroy(&i);
 
    ast_ari_response_ok(response, ast_json_ref(json));
}

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_ari_response_alloc_failed(), ast_ari_response_ok(), ast_channel_cache_all(), ast_channel_snapshot_to_json(), ast_json_array_append(), ast_json_array_create(), ast_json_ref(), ast_json_unref(), stasis_message_sanitizer::channel_snapshot, NULL, RAII_VAR, and stasis_app_get_sanitizer().

Referenced by ast_ari_channels_list_cb().

ast_ari_channels_move()

void ast_ari_channels_move	(	struct ast_variable *	headers,
		struct ast_ari_channels_move_args *	args,
		struct ast_ari_response *	response
	)

Move the channel from one Stasis application to another.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 257 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (!control) {
        return;
    }
 
    if (stasis_app_control_move(control, args->app, args->app_args)) {
        ast_ari_response_error(response, 500, "Internal Server Error",
            "Failed to switch Stasis applications");
        return;
    }
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), find_control(), NULL, RAII_VAR, and stasis_app_control_move().

Referenced by ast_ari_channels_move_cb().

ast_ari_channels_mute()

void ast_ari_channels_mute	(	struct ast_variable *	headers,
		struct ast_ari_channels_mute_args *	args,
		struct ast_ari_response *	response
	)

Mute a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 424 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    unsigned int direction = 0;
    enum ast_frame_type frametype = AST_FRAME_VOICE;
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    if (ast_strlen_zero(args->direction)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Direction is required");
        return;
    }
 
    if (!strcmp(args->direction, "in")) {
        direction = AST_MUTE_DIRECTION_READ;
    } else if (!strcmp(args->direction, "out")) {
        direction = AST_MUTE_DIRECTION_WRITE;
    } else if (!strcmp(args->direction, "both")) {
        direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
    } else {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Invalid direction specified");
        return;
    }
 
    stasis_app_control_mute(control, direction, frametype);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), AST_FRAME_VOICE, AST_MUTE_DIRECTION_READ, AST_MUTE_DIRECTION_WRITE, ast_strlen_zero(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_mute().

Referenced by ast_ari_channels_mute_cb().

ast_ari_channels_originate()

void ast_ari_channels_originate	(	struct ast_variable *	headers,
		struct ast_ari_channels_originate_args *	args,
		struct ast_ari_response *	response
	)

Create a new channel (originate).

The new channel is created immediately and a snapshot of it returned. If a Stasis application is provided it will be automatically subscribed to the originated channel for further events and updates.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1570 of file resource_channels.c.

{
    struct ast_variable *variables = NULL;
    struct ast_variable *report_event_variables = NULL;
    struct ast_channel *chan;
 
    /* Parse any query parameters out of the body parameter */
    if (args->variables) {
        struct ast_json *json_variables;
 
        ast_ari_channels_originate_parse_body(args->variables, args);
        json_variables = ast_json_object_get(args->variables, "variables");
        if (json_variables
            && json_to_ast_variables(response, json_variables, &variables,
                &report_event_variables)) {
            return;
        }
    }
 
    chan = ari_channels_handle_originate_with_id(
        args->endpoint,
        args->extension,
        args->context,
        args->priority,
        args->label,
        args->app,
        args->app_args,
        args->caller_id,
        args->timeout,
        variables,
        report_event_variables,
        args->channel_id,
        args->other_channel_id,
        args->originator,
        args->formats,
        response);
    ast_channel_cleanup(chan);
    ast_variables_destroy(report_event_variables);
    ast_variables_destroy(variables);
}

References args, ari_channels_handle_originate_with_id(), ast_ari_channels_originate_parse_body(), ast_channel_cleanup, ast_json_object_get(), ast_variables_destroy(), json_to_ast_variables(), and NULL.

Referenced by ast_ari_channels_originate_cb().

ast_ari_channels_originate_with_id()

void ast_ari_channels_originate_with_id	(	struct ast_variable *	headers,
		struct ast_ari_channels_originate_with_id_args *	args,
		struct ast_ari_response *	response
	)

Create a new channel (originate with id).

The new channel is created immediately and a snapshot of it returned. If a Stasis application is provided it will be automatically subscribed to the originated channel for further events and updates.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1527 of file resource_channels.c.

{
    struct ast_variable *variables = NULL;
    struct ast_variable *report_event_variables = NULL;
    struct ast_channel *chan;
 
    /* Parse any query parameters out of the body parameter */
    if (args->variables) {
        struct ast_json *json_variables;
 
        ast_ari_channels_originate_with_id_parse_body(args->variables, args);
        json_variables = ast_json_object_get(args->variables, "variables");
        if (json_variables
            && json_to_ast_variables(response, json_variables, &variables,
                &report_event_variables)) {
            return;
        }
    }
 
    chan = ari_channels_handle_originate_with_id(
        args->endpoint,
        args->extension,
        args->context,
        args->priority,
        args->label,
        args->app,
        args->app_args,
        args->caller_id,
        args->timeout,
        variables,
        report_event_variables,
        args->channel_id,
        args->other_channel_id,
        args->originator,
        args->formats,
        response);
    ast_channel_cleanup(chan);
    ast_variables_destroy(report_event_variables);
    ast_variables_destroy(variables);
}

References args, ari_channels_handle_originate_with_id(), ast_ari_channels_originate_with_id_parse_body(), ast_channel_cleanup, ast_json_object_get(), ast_variables_destroy(), json_to_ast_variables(), and NULL.

Referenced by ast_ari_channels_originate_with_id_cb().

ast_ari_channels_play()

void ast_ari_channels_play	(	struct ast_variable *	headers,
		struct ast_ari_channels_play_args *	args,
		struct ast_ari_response *	response
	)

Start playback of media.

The media URI may be any of a number of URI's. Currently sound:, recording:, number:, digits:, characters:, and tone: URI's are supported. This operation creates a playback resource that can be used to control the playback of media (pause, rewind, fast forward, etc.)

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 739 of file resource_channels.c.

{
    ari_channels_handle_play(
        args->channel_id,
        args->media,
        args->media_count,
        args->lang,
        args->offsetms,
        args->skipms,
        args->playback_id,
        response);
}

References args, and ari_channels_handle_play().

Referenced by ast_ari_channels_play_cb().

ast_ari_channels_play_with_id()

void ast_ari_channels_play_with_id	(	struct ast_variable *	headers,
		struct ast_ari_channels_play_with_id_args *	args,
		struct ast_ari_response *	response
	)

Start playback of media and specify the playbackId.

The media URI may be any of a number of URI's. Currently sound:, recording:, number:, digits:, characters:, and tone: URI's are supported. This operation creates a playback resource that can be used to control the playback of media (pause, rewind, fast forward, etc.)

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 754 of file resource_channels.c.

{
    ari_channels_handle_play(
        args->channel_id,
        args->media,
        args->media_count,
        args->lang,
        args->offsetms,
        args->skipms,
        args->playback_id,
        response);
}

References args, and ari_channels_handle_play().

Referenced by ast_ari_channels_play_with_id_cb().

ast_ari_channels_progress()

void ast_ari_channels_progress	(	struct ast_variable *	headers,
		struct ast_ari_channels_progress_args *	args,
		struct ast_ari_response *	response
	)

Indicate progress on a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 404 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_progress(control);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_progress().

Referenced by ast_ari_channels_progress_cb().

ast_ari_channels_record()

void ast_ari_channels_record	(	struct ast_variable *	headers,
		struct ast_ari_channels_record_args *	args,
		struct ast_ari_response *	response
	)

Start a recording.

Record audio from a channel. Note that this will not capture audio sent to the channel. The bridge itself has a record feature if that's what you want.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 769 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_app_recording *, recording, NULL, ao2_cleanup);
    RAII_VAR(char *, recording_url, NULL, ast_free);
    struct ast_json *json;
    RAII_VAR(struct stasis_app_recording_options *, options, NULL,
        ao2_cleanup);
    RAII_VAR(char *, uri_encoded_name, NULL, ast_free);
    size_t uri_name_maxlen;
 
    ast_assert(response != NULL);
 
    if (args->max_duration_seconds < 0) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "max_duration_seconds cannot be negative");
        return;
    }
 
    if (args->max_silence_seconds < 0) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "max_silence_seconds cannot be negative");
        return;
    }
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    options = stasis_app_recording_options_create(args->name, args->format);
    if (options == NULL) {
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Out of memory");
    }
    ast_string_field_build(options, target, "channel:%s", args->channel_id);
    options->max_silence_seconds = args->max_silence_seconds;
    options->max_duration_seconds = args->max_duration_seconds;
    options->terminate_on =
        stasis_app_recording_termination_parse(args->terminate_on);
    options->if_exists =
        stasis_app_recording_if_exists_parse(args->if_exists);
    options->beep = args->beep;
 
    if (options->terminate_on == STASIS_APP_RECORDING_TERMINATE_INVALID) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "terminateOn invalid");
        return;
    }
 
    if (options->if_exists == AST_RECORD_IF_EXISTS_ERROR) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "ifExists invalid");
        return;
    }
 
    if (!ast_get_format_for_file_ext(options->format)) {
        ast_ari_response_error(
            response, 422, "Unprocessable Entity",
            "specified format is unknown on this system");
        return;
    }
 
    recording = stasis_app_control_record(control, options);
    if (recording == NULL) {
        switch(errno) {
        case EINVAL:
            /* While the arguments are invalid, we should have
             * caught them prior to calling record.
             */
            ast_ari_response_error(
                response, 500, "Internal Server Error",
                "Error parsing request");
            break;
        case EEXIST:
            ast_ari_response_error(response, 409, "Conflict",
                "Recording '%s' already exists and can not be overwritten",
                args->name);
            break;
        case ENOMEM:
            ast_ari_response_error(
                response, 500, "Internal Server Error",
                "Out of memory");
            break;
        case EPERM:
            ast_ari_response_error(
                response, 400, "Bad Request",
                "Recording name invalid");
            break;
        default:
            ast_log(LOG_WARNING,
                "Unrecognized recording error: %s\n",
                strerror(errno));
            ast_ari_response_error(
                response, 500, "Internal Server Error",
                "Internal Server Error");
            break;
        }
        return;
    }
 
    uri_name_maxlen = strlen(args->name) * 3;
    uri_encoded_name = ast_malloc(uri_name_maxlen);
    if (!uri_encoded_name) {
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Out of memory");
        return;
    }
    ast_uri_encode(args->name, uri_encoded_name, uri_name_maxlen,
        ast_uri_http);
 
    if (ast_asprintf(&recording_url, "/recordings/live/%s",
            uri_encoded_name) == -1) {
        recording_url = NULL;
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Out of memory");
        return;
    }
 
    json = stasis_app_recording_to_json(recording);
    if (!json) {
        ast_ari_response_error(
            response, 500, "Internal Server Error",
            "Out of memory");
        return;
    }
 
    ast_ari_response_created(response, recording_url, json);
}

References ao2_cleanup, args, ast_ari_response_created(), ast_ari_response_error(), ast_asprintf, ast_assert, ast_free, ast_get_format_for_file_ext(), ast_log, ast_malloc, AST_RECORD_IF_EXISTS_ERROR, ast_string_field_build, ast_uri_encode(), ast_uri_http, errno, find_control(), LOG_WARNING, NULL, options, RAII_VAR, stasis_app_control_record(), stasis_app_recording_if_exists_parse(), stasis_app_recording_options_create(), STASIS_APP_RECORDING_TERMINATE_INVALID, stasis_app_recording_termination_parse(), and stasis_app_recording_to_json().

Referenced by ast_ari_channels_record_cb().

ast_ari_channels_redirect()

void ast_ari_channels_redirect	(	struct ast_variable *	headers,
		struct ast_ari_channels_redirect_args *	args,
		struct ast_ari_response *	response
	)

Redirect the channel to a different location.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 277 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, chan_snapshot, NULL, ao2_cleanup);
    char *tech;
    char *resource;
    int tech_len;
 
    control = find_control(response, args->channel_id);
    if (!control) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    if (ast_strlen_zero(args->endpoint)) {
        ast_ari_response_error(response, 400, "Not Found",
            "Required parameter 'endpoint' not provided.");
        return;
    }
 
    tech = ast_strdupa(args->endpoint);
    if (!(resource = strchr(tech, '/')) || !(tech_len = resource - tech)) {
        ast_ari_response_error(response, 422, "Unprocessable Entity",
            "Endpoint parameter '%s' does not contain tech/resource", args->endpoint);
        return;
    }
 
    *resource++ = '\0';
    if (ast_strlen_zero(resource)) {
        ast_ari_response_error(response, 422, "Unprocessable Entity",
            "No resource provided in endpoint parameter '%s'", args->endpoint);
        return;
    }
 
    chan_snapshot = ast_channel_snapshot_get_latest(args->channel_id);
    if (!chan_snapshot) {
        ast_ari_response_error(response, 500, "Internal Server Error",
            "Unable to find channel snapshot for '%s'", args->channel_id);
        return;
    }
 
    if (strncasecmp(chan_snapshot->base->type, tech, tech_len)) {
        ast_ari_response_error(response, 422, "Unprocessable Entity",
            "Endpoint technology '%s' does not match channel technology '%s'",
            tech, chan_snapshot->base->type);
        return;
    }
 
    if (stasis_app_control_redirect(control, resource)) {
        ast_ari_response_error(response, 500, "Internal Server Error",
            "Failed to redirect channel");
        return;
    }
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), ast_channel_snapshot_get_latest(), ast_strdupa, ast_strlen_zero(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_redirect().

Referenced by ast_ari_channels_redirect_cb().

ast_ari_channels_ring()

void ast_ari_channels_ring	(	struct ast_variable *	headers,
		struct ast_ari_channels_ring_args *	args,
		struct ast_ari_response *	response
	)

Indicate ringing to a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 364 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_ring(control);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_ring().

Referenced by ast_ari_channels_ring_cb().

ast_ari_channels_ring_stop()

void ast_ari_channels_ring_stop	(	struct ast_variable *	headers,
		struct ast_ari_channels_ring_stop_args *	args,
		struct ast_ari_response *	response
	)

Stop ringing indication on a channel if locally generated.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 384 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_ring_stop(control);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_ring_stop().

Referenced by ast_ari_channels_ring_stop_cb().

ast_ari_channels_rtpstatistics()

void ast_ari_channels_rtpstatistics	(	struct ast_variable *	headers,
		struct ast_ari_channels_rtpstatistics_args *	args,
		struct ast_ari_response *	response
	)

RTP stats on a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 2358 of file resource_channels.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, ast_channel_cleanup);
    RAII_VAR(struct ast_rtp_instance *, rtp, NULL, ao2_cleanup);
    struct ast_json *j_res;
    const struct ast_channel_tech *tech;
    struct ast_rtp_glue *glue;
 
    chan = ast_channel_get_by_name(args->channel_id);
    if (!chan) {
        ast_ari_response_error(response, 404, "Not Found",
            "Channel not found");
        return;
    }
 
    ast_channel_lock(chan);
    tech = ast_channel_tech(chan);
    if (!tech) {
        ast_channel_unlock(chan);
        ast_ari_response_error(response, 404, "Not Found",
            "Channel's tech not found");
        return;
    }
 
    glue = ast_rtp_instance_get_glue(tech->type);
    if (!glue) {
        ast_channel_unlock(chan);
        ast_ari_response_error(response, 403, "Forbidden",
            "Unsupported channel type");
        return;
    }
 
    glue->get_rtp_info(chan, &rtp);
    if (!rtp) {
        ast_channel_unlock(chan);
        ast_ari_response_error(response, 404, "Not Found",
            "RTP info not found");
        return;
    }
 
    j_res = ast_rtp_instance_get_stats_all_json(rtp);
    if (!j_res) {
        ast_channel_unlock(chan);
        ast_ari_response_error(response, 404, "Not Found",
            "Statistics not found");
        return;
    }
 
    ast_channel_unlock(chan);
    ast_ari_response_ok(response, j_res);
 
    return;
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_ok(), ast_channel_cleanup, ast_channel_get_by_name(), ast_channel_lock, ast_channel_unlock, ast_rtp_instance_get_glue(), ast_rtp_instance_get_stats_all_json(), ast_rtp_glue::get_rtp_info, NULL, RAII_VAR, and ast_channel_tech::type.

Referenced by ast_ari_channels_rtpstatistics_cb().

ast_ari_channels_send_dtmf()

void ast_ari_channels_send_dtmf	(	struct ast_variable *	headers,
		struct ast_ari_channels_send_dtmf_args *	args,
		struct ast_ari_response *	response
	)

Send provided DTMF to a given channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 508 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    if (ast_strlen_zero(args->dtmf)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "DTMF is required");
        return;
    }
 
    stasis_app_control_dtmf(control, args->dtmf, args->before, args->between, args->duration, args->after);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), ast_strlen_zero(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_dtmf().

Referenced by ast_ari_channels_send_dtmf_cb().

ast_ari_channels_set_channel_var()

void ast_ari_channels_set_channel_var	(	struct ast_variable *	headers,
		struct ast_ari_channels_set_channel_var_args *	args,
		struct ast_ari_response *	response
	)

Set the value of a channel variable or function.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1774 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    ast_assert(response != NULL);
 
    if (ast_strlen_zero(args->variable)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Variable name is required");
        return;
    }
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* response filled in by find_control */
        return;
    }
 
    if (stasis_app_control_set_channel_var_reportable(control, args->variable, args->value,
        args->report_events)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Failed to execute function");
        return;
    }
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), ast_assert, ast_strlen_zero(), find_control(), NULL, RAII_VAR, and stasis_app_control_set_channel_var_reportable().

Referenced by ast_ari_channels_set_channel_var_cb().

ast_ari_channels_set_channel_vars()

void ast_ari_channels_set_channel_vars	(	struct ast_variable *	headers,
		struct ast_ari_channels_set_channel_vars_args *	args,
		struct ast_ari_response *	response
	)

Set the values of multiple channel variables or functions.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1806 of file resource_channels.c.

{
    struct ast_json *json_variables;
    struct ast_variable *var;
    RAII_VAR(struct ast_variable *, variables, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_variable *, report_event_variables, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_channel *, channel, NULL, ast_channel_cleanup);
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    ast_assert(response != NULL);
 
    if (!args->variables) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "The 'variables' field is required");
        return;
    }
 
    channel = ast_channel_get_by_name(args->channel_id);
    if (!channel) {
        ast_ari_response_error(
            response, 404, "Channel Not Found",
            "Provided channel was not found");
        return;
    }
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* response filled in by find_control */
        return;
    }
 
    json_variables = ast_json_object_get(args->variables, "variables");
    if (!json_variables || ast_json_typeof(json_variables) != AST_JSON_OBJECT) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "The 'variables' field must be a JSON object");
        return;
    }
 
    if (json_to_ast_variables(response, json_variables, &variables,
        &report_event_variables)) {
        return;
    }
 
    for (var = variables; var; var = var->next) {
        int report_events = 0;
        struct ast_variable *report_var;
        char buf[strlen(var->name) + 1];
        char *variable;
        strcpy(buf, var->name);
        /* Strip whitespace from the variable name */
        variable = ast_strip(buf);
 
        /* See if the variable is in the report event list */
        for (report_var = report_event_variables; report_var;
            report_var = report_var->next) {
            if (!strcmp(report_var->name, var->name)) {
                report_events = 1;
                break;
            }
        }
 
        if (stasis_app_control_set_channel_var_reportable(control, variable,
            var->value, report_events)) {
            ast_ari_response_error(
                response, 400, "Bad Request",
                "Failed to execute function");
            return;
        }
    }
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), ast_assert, ast_channel_cleanup, ast_channel_get_by_name(), AST_JSON_OBJECT, ast_json_object_get(), ast_json_typeof(), ast_strip(), ast_variables_destroy(), buf, find_control(), json_to_ast_variables(), ast_variable::name, ast_variable::next, NULL, RAII_VAR, stasis_app_control_set_channel_var_reportable(), and var.

Referenced by ast_ari_channels_set_channel_vars_cb().

ast_ari_channels_snoop_channel()

void ast_ari_channels_snoop_channel	(	struct ast_variable *	headers,
		struct ast_ari_channels_snoop_channel_args *	args,
		struct ast_ari_response *	response
	)

Start snooping.

Snoop (spy/whisper) on a specific channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1962 of file resource_channels.c.

{
    ari_channels_handle_snoop_channel(
        args->channel_id,
        args->spy,
        args->whisper,
        args->app,
        args->app_args,
        args->snoop_id,
        response);
}

References args, and ari_channels_handle_snoop_channel().

Referenced by ast_ari_channels_snoop_channel_cb().

ast_ari_channels_snoop_channel_with_id()

void ast_ari_channels_snoop_channel_with_id	(	struct ast_variable *	headers,
		struct ast_ari_channels_snoop_channel_with_id_args *	args,
		struct ast_ari_response *	response
	)

Start snooping.

Snoop (spy/whisper) on a specific channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 1976 of file resource_channels.c.

{
    ari_channels_handle_snoop_channel(
        args->channel_id,
        args->spy,
        args->whisper,
        args->app,
        args->app_args,
        args->snoop_id,
        response);
}

References args, and ari_channels_handle_snoop_channel().

Referenced by ast_ari_channels_snoop_channel_with_id_cb().

ast_ari_channels_start_moh()

void ast_ari_channels_start_moh	(	struct ast_variable *	headers,
		struct ast_ari_channels_start_moh_args *	args,
		struct ast_ari_response *	response
	)

Play music on hold to a channel.

Using media operations such as /play on a channel playing MOH in this manner will suspend MOH without resuming automatically. If continuing music on hold is desired, the stasis application must reinitiate music on hold.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 577 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_moh_start(control, args->moh_class);
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_moh_start().

Referenced by ast_ari_channels_start_moh_cb().

ast_ari_channels_start_silence()

void ast_ari_channels_start_silence	(	struct ast_variable *	headers,
		struct ast_ari_channels_start_silence_args *	args,
		struct ast_ari_response *	response
	)

Play silence to a channel.

Using media operations such as /play on a channel playing silence in this manner will suspend silence without resuming automatically.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 617 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_silence_start(control);
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_silence_start().

Referenced by ast_ari_channels_start_silence_cb().

ast_ari_channels_stop_moh()

void ast_ari_channels_stop_moh	(	struct ast_variable *	headers,
		struct ast_ari_channels_stop_moh_args *	args,
		struct ast_ari_response *	response
	)

Stop playing music on hold to a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 597 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_moh_stop(control);
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_moh_stop().

Referenced by ast_ari_channels_stop_moh_cb().

ast_ari_channels_stop_silence()

void ast_ari_channels_stop_silence	(	struct ast_variable *	headers,
		struct ast_ari_channels_stop_silence_args *	args,
		struct ast_ari_response *	response
	)

Stop playing silence to a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 637 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_silence_stop(control);
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_silence_stop().

Referenced by ast_ari_channels_stop_silence_cb().

ast_ari_channels_transfer_progress()

void ast_ari_channels_transfer_progress	(	struct ast_variable *	headers,
		struct ast_ari_channels_transfer_progress_args *	args,
		struct ast_ari_response *	response
	)

Inform the channel about the progress of the attended/blind transfer.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 2711 of file resource_channels.c.

{
    enum ast_control_transfer message;
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel *, chan, NULL, ast_channel_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    chan = ast_channel_get_by_name(args->channel_id);
    if (!chan) {
        ast_ari_response_error(response, 404, "Not Found",
            "Callee not found");
        return;
    }
 
    if (ast_strlen_zero(args->states)) {
        ast_ari_response_error(response, 400, "Bad Request", "states must not be empty");
        return;
    }
 
    if (strcasecmp(args->states, "channel_progress") == 0) {
        message = AST_TRANSFER_PROGRESS;
    } else if (strcasecmp(args->states, "channel_answered") == 0) {
        message = AST_TRANSFER_SUCCESS;
    } else if (strcasecmp(args->states, "channel_unavailable") == 0) {
        message = AST_TRANSFER_UNAVAILABLE;
    } else if (strcasecmp(args->states, "channel_declined") == 0) {
        message = AST_TRANSFER_FAILED;
    } else {
        ast_ari_response_error(response, 400, "Bad Request", "Invalid states value");
        return;
    }
 
    ast_indicate_data(chan, AST_CONTROL_TRANSFER, &message, sizeof(message));
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), ast_channel_cleanup, ast_channel_get_by_name(), AST_CONTROL_TRANSFER, ast_indicate_data(), ast_strlen_zero(), AST_TRANSFER_FAILED, AST_TRANSFER_PROGRESS, AST_TRANSFER_SUCCESS, AST_TRANSFER_UNAVAILABLE, find_control(), NULL, and RAII_VAR.

Referenced by ast_ari_channels_transfer_progress_cb().

ast_ari_channels_unhold()

void ast_ari_channels_unhold	(	struct ast_variable *	headers,
		struct ast_ari_channels_unhold_args *	args,
		struct ast_ari_response *	response
	)

Remove a channel from hold.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 556 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        /* Response filled in by find_control */
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    stasis_app_control_unhold(control);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_no_content(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_unhold().

Referenced by ast_ari_channels_unhold_cb().

ast_ari_channels_unmute()

void ast_ari_channels_unmute	(	struct ast_variable *	headers,
		struct ast_ari_channels_unmute_args *	args,
		struct ast_ari_response *	response
	)

Unmute a channel.

Parameters

	headers	HTTP headers
	args	Swagger parameters
[out]	response	HTTP response

Definition at line 466 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
    unsigned int direction = 0;
    enum ast_frame_type frametype = AST_FRAME_VOICE;
 
    control = find_control(response, args->channel_id);
    if (control == NULL) {
        return;
    }
 
    if (channel_state_invalid(control, response)) {
        return;
    }
 
    if (ast_strlen_zero(args->direction)) {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Direction is required");
        return;
    }
 
    if (!strcmp(args->direction, "in")) {
        direction = AST_MUTE_DIRECTION_READ;
    } else if (!strcmp(args->direction, "out")) {
        direction = AST_MUTE_DIRECTION_WRITE;
    } else if (!strcmp(args->direction, "both")) {
        direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
    } else {
        ast_ari_response_error(
            response, 400, "Bad Request",
            "Invalid direction specified");
        return;
    }
 
    stasis_app_control_unmute(control, direction, frametype);
 
    ast_ari_response_no_content(response);
}

References ao2_cleanup, args, ast_ari_response_error(), ast_ari_response_no_content(), AST_FRAME_VOICE, AST_MUTE_DIRECTION_READ, AST_MUTE_DIRECTION_WRITE, ast_strlen_zero(), channel_state_invalid(), find_control(), NULL, RAII_VAR, and stasis_app_control_unmute().

Referenced by ast_ari_channels_unmute_cb().

chan_data_destroy()

static void chan_data_destroy ( struct ari_channel_thread_data *  chan_data )

static

Definition at line 1995 of file resource_channels.c.

{
    ast_free(chan_data->stasis_stuff);
    ast_hangup(chan_data->chan);
    ast_free(chan_data);
}

References ast_free, ast_hangup(), ari_channel_thread_data::chan, and ari_channel_thread_data::stasis_stuff.

Referenced by ari_channel_thread(), and ast_ari_channels_create().

channel_state_invalid()

static int channel_state_invalid ( struct stasis_app_control *  control, struct ast_ari_response *  response  )

static

Ensure channel is in a state that allows operation to be performed.

Since Asterisk 14, it has been possible for down channels, as well as unanswered outbound channels to enter Stasis. While some operations are fine to perform on such channels, operations that

• Attempt to manipulate channel state
• Attempt to play media
• Attempt to control the channel's location in the dialplan

are invalid. This function can be used to determine if the channel is in an appropriate state.

Note

When this function returns an error, the HTTP response is taken care of.

Parameters

control	The app control
response	Response to fill in if there is an error

Return values

0	Channel is in a valid state. Continue on!
non-zero	Channel is in an invalid state. Bail!

Definition at line 109 of file resource_channels.c.

{
    struct ast_channel_snapshot *snapshot;
 
    snapshot = stasis_app_control_get_snapshot(control);
    if (!snapshot) {
        ast_ari_response_error(response, 404, "Not Found", "Channel not found");
        return -1;
    }
 
    /* These channel states apply only to outbound channels:
     * - Down: Channel has been created, and nothing else has been done
     * - Reserved: For a PRI, an underlying B-channel is reserved,
     *   but the channel is not yet dialed
     * - Ringing: The channel has been dialed.
     *
     * This does not affect inbound channels. Inbound channels, when they
     * enter the dialplan, are in the "Ring" state. If they have already
     * been answered, then they are in the "Up" state.
     */
    if (snapshot->state == AST_STATE_DOWN
        || snapshot->state == AST_STATE_RESERVED
        || snapshot->state == AST_STATE_RINGING) {
        ast_ari_response_error(response, 412, "Precondition Failed",
            "Channel in invalid state");
        ao2_ref(snapshot, -1);
 
        return -1;
    }
 
    ao2_ref(snapshot, -1);
 
    return 0;
}

References ao2_ref, ast_ari_response_error(), AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_RINGING, stasis_app_control_get_snapshot(), and ast_channel_snapshot::state.

Referenced by ari_channels_handle_play(), ast_ari_channels_answer(), ast_ari_channels_continue_in_dialplan(), ast_ari_channels_hold(), ast_ari_channels_mute(), ast_ari_channels_progress(), ast_ari_channels_redirect(), ast_ari_channels_ring(), ast_ari_channels_ring_stop(), ast_ari_channels_send_dtmf(), ast_ari_channels_start_moh(), ast_ari_channels_start_silence(), ast_ari_channels_stop_moh(), ast_ari_channels_stop_silence(), ast_ari_channels_unhold(), and ast_ari_channels_unmute().

convert_reason_to_hangup_code()

static int convert_reason_to_hangup_code ( const char *  reason )

static

Return the corresponded hangup code of the given reason.

Definition at line 54 of file resource_channels.c.

{
    if (!strcmp(reason, "normal")) {
        return AST_CAUSE_NORMAL;
    } else if (!strcmp(reason, "busy")) {
        return AST_CAUSE_BUSY;
    } else if (!strcmp(reason, "congestion")) {
        return AST_CAUSE_CONGESTION;
    } else if (!strcmp(reason, "no_answer")) {
        return AST_CAUSE_NOANSWER;
    } else if (!strcmp(reason, "timeout")) {
        return AST_CAUSE_NO_USER_RESPONSE;
    } else if (!strcmp(reason, "rejected")) {
        return AST_CAUSE_CALL_REJECTED;
    } else if (!strcmp(reason, "unallocated")) {
        return AST_CAUSE_UNALLOCATED;
    } else if (!strcmp(reason, "normal_unspecified")) {
        return AST_CAUSE_NORMAL_UNSPECIFIED;
    } else if (!strcmp(reason, "number_incomplete")) {
        return AST_CAUSE_INVALID_NUMBER_FORMAT;
    } else if (!strcmp(reason, "codec_mismatch")) {
        return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
    } else if (!strcmp(reason, "interworking")) {
        return AST_CAUSE_INTERWORKING;
    } else if (!strcmp(reason, "failure")) {
        return AST_CAUSE_FAILURE;
    } else if(!strcmp(reason, "answered_elsewhere")) {
        return AST_CAUSE_ANSWERED_ELSEWHERE;
    }
 
    return -1;
}

References AST_CAUSE_ANSWERED_ELSEWHERE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_BUSY, AST_CAUSE_CALL_REJECTED, AST_CAUSE_CONGESTION, AST_CAUSE_FAILURE, AST_CAUSE_INTERWORKING, AST_CAUSE_INVALID_NUMBER_FORMAT, AST_CAUSE_NO_USER_RESPONSE, AST_CAUSE_NOANSWER, AST_CAUSE_NORMAL, AST_CAUSE_NORMAL_UNSPECIFIED, and AST_CAUSE_UNALLOCATED.

Referenced by ast_ari_channels_hangup().

external_media_audiosocket_tcp()

static int external_media_audiosocket_tcp ( struct ast_ari_channels_external_media_args *  args, struct ast_variable *  variables, struct ast_variable *  report_event_variables, struct ast_ari_response *  response  )

static

Definition at line 2463 of file resource_channels.c.

{
    char *endpoint;
    struct ast_channel *chan;
    struct varshead *vars;
 
    if (ast_asprintf(&endpoint, "AudioSocket/%s/%s",
        args->external_host, args->data) == -1) {
        return 1;
    }
 
    chan = ari_channels_handle_originate_with_id(
        endpoint,
        NULL,
        NULL,
        0,
        NULL,
        args->app,
        args->data,
        NULL,
        0,
        variables,
        report_event_variables,
        args->channel_id,
        NULL,
        NULL,
        args->format,
        response);
 
    ast_free(endpoint);
 
    if (!chan) {
        return 1;
    }
 
    ast_channel_lock(chan);
    vars = ast_channel_varshead(chan);
    if (vars && !AST_LIST_EMPTY(vars)) {
        ast_json_object_set(response->message, "channelvars", ast_json_channel_vars(vars));
    }
    ast_channel_unlock(chan);
    ast_channel_unref(chan);
    return 0;
}

References args, ari_channels_handle_originate_with_id(), ast_asprintf, ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_channel_varshead(), ast_free, ast_json_channel_vars(), ast_json_object_set(), AST_LIST_EMPTY, ast_ari_response::message, and NULL.

Referenced by ast_ari_channels_external_media().

external_media_rtp_udp()

static int external_media_rtp_udp ( struct ast_ari_channels_external_media_args *  args, struct ast_variable *  variables, struct ast_variable *  report_event_variables, struct ast_ari_response *  response  )

static

Definition at line 2414 of file resource_channels.c.

{
    char *endpoint;
    struct ast_channel *chan;
    struct varshead *vars;
 
    if (ast_asprintf(&endpoint, "UnicastRTP/%s/c(%s)",
            args->external_host,
            args->format) == -1) {
        return 1;
    }
 
    chan = ari_channels_handle_originate_with_id(
        endpoint,
        NULL,
        NULL,
        0,
        NULL,
        args->app,
        args->data,
        NULL,
        0,
        variables,
        report_event_variables,
        args->channel_id,
        NULL,
        NULL,
        args->format,
        response);
 
    ast_free(endpoint);
 
    if (!chan) {
        return 1;
    }
 
    ast_channel_lock(chan);
    vars = ast_channel_varshead(chan);
    if (vars && !AST_LIST_EMPTY(vars)) {
        ast_json_object_set(response->message, "channelvars", ast_json_channel_vars(vars));
    }
    ast_channel_unlock(chan);
    ast_channel_unref(chan);
    return 0;
}

References args, ari_channels_handle_originate_with_id(), ast_asprintf, ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_channel_varshead(), ast_free, ast_json_channel_vars(), ast_json_object_set(), AST_LIST_EMPTY, ast_ari_response::message, and NULL.

Referenced by ast_ari_channels_external_media().

external_media_websocket()

static int external_media_websocket ( struct ast_ari_channels_external_media_args *  args, struct ast_variable *  variables, struct ast_variable *  report_event_variables, struct ast_ari_response *  response  )

static

Definition at line 2511 of file resource_channels.c.

{
    char *endpoint;
    struct ast_channel *chan;
    struct varshead *vars;
    char direction[16] = "";
 
    /* If direction is set here, it WILL override any m() line in transport data
     * since it is appended to the end of the string.
     */
    if (args->direction) {
        snprintf(direction, sizeof(direction), "d(%s)", args->direction);
    }
 
    if (ast_asprintf(&endpoint, "WebSocket/%s%s%s%s%s",
            args->external_host,
            S_COR(args->transport_data, "/", ""),
            S_OR(args->transport_data, ""),
            S_COR(!args->transport_data && args->direction, "/", ""),
            direction) == -1) {
        return 1;
    }
 
    chan = ari_channels_handle_originate_with_id(
        endpoint,
        NULL,
        NULL,
        0,
        NULL,
        args->app,
        args->data,
        NULL,
        0,
        variables,
        report_event_variables,
        args->channel_id,
        NULL,
        NULL,
        args->format,
        response);
 
    ast_free(endpoint);
 
    if (!chan) {
        return 1;
    }
 
    ast_channel_lock(chan);
    vars = ast_channel_varshead(chan);
    if (vars && !AST_LIST_EMPTY(vars)) {
        ast_json_object_set(response->message, "channelvars", ast_json_channel_vars(vars));
    }
    ast_channel_unlock(chan);
    ast_channel_unref(chan);
    return 0;
}

References args, ari_channels_handle_originate_with_id(), ast_asprintf, ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_channel_varshead(), ast_free, ast_json_channel_vars(), ast_json_object_set(), AST_LIST_EMPTY, ast_ari_response::message, NULL, S_COR, and S_OR.

Referenced by ast_ari_channels_external_media().

find_control()

static struct stasis_app_control * find_control ( struct ast_ari_response *  response, const char *  channel_id  )

static

Finds the control object for a channel, filling the response with an error, if appropriate.

Parameters

[out]	response	Response to fill with an error if control is not found.
	channel_id	ID of the channel to lookup.

Returns

Channel control object.

Return values

NULL	if control object does not exist.

Definition at line 153 of file resource_channels.c.

{
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    ast_assert(response != NULL);
 
    control = stasis_app_control_find_by_channel_id(channel_id);
    if (control == NULL) {
        /* Distinguish between 404 and 409 errors */
        RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
        chan = ast_channel_get_by_name(channel_id);
        if (chan == NULL) {
            ast_ari_response_error(response, 404, "Not Found",
                   "Channel not found");
            return NULL;
        }
 
        ast_ari_response_error(response, 409, "Conflict",
               "Channel not in Stasis application");
        return NULL;
    }
 
    ao2_ref(control, +1);
    return control;
}

References ao2_cleanup, ao2_ref, ast_ari_response_error(), ast_assert, ast_channel_get_by_name(), NULL, RAII_VAR, and stasis_app_control_find_by_channel_id().

Referenced by ari_channels_handle_play(), ast_ari_channels_answer(), ast_ari_channels_continue_in_dialplan(), ast_ari_channels_dial(), ast_ari_channels_hold(), ast_ari_channels_move(), ast_ari_channels_mute(), ast_ari_channels_progress(), ast_ari_channels_record(), ast_ari_channels_redirect(), ast_ari_channels_ring(), ast_ari_channels_ring_stop(), ast_ari_channels_send_dtmf(), ast_ari_channels_set_channel_var(), ast_ari_channels_set_channel_vars(), ast_ari_channels_start_moh(), ast_ari_channels_start_silence(), ast_ari_channels_stop_moh(), ast_ari_channels_stop_silence(), ast_ari_channels_transfer_progress(), ast_ari_channels_unhold(), and ast_ari_channels_unmute().

json_to_ast_variables()

static int json_to_ast_variables ( struct ast_ari_response *  response, struct ast_json *  json_variables, struct ast_variable **  variables, struct ast_variable **  report_event_variables  )

static

Definition at line 1436 of file resource_channels.c.

{
    struct ast_json_iter *it_json_var;
    struct ast_variable *var_tail = NULL;
    struct ast_variable *report_var_tail = NULL;
 
    *variables = NULL;
    *report_event_variables = NULL;
 
    for (it_json_var = ast_json_object_iter(json_variables); it_json_var;
        it_json_var = ast_json_object_iter_next(json_variables, it_json_var)) {
        struct ast_variable *new_var;
        const char *key = ast_json_object_iter_key(it_json_var);
        const char *value = NULL;
        struct ast_json *json_value = ast_json_object_iter_value(it_json_var);
        int report_events = 0;
 
        if (ast_strlen_zero(key)) {
            continue;
        }
 
        if (ast_json_typeof(json_value) == AST_JSON_STRING) {
            value = ast_json_string_get(json_value);
        } else if (ast_json_typeof(json_value) == AST_JSON_OBJECT) {
            struct ast_json *value_field = ast_json_object_get(json_value, "value");
            struct ast_json *report_field = ast_json_object_get(json_value, "report_events");
            ast_log(LOG_DEBUG, "Processing variable '%s' with report_events: %s\n", key,
                report_field ? (ast_json_is_true(report_field) ? "true" : "false") : "not set");
 
            if (!value_field || ast_json_typeof(value_field) != AST_JSON_STRING) {
                ast_ari_response_error(response, 400, "Bad Request",
                    "Each object value in 'variables' must include string field 'value'");
                goto error;
            }
 
            value = ast_json_string_get(value_field);
            ast_log(LOG_DEBUG, "Variable '%s' has value '%s'\n", key, value);
 
            if (report_field) {
                enum ast_json_type report_type = ast_json_typeof(report_field);
 
                if (report_type != AST_JSON_TRUE && report_type != AST_JSON_FALSE) {
                    ast_ari_response_error(response, 400, "Bad Request",
                        "Field 'report_events' in 'variables' entries must be boolean");
                    goto error;
                }
 
                report_events = ast_json_is_true(report_field);
            }
        } else {
            ast_ari_response_error(response, 400, "Bad Request",
                "Each value in 'variables' must be a string or an object with 'value' and optional 'report_events'");
            goto error;
        }
 
        if (!value) {
            continue;
        }
 
        new_var = ast_variable_new(key, value, "");
        if (!new_var) {
            ast_ari_response_alloc_failed(response);
            goto error;
        }
 
        var_tail = ast_variable_list_append_hint(variables, var_tail, new_var);
 
        if (report_events) {
            struct ast_variable *report_var = ast_variable_new(key, "1", "");
 
            if (!report_var) {
                ast_ari_response_alloc_failed(response);
                goto error;
            }
 
            report_var_tail = ast_variable_list_append_hint(report_event_variables,
                report_var_tail, report_var);
        }
    }
 
    return 0;
 
error:
    ast_variables_destroy(*variables);
    *variables = NULL;
    ast_variables_destroy(*report_event_variables);
    *report_event_variables = NULL;
    return -1;
}

References ast_ari_response_alloc_failed(), ast_ari_response_error(), AST_JSON_FALSE, ast_json_is_true(), AST_JSON_OBJECT, ast_json_object_get(), ast_json_object_iter(), ast_json_object_iter_key(), ast_json_object_iter_next(), ast_json_object_iter_value(), AST_JSON_STRING, ast_json_string_get(), AST_JSON_TRUE, ast_json_typeof(), ast_log, ast_strlen_zero(), ast_variable_list_append_hint(), ast_variable_new, ast_variables_destroy(), error(), LOG_DEBUG, NULL, and value.

Referenced by ast_ari_channels_create(), ast_ari_channels_external_media(), ast_ari_channels_originate(), ast_ari_channels_originate_with_id(), and ast_ari_channels_set_channel_vars().

restore_dialstring()

static char * restore_dialstring ( struct ast_channel *  chan )

static

Retrieve the dialstring from the channel datastore.

Precondition

chan is locked

Parameters

chan	Channel that was previously created in ARI

Return values

NULL	Failed to find datastore
non-NULL	The dialstring

Definition at line 2077 of file resource_channels.c.

{
    struct ast_datastore *datastore;
 
    datastore = ast_channel_datastore_find(chan, &dialstring_info, NULL);
    if (!datastore) {
        return NULL;
    }
 
    return datastore->data;
}

References ast_channel_datastore_find(), ast_datastore::data, dialstring_info, and NULL.

Referenced by ast_ari_channels_dial().

save_dialstring()

static int save_dialstring ( struct ast_channel *  chan, const char *  dialstring  )

static

Save dialstring onto a channel datastore.

This will later be retrieved when it comes time to actually dial the channel

Parameters

chan	The channel on which to save the dialstring
dialstring	The dialstring to save

Return values

0	on success.
-1	on error.

Definition at line 2043 of file resource_channels.c.

{
    struct ast_datastore *datastore;
 
    datastore = ast_datastore_alloc(&dialstring_info, NULL);
    if (!datastore) {
        return -1;
    }
 
    datastore->data = ast_strdup(dialstring);
    if (!datastore->data) {
        ast_datastore_free(datastore);
        return -1;
    }
 
    ast_channel_lock(chan);
    if (ast_channel_datastore_add(chan, datastore)) {
        ast_channel_unlock(chan);
        ast_datastore_free(datastore);
        return -1;
    }
    ast_channel_unlock(chan);
 
    return 0;
}

References ast_channel_datastore_add(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, ast_datastore_free(), ast_strdup, ast_datastore::data, dialstring_info, and NULL.

Referenced by ast_ari_channels_create().

Variable Documentation

dialstring_info

struct ast_datastore_info dialstring_info

Initial value:

= {
    .type = "ARI Dialstring",
    .destroy = ast_free_ptr,
}

Definition at line 2028 of file resource_channels.c.

                                            {
    .type = "ARI Dialstring",
    .destroy = ast_free_ptr,
};

Referenced by restore_dialstring(), and save_dialstring().