stasis_channels.c File Reference

Stasis Messages and Data Types for Channel Objects. More...

#include "asterisk.h"
#include "asterisk/astobj2.h"
#include "asterisk/json.h"
#include "asterisk/pbx.h"
#include "asterisk/bridge.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/translate.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/dial.h"
#include "asterisk/linkedlists.h"
#include "asterisk/utf8.h"
#include "asterisk/vector.h"

Include dependency graph for stasis_channels.c:

Go to the source code of this file.

Data Structures
struct	ast_multi_channel_blob
	A multi channel blob data structure for multi_channel_blob stasis messages. More...
struct	channel_role_snapshot
	A channel snapshot wrapper object used in ast_multi_channel_blob objects. More...
struct	dial_masquerade_datastore
struct	dial_target

Macros
#define	NUM_MULTI_CHANNEL_BLOB_BUCKETS   7

Functions
static struct ast_manager_event_blob *	agent_login_to_ami (struct stasis_message *msg)
static struct ast_manager_event_blob *	agent_logoff_to_ami (struct stasis_message *msg)
static void	ari_transfer_dtor (void *obj)
static struct ast_json *	ari_transfer_to_json (struct stasis_message *msg, const struct stasis_message_sanitizer *sanitize)
struct ast_ari_transfer_message *	ast_ari_transfer_message_create (struct ast_channel *originating_chan, const char *referred_by, const char *exten, const char *protocol_id, struct ast_channel *dest, struct ast_refer_params *params, enum ast_control_transfer state)
struct stasis_message *	ast_channel_blob_create (struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
	Creates a ast_channel_blob message.
struct stasis_message *	ast_channel_blob_create_from_cache (const char *channel_id, struct stasis_message_type *type, struct ast_json *blob)
	Create a ast_channel_blob message, pulling channel state from the cache.
struct ao2_container *	ast_channel_cache_all (void)
struct ao2_container *	ast_channel_cache_by_name (void)
	Secondary channel cache, indexed by name.
void	ast_channel_publish_blob (struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
	Publish a channel blob message.
void	ast_channel_publish_cached_blob (struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
	Publish a channel blob message using the latest snapshot from the cache.
void	ast_channel_publish_dial (struct ast_channel *caller, struct ast_channel *peer, const char *dialstring, const char *dialstatus)
	Publish in the ast_channel_topic or ast_channel_topic_all topics a stasis message for the channels involved in a dial operation.
void	ast_channel_publish_dial_forward (struct ast_channel *caller, struct ast_channel *peer, struct ast_channel *forwarded, const char *dialstring, const char *dialstatus, const char *forward)
	Publish in the ast_channel_topic or ast_channel_topic_all topics a stasis message for the channels involved in a dial operation that is forwarded.
static void	ast_channel_publish_dial_internal (struct ast_channel *caller, struct ast_channel *peer, struct ast_channel *forwarded, const char *dialstring, const char *dialstatus, const char *forward)
void	ast_channel_publish_final_snapshot (struct ast_channel *chan)
	Send the final channel snapshot for a channel, thus removing it from cache.
void	ast_channel_publish_snapshot (struct ast_channel *chan)
	Publish a ast_channel_snapshot for a channel.
void	ast_channel_publish_varset (struct ast_channel *chan, const char *name, const char *value)
	Publish a ast_channel_publish_varset for a channel.
int	ast_channel_snapshot_caller_id_equal (const struct ast_channel_snapshot *old_snapshot, const struct ast_channel_snapshot *new_snapshot)
	Compares the callerid info of two snapshots.
int	ast_channel_snapshot_cep_equal (const struct ast_channel_snapshot *old_snapshot, const struct ast_channel_snapshot *new_snapshot)
	Compares the context, exten and priority of two snapshots.
int	ast_channel_snapshot_connected_line_equal (const struct ast_channel_snapshot *old_snapshot, const struct ast_channel_snapshot *new_snapshot)
	Compares the connected line info of two snapshots.
struct ast_channel_snapshot *	ast_channel_snapshot_create (struct ast_channel *chan)
	Generate a snapshot of the channel state. This is an ao2 object, so ao2_cleanup() to deallocate.
struct ast_channel_snapshot *	ast_channel_snapshot_get_latest (const char *uniqueid)
	Obtain the latest ast_channel_snapshot from the Stasis Message Bus API cache. This is an ao2 object, so use ao2_cleanup() to deallocate.
struct ast_channel_snapshot *	ast_channel_snapshot_get_latest_by_name (const char *name)
	Obtain the latest ast_channel_snapshot from the Stasis Message Bus API cache. This is an ao2 object, so use ao2_cleanup() to deallocate.
void	ast_channel_snapshot_invalidate_segment (struct ast_channel *chan, enum ast_channel_snapshot_segment_invalidation segment)
	Invalidate a channel snapshot segment from being reused.
struct ast_json *	ast_channel_snapshot_to_json (const struct ast_channel_snapshot *snapshot, const struct stasis_message_sanitizer *sanitize)
	Build a JSON object from a ast_channel_snapshot.
void	ast_channel_stage_snapshot (struct ast_channel *chan)
	Set flag to indicate channel snapshot is being staged.
void	ast_channel_stage_snapshot_done (struct ast_channel *chan)
	Clear flag to indicate channel snapshot is being staged, and publish snapshot.
struct stasis_topic *	ast_channel_topic_all (void)
	A topic which publishes the events for all channels.
void	ast_multi_channel_blob_add_channel (struct ast_multi_channel_blob *obj, const char *role, struct ast_channel_snapshot *snapshot)
	Add a ast_channel_snapshot to a ast_multi_channel_blob object.
struct ast_multi_channel_blob *	ast_multi_channel_blob_create (struct ast_json *blob)
	Create a ast_multi_channel_blob suitable for a stasis_message.
struct ast_channel_snapshot *	ast_multi_channel_blob_get_channel (struct ast_multi_channel_blob *obj, const char *role)
	Retrieve a channel snapshot associated with a specific role from a ast_multi_channel_blob.
struct ao2_container *	ast_multi_channel_blob_get_channels (struct ast_multi_channel_blob *obj, const char *role)
	Retrieve all channel snapshots associated with a specific role from a ast_multi_channel_blob.
struct ast_json *	ast_multi_channel_blob_get_json (struct ast_multi_channel_blob *obj)
	Retrieve the JSON blob from a ast_multi_channel_blob. Returned ast_json is still owned by obj.
int	ast_stasis_channels_init (void)
	Initialize the stasis channel topic and message types.
static void	channel_blob_dtor (void *obj)
static struct ast_json *	channel_blob_to_json (struct stasis_message *message, const char *type, const struct stasis_message_sanitizer *sanitize)
static int	channel_role_cmp_cb (void *obj, void *arg, int flags)
static int	channel_role_hash_cb (const void *obj, const int flags)
static void	channel_role_snapshot_dtor (void *obj)
static struct ast_channel_snapshot_base *	channel_snapshot_base_create (struct ast_channel *chan)
static void	channel_snapshot_base_dtor (void *obj)
static struct ast_channel_snapshot_bridge *	channel_snapshot_bridge_create (struct ast_channel *chan)
static struct ast_channel_snapshot_caller *	channel_snapshot_caller_create (struct ast_channel *chan)
static void	channel_snapshot_caller_dtor (void *obj)
static int	channel_snapshot_cmp_cb (void *obj, void *arg, int flags)
static struct ast_channel_snapshot_connected *	channel_snapshot_connected_create (struct ast_channel *chan)
static struct ast_channel_snapshot_dialplan *	channel_snapshot_dialplan_create (struct ast_channel *chan)
static void	channel_snapshot_dialplan_dtor (void *obj)
static void	channel_snapshot_dtor (void *obj)
static struct ast_channel_snapshot_hangup *	channel_snapshot_hangup_create (struct ast_channel *chan)
static int	channel_snapshot_hash_cb (const void *obj, const int flags)
static struct ast_channel_snapshot_peer *	channel_snapshot_peer_create (struct ast_channel *chan)
static int	channel_snapshot_uniqueid_cmp_cb (void *obj, void *arg, int flags)
static int	channel_snapshot_uniqueid_hash_cb (const void *obj, const int flags)
static struct ast_channel_snapshot_update *	channel_snapshot_update_create (struct ast_channel *chan)
static void	channel_snapshot_update_dtor (void *obj)
static struct stasis_message *	create_channel_blob_message (struct ast_channel_snapshot *snapshot, struct stasis_message_type *type, struct ast_json *blob)
static void	dial_masquerade_breakdown (void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
static void	dial_masquerade_caller_datastore_destroy (void *data)
static struct dial_masquerade_datastore *	dial_masquerade_datastore_add (struct ast_channel *chan, struct dial_masquerade_datastore *masq_data)
static struct dial_masquerade_datastore *	dial_masquerade_datastore_alloc (void)
static void	dial_masquerade_datastore_cleanup (struct dial_masquerade_datastore *masq_data)
static void	dial_masquerade_datastore_destroy (void *data)
static void	dial_masquerade_datastore_dtor (void *vdoomed)
static struct ast_datastore *	dial_masquerade_datastore_find (struct ast_channel *chan)
static void	dial_masquerade_datastore_remove_chan (struct dial_masquerade_datastore *masq_data, struct ast_channel *chan)
static void	dial_masquerade_fixup (void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
static void	dial_target_free (struct dial_target *doomed)
static struct ast_json *	dial_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static struct ast_json *	dtmf_end_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static struct ast_json *	hangup_request_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static struct ast_json *	hold_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static void	multi_channel_blob_dtor (void *obj)
static void	publish_message_for_channel_topics (struct stasis_message *message, struct ast_channel *chan)
static void	remove_dial_masquerade (struct ast_channel *peer)
static void	remove_dial_masquerade_caller (struct ast_channel *caller)
static int	set_dial_masquerade (struct ast_channel *caller, struct ast_channel *peer, const char *dialstring)
static void	stasis_channels_cleanup (void)
static const char *	state2str (enum ast_control_transfer state)
static struct ast_manager_event_blob *	talking_start_to_ami (struct stasis_message *msg)
static struct ast_json *	talking_start_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static struct ast_manager_event_blob *	talking_stop_to_ami (struct stasis_message *msg)
static struct ast_json *	talking_stop_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static struct ast_json *	tone_detect_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static struct ast_json *	unhold_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
static struct ast_manager_event_blob *	varset_to_ami (struct stasis_message *msg)
static struct ast_json *	varset_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_agent_login_type,.to_ami=agent_login_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_agent_logoff_type,.to_ami=agent_logoff_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_chanspy_start_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_chanspy_stop_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_dial_type,.to_json=dial_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_dtmf_begin_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_dtmf_end_type,.to_json=dtmf_end_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_fax_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_flash_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_hangup_handler_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_hangup_request_type,.to_json=hangup_request_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_hold_type,.to_json=hold_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_masquerade_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_mixmonitor_mute_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_mixmonitor_start_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_mixmonitor_stop_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_moh_start_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_moh_stop_type)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_snapshot_type)
	Define channel message types.
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_talking_start,.to_ami=talking_start_to_ami,.to_json=talking_start_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_talking_stop,.to_ami=talking_stop_to_ami,.to_json=talking_stop_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_tone_detect,.to_json=tone_detect_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_transfer_request_type,.to_json=ari_transfer_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_unhold_type,.to_json=unhold_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_varset_type,.to_ami=varset_to_ami,.to_json=varset_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_channel_wink_type)

Variables
static struct ao2_container *	channel_cache
static struct ao2_container *	channel_cache_by_name
static struct stasis_topic *	channel_topic_all
static const struct ast_datastore_info	dial_masquerade_caller_info
static const struct ast_datastore_info	dial_masquerade_info

Detailed Description

Stasis Messages and Data Types for Channel Objects.

Author

Matt Jordan <mjordan@digium.com> 

Definition in file stasis_channels.c.

Macro Definition Documentation

NUM_MULTI_CHANNEL_BLOB_BUCKETS

#define NUM_MULTI_CHANNEL_BLOB_BUCKETS   7

Definition at line 138 of file stasis_channels.c.

Function Documentation

agent_login_to_ami()

static struct ast_manager_event_blob * agent_login_to_ami ( struct stasis_message *  msg )

static

Definition at line 1269 of file stasis_channels.c.

{
    struct ast_str *channel_string;
    struct ast_channel_blob *obj = stasis_message_data(msg);
    const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent"));
    struct ast_manager_event_blob *ev;
 
    channel_string = ast_manager_build_channel_state_string(obj->snapshot);
    if (!channel_string) {
        return NULL;
    }
 
    ev = ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogin",
        "%s"
        "Agent: %s\r\n",
        ast_str_buffer(channel_string), agent);
    ast_free(channel_string);
    return ev;
}

References ast_free, ast_json_object_get(), ast_json_string_get(), ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_str_buffer(), ast_channel_blob::blob, EVENT_FLAG_AGENT, NULL, ast_channel_blob::snapshot, and stasis_message_data().

agent_logoff_to_ami()

static struct ast_manager_event_blob * agent_logoff_to_ami ( struct stasis_message *  msg )

static

Definition at line 1289 of file stasis_channels.c.

{
    struct ast_str *channel_string;
    struct ast_channel_blob *obj = stasis_message_data(msg);
    const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent"));
    long logintime = ast_json_integer_get(ast_json_object_get(obj->blob, "logintime"));
    struct ast_manager_event_blob *ev;
 
    channel_string = ast_manager_build_channel_state_string(obj->snapshot);
    if (!channel_string) {
        return NULL;
    }
 
    ev = ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogoff",
        "%s"
        "Agent: %s\r\n"
        "Logintime: %ld\r\n",
        ast_str_buffer(channel_string), agent, logintime);
    ast_free(channel_string);
    return ev;
}

References ast_free, ast_json_integer_get(), ast_json_object_get(), ast_json_string_get(), ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_str_buffer(), ast_channel_blob::blob, EVENT_FLAG_AGENT, NULL, ast_channel_blob::snapshot, and stasis_message_data().

ari_transfer_dtor()

static void ari_transfer_dtor ( void *  obj )

static

Definition at line 1757 of file stasis_channels.c.

{
    struct ast_ari_transfer_message *msg = obj;
 
    ao2_cleanup(msg->source);
    ao2_cleanup(msg->source_bridge);
    ao2_cleanup(msg->source_peer);
    ao2_cleanup(msg->dest);
    ao2_cleanup(msg->dest_bridge);
    ao2_cleanup(msg->dest_peer);
    ao2_cleanup(msg->refer_params);
    ast_free(msg->referred_by);
    ast_free(msg->protocol_id);
}

References ao2_cleanup, ast_free, ast_ari_transfer_message::dest, ast_ari_transfer_message::dest_bridge, ast_ari_transfer_message::dest_peer, ast_ari_transfer_message::protocol_id, ast_ari_transfer_message::refer_params, ast_ari_transfer_message::referred_by, ast_ari_transfer_message::source, ast_ari_transfer_message::source_bridge, and ast_ari_transfer_message::source_peer.

Referenced by ast_ari_transfer_message_create().

ari_transfer_to_json()

static struct ast_json * ari_transfer_to_json ( struct stasis_message *  msg, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1663 of file stasis_channels.c.

{
    struct ast_json *json_channel, *res;
    struct ast_json *refer_json, *referred_json, *dest_json;
    const struct timeval *tv = stasis_message_timestamp(msg);
    struct ast_ari_transfer_message *transfer_msg = stasis_message_data(msg);
 
    dest_json = ast_json_pack("{s: s}", "destination", transfer_msg->destination);
    if (!dest_json) {
        return NULL;
    }
 
    if (transfer_msg->protocol_id) {
        ast_json_object_set(dest_json, "protocol_id",
            ast_json_string_create(transfer_msg->protocol_id));
    }
 
    if (AST_VECTOR_SIZE(transfer_msg->refer_params) > 0) {
        struct ast_json *params = ast_json_array_create();
        if (!params) {
            return NULL;
        }
        for (int i = 0; i < AST_VECTOR_SIZE(transfer_msg->refer_params); ++i) {
            struct ast_refer_param param = AST_VECTOR_GET(transfer_msg->refer_params, i);
            ast_json_array_append(params, ast_json_pack("{s: s, s: s}",
                                    "parameter_name", param.param_name,
                                    "parameter_value", param.param_value));
        }
        ast_json_object_set(dest_json, "additional_protocol_params", params);
    }
 
    refer_json = ast_json_pack("{s: o}",
        "requested_destination", dest_json);
    if (!refer_json) {
        return NULL;
    }
    if (transfer_msg->dest) {
        struct ast_json *dest_chan_json;
 
        dest_chan_json = ast_channel_snapshot_to_json(transfer_msg->dest, sanitize);
        ast_json_object_set(refer_json, "destination_channel", dest_chan_json);
    }
    if (transfer_msg->dest_peer) {
        struct ast_json *peer_chan_json;
 
        peer_chan_json = ast_channel_snapshot_to_json(transfer_msg->dest_peer, sanitize);
        ast_json_object_set(refer_json, "connected_channel", peer_chan_json);
    }
    if (transfer_msg->dest_bridge) {
        struct ast_json *dest_bridge_json;
 
        dest_bridge_json = ast_bridge_snapshot_to_json(transfer_msg->dest_bridge, sanitize);
        ast_json_object_set(refer_json, "bridge", dest_bridge_json);
    }
 
    json_channel = ast_channel_snapshot_to_json(transfer_msg->source, sanitize);
    if (!json_channel) {
        return NULL;
    }
 
    referred_json = ast_json_pack("{s: o}",
        "source_channel", json_channel);
    if (!referred_json) {
        return NULL;
    }
    if (transfer_msg->source_peer) {
        struct ast_json *peer_chan_json;
 
        peer_chan_json = ast_channel_snapshot_to_json(transfer_msg->source_peer, sanitize);
        ast_json_object_set(referred_json, "connected_channel", peer_chan_json);
    }
    if (transfer_msg->source_bridge) {
        struct ast_json *source_bridge_json;
 
        source_bridge_json = ast_bridge_snapshot_to_json(transfer_msg->source_bridge, sanitize);
        ast_json_object_set(referred_json, "bridge", source_bridge_json);
    }
 
    res = ast_json_pack("{s: s, s: o, s: o, s: o}",
        "type", "ChannelTransfer",
        "timestamp", ast_json_timeval(*tv, NULL),
        "refer_to", refer_json,
        "referred_by", referred_json);
    if (!res) {
        return NULL;
    }
 
    if (transfer_msg->state != AST_TRANSFER_INVALID) {
        ast_json_object_set(res, "state", ast_json_string_create(state2str(transfer_msg->state)));
    }
    return res;
}

References ast_bridge_snapshot_to_json(), ast_channel_snapshot_to_json(), ast_json_array_append(), ast_json_array_create(), ast_json_object_set(), ast_json_pack(), ast_json_string_create(), ast_json_timeval(), AST_TRANSFER_INVALID, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_ari_transfer_message::dest, ast_ari_transfer_message::dest_bridge, ast_ari_transfer_message::dest_peer, ast_ari_transfer_message::destination, NULL, ast_refer_param::param_name, ast_refer_param::param_value, ast_ari_transfer_message::protocol_id, ast_ari_transfer_message::refer_params, ast_ari_transfer_message::source, ast_ari_transfer_message::source_bridge, ast_ari_transfer_message::source_peer, stasis_message_data(), stasis_message_timestamp(), ast_ari_transfer_message::state, and state2str().

ast_ari_transfer_message_create()

struct ast_ari_transfer_message * ast_ari_transfer_message_create	(	struct ast_channel *	originating_chan,
		const char *	referred_by,
		const char *	exten,
		const char *	protocol_id,
		struct ast_channel *	dest,
		struct ast_refer_params *	params,
		enum ast_control_transfer	state
	)

Definition at line 1772 of file stasis_channels.c.

{
    struct ast_ari_transfer_message *msg;
    msg = ao2_alloc(sizeof(*msg), ari_transfer_dtor);
    if (!msg) {
        return NULL;
    }
 
    msg->refer_params = params;
    ao2_ref(msg->refer_params, +1);
 
    msg->state = state;
 
    ast_channel_lock(originating_chan);
    msg->source = ao2_bump(ast_channel_snapshot(originating_chan));
    ast_channel_unlock(originating_chan);
    if (!msg->source) {
        ao2_cleanup(msg);
        return NULL;
    }
 
    if (dest) {
        ast_channel_lock(dest);
        msg->dest = ao2_bump(ast_channel_snapshot(dest));
        ast_channel_unlock(dest);
        if (!msg->dest) {
            ao2_cleanup(msg);
            return NULL;
        }
    }
 
    if (referred_by) {
        msg->referred_by = ast_strdup(referred_by);
        if (!msg->referred_by) {
            ao2_cleanup(msg);
            return NULL;
        }
    }
 
    ast_copy_string(msg->destination, exten, sizeof(msg->destination));
 
    if (protocol_id) {
        msg->protocol_id = ast_strdup(protocol_id);
        if (!msg->protocol_id) {
            ao2_cleanup(msg);
            return NULL;
        }
    }
 
    return msg;
}

References ao2_alloc, ao2_bump, ao2_cleanup, ao2_ref, ari_transfer_dtor(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), ast_strdup, ast_ari_transfer_message::dest, ast_ari_transfer_message::destination, NULL, ast_ari_transfer_message::protocol_id, ast_ari_transfer_message::refer_params, ast_ari_transfer_message::referred_by, ast_ari_transfer_message::source, and ast_ari_transfer_message::state.

Referenced by ast_refer_notify_transfer_request().

ast_channel_publish_dial_internal()

static void ast_channel_publish_dial_internal ( struct ast_channel *  caller, struct ast_channel *  peer, struct ast_channel *  forwarded, const char *  dialstring, const char *  dialstatus, const char *  forward  )

static

Definition at line 630 of file stasis_channels.c.

{
    struct ast_multi_channel_blob *payload;
    struct stasis_message *msg;
    struct ast_json *blob;
    struct ast_channel_snapshot *peer_snapshot;
 
    if (!ast_channel_dial_type()) {
        return;
    }
 
    ast_assert(peer != NULL);
 
    blob = ast_json_pack("{s: s, s: s, s: s}",
        "dialstatus", S_OR(dialstatus, ""),
        "forward", S_OR(forward, ""),
        "dialstring", S_OR(dialstring, ""));
    if (!blob) {
        return;
    }
    payload = ast_multi_channel_blob_create(blob);
    ast_json_unref(blob);
    if (!payload) {
        return;
    }
 
    if (caller) {
        struct ast_channel_snapshot *caller_snapshot;
 
        ast_channel_lock(caller);
        if (ast_strlen_zero(dialstatus)) {
            caller_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(caller));
        } else {
            caller_snapshot = ast_channel_snapshot_create(caller);
        }
        ast_channel_unlock(caller);
        if (!caller_snapshot) {
            ao2_ref(payload, -1);
            return;
        }
        ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot);
        ao2_ref(caller_snapshot, -1);
    }
 
    ast_channel_lock(peer);
    if (ast_strlen_zero(dialstatus)) {
        peer_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(peer));
    } else {
        peer_snapshot = ast_channel_snapshot_create(peer);
    }
    ast_channel_unlock(peer);
    if (!peer_snapshot) {
        ao2_ref(payload, -1);
        return;
    }
    ast_multi_channel_blob_add_channel(payload, "peer", peer_snapshot);
    ao2_ref(peer_snapshot, -1);
 
    if (forwarded) {
        struct ast_channel_snapshot *forwarded_snapshot;
 
        ast_channel_lock(forwarded);
        forwarded_snapshot = ast_channel_snapshot_create(forwarded);
        ast_channel_unlock(forwarded);
        if (!forwarded_snapshot) {
            ao2_ref(payload, -1);
            return;
        }
        ast_multi_channel_blob_add_channel(payload, "forwarded", forwarded_snapshot);
        ao2_ref(forwarded_snapshot, -1);
    }
 
    msg = stasis_message_create(ast_channel_dial_type(), payload);
    ao2_ref(payload, -1);
    if (msg) {
        publish_message_for_channel_topics(msg, caller ?: peer);
        ao2_ref(msg, -1);
    }
}

References ao2_ref, ast_assert, ast_channel_dial_type(), ast_channel_lock, ast_channel_snapshot_create(), ast_channel_snapshot_get_latest(), ast_channel_uniqueid(), ast_channel_unlock, ast_json_pack(), ast_json_unref(), ast_multi_channel_blob_add_channel(), ast_multi_channel_blob_create(), ast_strlen_zero(), ast_channel_snapshot::caller, NULL, ast_channel_snapshot::peer, publish_message_for_channel_topics(), S_OR, and stasis_message_create().

Referenced by ast_channel_publish_dial_forward(), dial_masquerade_breakdown(), and dial_masquerade_fixup().

ast_channel_snapshot_caller_id_equal()

int ast_channel_snapshot_caller_id_equal	(	const struct ast_channel_snapshot *	old_snapshot,
		const struct ast_channel_snapshot *	new_snapshot
	)

Compares the callerid info of two snapshots.

Since

12

Parameters

old_snapshot	Old snapshot
new_snapshot	New snapshot

Return values

True	(non-zero) if callerid are identical.
False	(zero) if callerid changed.

Definition at line 1383 of file stasis_channels.c.

{
    ast_assert(old_snapshot != NULL);
    ast_assert(new_snapshot != NULL);
    return strcmp(old_snapshot->caller->number, new_snapshot->caller->number) == 0 &&
        strcmp(old_snapshot->caller->name, new_snapshot->caller->name) == 0;
}

References ast_assert, ast_channel_snapshot::caller, ast_channel_snapshot_caller::name, NULL, and ast_channel_snapshot_caller::number.

Referenced by channel_callerid(), and channel_new_callerid().

ast_channel_snapshot_cep_equal()

int ast_channel_snapshot_cep_equal	(	const struct ast_channel_snapshot *	old_snapshot,
		const struct ast_channel_snapshot *	new_snapshot
	)

Compares the context, exten and priority of two snapshots.

Since

12

Parameters

old_snapshot	Old snapshot
new_snapshot	New snapshot

Return values

True	(non-zero) if context, exten or priority are identical.
False	(zero) if context, exten and priority changed.

Definition at line 1362 of file stasis_channels.c.

{
    ast_assert(old_snapshot != NULL);
    ast_assert(new_snapshot != NULL);
 
    /* We actually get some snapshots with CEP set, but before the
     * application is set. Since empty application is invalid, we treat
     * setting the application from nothing as a CEP change.
     */
    if (ast_strlen_zero(old_snapshot->dialplan->appl) &&
        !ast_strlen_zero(new_snapshot->dialplan->appl)) {
        return 0;
    }
 
    return old_snapshot->dialplan->priority == new_snapshot->dialplan->priority &&
        strcmp(old_snapshot->dialplan->context, new_snapshot->dialplan->context) == 0 &&
        strcmp(old_snapshot->dialplan->exten, new_snapshot->dialplan->exten) == 0;
}

References ast_channel_snapshot_dialplan::appl, ast_assert, ast_strlen_zero(), ast_channel_snapshot_dialplan::context, ast_channel_snapshot::dialplan, ast_channel_snapshot_dialplan::exten, NULL, and ast_channel_snapshot_dialplan::priority.

Referenced by channel_dialplan(), and channel_newexten().

ast_channel_snapshot_connected_line_equal()

int ast_channel_snapshot_connected_line_equal	(	const struct ast_channel_snapshot *	old_snapshot,
		const struct ast_channel_snapshot *	new_snapshot
	)

Compares the connected line info of two snapshots.

Since

13.1.0

Parameters

old_snapshot	Old snapshot
new_snapshot	New snapshot

Return values

True	(non-zero) if callerid are identical.
False	(zero) if callerid changed.

Definition at line 1393 of file stasis_channels.c.

{
    ast_assert(old_snapshot != NULL);
    ast_assert(new_snapshot != NULL);
    return strcmp(old_snapshot->connected->number, new_snapshot->connected->number) == 0 &&
        strcmp(old_snapshot->connected->name, new_snapshot->connected->name) == 0;
}

References ast_assert, ast_channel_snapshot::connected, ast_channel_snapshot_connected::name, NULL, and ast_channel_snapshot_connected::number.

Referenced by channel_connected_line(), and channel_new_connected_line().

ast_channel_snapshot_to_json()

struct ast_json * ast_channel_snapshot_to_json	(	const struct ast_channel_snapshot *	snapshot,
		const struct stasis_message_sanitizer *	sanitize
	)

Build a JSON object from a ast_channel_snapshot.

Parameters

snapshot	The snapshot to convert to JSON
sanitize	The message sanitizer to use on the snapshot

Returns

JSON object representing channel snapshot.

Return values

NULL

on error

Definition at line 1311 of file stasis_channels.c.

{
    struct ast_json *json_chan;
 
    if (snapshot == NULL
        || (sanitize
            && sanitize->channel_snapshot
            && sanitize->channel_snapshot(snapshot))) {
        return NULL;
    }
 
    json_chan = ast_json_pack(
        /* Broken up into groups for readability */
        "{ s: s, s: s, s: s, s: s,"
        "  s: o, s: o, s: s,"
        "  s: o, s: o, s: s }",
        /* First line */
        "id", snapshot->base->uniqueid,
        "name", snapshot->base->name,
        "state", ast_state2str(snapshot->state),
        "protocol_id", snapshot->base->protocol_id,
        /* Second line */
        "caller", ast_json_name_number(
            snapshot->caller->name, snapshot->caller->number),
        "connected", ast_json_name_number(
            snapshot->connected->name, snapshot->connected->number),
        "accountcode", snapshot->base->accountcode,
        /* Third line */
        "dialplan", ast_json_dialplan_cep_app(
            snapshot->dialplan->context, snapshot->dialplan->exten, snapshot->dialplan->priority,
            snapshot->dialplan->appl, snapshot->dialplan->data),
        "creationtime", ast_json_timeval(snapshot->base->creationtime, NULL),
        "language", snapshot->base->language);
 
    if (!ast_strlen_zero(snapshot->caller->rdnis)) {
        ast_json_object_set(json_chan, "caller_rdnis", ast_json_string_create(snapshot->caller->rdnis));
    }
 
    if (snapshot->ari_vars && !AST_LIST_EMPTY(snapshot->ari_vars)) {
        ast_json_object_set(json_chan, "channelvars", ast_json_channel_vars(snapshot->ari_vars));
    }
 
        if (!ast_strlen_zero(snapshot->base->tenantid)) {
                ast_json_object_set(json_chan, "tenantid", ast_json_string_create(snapshot->base->tenantid));
        }
 
    return json_chan;
}

References ast_channel_snapshot_base::accountcode, ast_channel_snapshot_dialplan::appl, ast_channel_snapshot::ari_vars, ast_json_channel_vars(), ast_json_dialplan_cep_app(), ast_json_name_number(), ast_json_object_set(), ast_json_pack(), ast_json_string_create(), ast_json_timeval(), AST_LIST_EMPTY, ast_state2str(), ast_strlen_zero(), ast_channel_snapshot::base, ast_channel_snapshot::caller, stasis_message_sanitizer::channel_snapshot, ast_channel_snapshot::connected, ast_channel_snapshot_dialplan::context, ast_channel_snapshot_base::creationtime, ast_channel_snapshot_dialplan::data, ast_channel_snapshot::dialplan, ast_channel_snapshot_dialplan::exten, ast_channel_snapshot_base::language, ast_channel_snapshot_caller::name, ast_channel_snapshot_connected::name, ast_channel_snapshot_base::name, NULL, ast_channel_snapshot_caller::number, ast_channel_snapshot_connected::number, ast_channel_snapshot_dialplan::priority, ast_channel_snapshot_caller::rdnis, ast_channel_snapshot::state, ast_channel_snapshot_base::tenantid, and ast_channel_snapshot_base::uniqueid.

Referenced by ari_channels_handle_originate_with_id(), ari_channels_handle_snoop_channel(), ari_transfer_to_json(), ast_ari_channels_create(), ast_ari_channels_get(), ast_ari_channels_list(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), attended_transfer_to_json(), blind_transfer_to_json(), channel_blob_to_json(), channel_callerid(), channel_connected_line(), channel_destroyed_event(), channel_dialplan(), channel_to_json(), dial_to_json(), dtmf_end_to_json(), hold_to_json(), multi_user_event_to_json(), rtcp_report_to_json(), simple_bridge_channel_event(), simple_channel_event(), stasis_app_exec(), stasis_end_to_json(), stasis_start_to_json(), and unhold_to_json().

ast_stasis_channels_init()

int ast_stasis_channels_init

(

void

)

Initialize the stasis channel topic and message types.

Return values

0	on success
Non-zero	on error

Definition at line 1922 of file stasis_channels.c.

{
    int res = 0;
 
    ast_register_cleanup(stasis_channels_cleanup);
 
    channel_topic_all = stasis_topic_create("channel:all");
    if (!channel_topic_all) {
        return -1;
    }
 
    channel_cache = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_RWLOCK,
        0, AST_NUM_CHANNEL_BUCKETS, channel_snapshot_uniqueid_hash_cb,
        NULL, channel_snapshot_uniqueid_cmp_cb);
    if (!channel_cache) {
        return -1;
    }
 
    channel_cache_by_name = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_RWLOCK,
        0, AST_NUM_CHANNEL_BUCKETS, channel_snapshot_hash_cb,
        NULL, channel_snapshot_cmp_cb);
    if (!channel_cache_by_name) {
        return -1;
    }
 
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_agent_login_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_agent_logoff_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_snapshot_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_dial_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_varset_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_hangup_request_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_masquerade_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_dtmf_begin_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_dtmf_end_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_flash_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_wink_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_hold_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_unhold_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_chanspy_start_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_chanspy_stop_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_fax_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_hangup_handler_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_moh_start_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_moh_stop_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_mixmonitor_start_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_mixmonitor_stop_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_mixmonitor_mute_type);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_talking_start);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_talking_stop);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_tone_detect);
    res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_transfer_request_type);
 
    return res;
}

References AO2_ALLOC_OPT_LOCK_RWLOCK, ao2_container_alloc_hash, ast_channel_agent_login_type(), ast_channel_agent_logoff_type(), ast_channel_chanspy_start_type(), ast_channel_chanspy_stop_type(), ast_channel_dial_type(), ast_channel_dtmf_begin_type(), ast_channel_dtmf_end_type(), ast_channel_fax_type(), ast_channel_flash_type(), ast_channel_hangup_handler_type(), ast_channel_hangup_request_type(), ast_channel_hold_type(), ast_channel_masquerade_type(), ast_channel_mixmonitor_mute_type(), ast_channel_mixmonitor_start_type(), ast_channel_mixmonitor_stop_type(), ast_channel_moh_start_type(), ast_channel_moh_stop_type(), ast_channel_snapshot_type(), ast_channel_talking_start(), ast_channel_talking_stop(), ast_channel_tone_detect(), ast_channel_transfer_request_type(), ast_channel_unhold_type(), ast_channel_varset_type(), ast_channel_wink_type(), AST_NUM_CHANNEL_BUCKETS, ast_register_cleanup(), channel_cache, channel_cache_by_name, channel_snapshot_cmp_cb(), channel_snapshot_hash_cb(), channel_snapshot_uniqueid_cmp_cb(), channel_snapshot_uniqueid_hash_cb(), channel_topic_all, NULL, stasis_channels_cleanup(), STASIS_MESSAGE_TYPE_INIT, and stasis_topic_create().

Referenced by ast_channels_init().

channel_blob_dtor()

static void channel_blob_dtor ( void *  obj )

static

Definition at line 623 of file stasis_channels.c.

{
    struct ast_channel_blob *event = obj;
    ao2_cleanup(event->snapshot);
    ast_json_unref(event->blob);
}

References ao2_cleanup, and ast_json_unref().

Referenced by create_channel_blob_message().

channel_blob_to_json()

static struct ast_json * channel_blob_to_json ( struct stasis_message *  message, const char *  type, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1403 of file stasis_channels.c.

{
    struct ast_json *to_json;
    struct ast_channel_blob *channel_blob = stasis_message_data(message);
    struct ast_json *blob = channel_blob->blob;
    struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
    const struct timeval *tv = stasis_message_timestamp(message);
    int res = 0;
 
    if (blob == NULL || ast_json_is_null(blob)) {
        to_json = ast_json_object_create();
    } else {
        /* blobs are immutable, so shallow copies are fine */
        to_json = ast_json_copy(blob);
    }
    if (!to_json) {
        return NULL;
    }
 
    res |= ast_json_object_set(to_json, "type", ast_json_string_create(type));
    res |= ast_json_object_set(to_json, "timestamp",
        ast_json_timeval(*tv, NULL));
 
    /* For global channel messages, the snapshot is optional */
    if (snapshot) {
        struct ast_json *json_channel;
 
        json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
        if (!json_channel) {
            ast_json_unref(to_json);
            return NULL;
        }
 
        res |= ast_json_object_set(to_json, "channel", json_channel);
    }
 
    if (res != 0) {
        ast_json_unref(to_json);
        return NULL;
    }
 
    return to_json;
}

References ast_channel_snapshot_to_json(), ast_json_copy(), ast_json_is_null(), ast_json_object_create(), ast_json_object_set(), ast_json_string_create(), ast_json_timeval(), ast_json_unref(), ast_channel_blob::blob, NULL, ast_channel_blob::snapshot, stasis_message_data(), stasis_message_timestamp(), and type.

Referenced by hangup_request_to_json(), talking_start_to_json(), talking_stop_to_json(), tone_detect_to_json(), and varset_to_json().

channel_role_cmp_cb()

static int channel_role_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 848 of file stasis_channels.c.

{
    const struct channel_role_snapshot *object_left = obj;
    const struct channel_role_snapshot *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = object_right->role;
    case OBJ_SEARCH_KEY:
        cmp = strcasecmp(object_left->role, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        cmp = strncasecmp(object_left->role, right_key, strlen(right_key));
        break;
    default:
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    return CMP_MATCH;
}

References CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and channel_role_snapshot::role.

Referenced by ast_multi_channel_blob_create(), and ast_multi_channel_blob_get_channels().

channel_role_hash_cb()

static int channel_role_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 878 of file stasis_channels.c.

{
    const struct channel_role_snapshot *object = obj;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        key = object->role;
        break;
    default:
        ast_assert(0);
        return 0;
    }
    return ast_str_case_hash(key);
}

References ast_assert, ast_str_case_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and channel_role_snapshot::role.

Referenced by ast_multi_channel_blob_create().

channel_role_snapshot_dtor()

static void channel_role_snapshot_dtor ( void *  obj )

static

Definition at line 977 of file stasis_channels.c.

{
    struct channel_role_snapshot *role_snapshot = obj;
 
    ao2_cleanup(role_snapshot->snapshot);
}

References ao2_cleanup, and channel_role_snapshot::snapshot.

Referenced by ast_multi_channel_blob_add_channel().

channel_snapshot_base_create()

static struct ast_channel_snapshot_base * channel_snapshot_base_create ( struct ast_channel *  chan )

static

Definition at line 287 of file stasis_channels.c.

{
    struct ast_channel_snapshot_base *snapshot;
 
    snapshot = ao2_alloc_options(sizeof(*snapshot), channel_snapshot_base_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!snapshot) {
        return NULL;
    }
 
    if (ast_string_field_init(snapshot, 256) || ast_string_field_init_extended(snapshot, protocol_id)) {
        ao2_ref(snapshot, -1);
        return NULL;
    }
 
    ast_string_field_set(snapshot, name, ast_channel_name(chan));
    ast_string_field_set(snapshot, type, ast_channel_tech(chan)->type);
    ast_string_field_set(snapshot, accountcode, ast_channel_accountcode(chan));
    ast_string_field_set(snapshot, userfield, ast_channel_userfield(chan));
    ast_string_field_set(snapshot, uniqueid, ast_channel_uniqueid(chan));
    ast_string_field_set(snapshot, language, ast_channel_language(chan));
    ast_string_field_set(snapshot, tenantid, ast_channel_tenantid(chan));
 
    snapshot->creationtime = ast_channel_creationtime(chan);
    snapshot->tech_properties = ast_channel_tech(chan)->properties;
 
    if (ast_channel_tech(chan)->get_pvt_uniqueid) {
        ast_string_field_set(snapshot, protocol_id, ast_channel_tech(chan)->get_pvt_uniqueid(chan));
    }
 
    return snapshot;
}

References accountcode, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_channel_accountcode(), ast_channel_creationtime(), ast_channel_language(), ast_channel_name(), ast_channel_tenantid(), ast_channel_uniqueid(), ast_channel_userfield(), ast_string_field_init, ast_string_field_init_extended, ast_string_field_set, channel_snapshot_base_dtor(), ast_channel_snapshot_base::creationtime, language, name, NULL, ast_channel_tech::properties, ast_channel_snapshot_base::tech_properties, ast_channel_snapshot_base::tenantid, type, ast_channel_snapshot_base::uniqueid, and ast_channel_snapshot_base::userfield.

Referenced by ast_channel_snapshot_create().

channel_snapshot_base_dtor()

static void channel_snapshot_base_dtor ( void *  obj )

static

Definition at line 280 of file stasis_channels.c.

{
    struct ast_channel_snapshot_base *snapshot = obj;
 
    ast_string_field_free_memory(snapshot);
}

References ast_string_field_free_memory.

Referenced by channel_snapshot_base_create().

channel_snapshot_bridge_create()

static struct ast_channel_snapshot_bridge * channel_snapshot_bridge_create ( struct ast_channel *  chan )

static

Definition at line 404 of file stasis_channels.c.

{
    const char *uniqueid = "";
    struct ast_bridge *bridge;
    struct ast_channel_snapshot_bridge *snapshot;
 
    bridge = ast_channel_get_bridge(chan);
    if (bridge && !ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_INVISIBLE)) {
        uniqueid = bridge->uniqueid;
    }
    ao2_cleanup(bridge);
 
    snapshot = ao2_alloc_options(sizeof(*snapshot) + strlen(uniqueid) + 1, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!snapshot) {
        return NULL;
    }
 
    strcpy(snapshot->id, uniqueid); /* Safe */
 
    return snapshot;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, AST_BRIDGE_FLAG_INVISIBLE, ast_channel_get_bridge(), ast_test_flag, ast_bridge::feature_flags, ast_channel_snapshot_bridge::id, NULL, and ast_bridge::uniqueid.

Referenced by ast_channel_snapshot_create().

channel_snapshot_caller_create()

static struct ast_channel_snapshot_caller * channel_snapshot_caller_create ( struct ast_channel *  chan )

static

Definition at line 347 of file stasis_channels.c.

{
    struct ast_channel_snapshot_caller *snapshot;
 
    snapshot = ao2_alloc_options(sizeof(*snapshot), channel_snapshot_caller_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!snapshot) {
        return NULL;
    }
 
    if (ast_string_field_init(snapshot, 256)) {
        ao2_ref(snapshot, -1);
        return NULL;
    }
 
    ast_string_field_set(snapshot, name,
        S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, ""));
    ast_string_field_set(snapshot, number,
        S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""));
    ast_string_field_set(snapshot, subaddr,
        S_COR(ast_channel_caller(chan)->id.subaddress.valid, ast_channel_caller(chan)->id.subaddress.str, ""));
    ast_string_field_set(snapshot, ani,
        S_COR(ast_channel_caller(chan)->ani.number.valid, ast_channel_caller(chan)->ani.number.str, ""));
 
    ast_string_field_set(snapshot, rdnis,
        S_COR(ast_channel_redirecting(chan)->from.number.valid, ast_channel_redirecting(chan)->from.number.str, ""));
 
    ast_string_field_set(snapshot, dnid,
        S_OR(ast_channel_dialed(chan)->number.str, ""));
    ast_string_field_set(snapshot, dialed_subaddr,
        S_COR(ast_channel_dialed(chan)->subaddress.valid, ast_channel_dialed(chan)->subaddress.str, ""));
 
    snapshot->pres = ast_party_id_presentation(&ast_channel_caller(chan)->id);
 
    return snapshot;
}

References ast_channel_snapshot_caller::ani, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_channel_caller(), ast_channel_dialed(), ast_channel_redirecting(), ast_party_id_presentation(), ast_string_field_init, ast_string_field_set, channel_snapshot_caller_dtor(), ast_channel_snapshot_caller::dialed_subaddr, ast_channel_snapshot_caller::dnid, name, NULL, ast_channel_snapshot_caller::pres, ast_channel_snapshot_caller::rdnis, S_COR, S_OR, ast_party_dialed::str, and ast_channel_snapshot_caller::subaddr.

Referenced by ast_channel_snapshot_create().

channel_snapshot_caller_dtor()

static void channel_snapshot_caller_dtor ( void *  obj )

static

Definition at line 340 of file stasis_channels.c.

{
    struct ast_channel_snapshot_caller *snapshot = obj;
 
    ast_string_field_free_memory(snapshot);
}

References ast_string_field_free_memory.

Referenced by channel_snapshot_caller_create().

channel_snapshot_cmp_cb()

static int channel_snapshot_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 186 of file stasis_channels.c.

{
    const struct ast_channel_snapshot *object_left = obj;
    const struct ast_channel_snapshot *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = object_right->base->name;
    case OBJ_SEARCH_KEY:
        cmp = strcasecmp(object_left->base->name, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        cmp = strncasecmp(object_left->base->name, right_key, strlen(right_key));
        break;
    default:
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    return CMP_MATCH;
}

References ast_channel_snapshot::base, CMP_MATCH, ast_channel_snapshot::flags, ast_channel_snapshot_base::name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by ast_multi_channel_blob_get_channels(), and ast_stasis_channels_init().

channel_snapshot_connected_create()

static struct ast_channel_snapshot_connected * channel_snapshot_connected_create ( struct ast_channel *  chan )

static

Definition at line 384 of file stasis_channels.c.

{
    const char *name = S_COR(ast_channel_connected(chan)->id.name.valid, ast_channel_connected(chan)->id.name.str, "");
    const char *number = S_COR(ast_channel_connected(chan)->id.number.valid, ast_channel_connected(chan)->id.number.str, "");
    size_t name_len = strlen(name) + 1;
    size_t number_len = strlen(number) + 1;
    struct ast_channel_snapshot_connected *snapshot;
 
    snapshot = ao2_alloc_options(sizeof(*snapshot) + name_len + number_len, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!snapshot) {
        return NULL;
    }
 
    strcpy(snapshot->name, name); /* Safe */
    snapshot->number = snapshot->name + name_len;
    ast_copy_string(snapshot->number, number, number_len); /* Safe */
 
    return snapshot;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_channel_connected(), ast_copy_string(), ast_channel_snapshot_connected::name, name, NULL, ast_channel_snapshot_connected::number, and S_COR.

Referenced by ast_channel_snapshot_create().

channel_snapshot_dialplan_create()

static struct ast_channel_snapshot_dialplan * channel_snapshot_dialplan_create ( struct ast_channel *  chan )

static

Definition at line 433 of file stasis_channels.c.

{
    struct ast_channel_snapshot_dialplan *snapshot;
 
    snapshot = ao2_alloc_options(sizeof(*snapshot), channel_snapshot_dialplan_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!snapshot) {
        return NULL;
    }
 
    if (ast_string_field_init(snapshot, 256)) {
        ao2_ref(snapshot, -1);
        return NULL;
    }
 
    if (ast_channel_appl(chan)) {
        ast_string_field_set(snapshot, appl, ast_channel_appl(chan));
    }
    if (ast_channel_data(chan)) {
        ast_string_field_set(snapshot, data, ast_channel_data(chan));
    }
    ast_string_field_set(snapshot, context, ast_channel_context(chan));
    ast_string_field_set(snapshot, exten, ast_channel_exten(chan));
    snapshot->priority = ast_channel_priority(chan);
 
    return snapshot;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_channel_snapshot_dialplan::appl, ast_channel_appl(), ast_channel_context(), ast_channel_data(), ast_channel_exten(), ast_channel_priority(), ast_string_field_init, ast_string_field_set, channel_snapshot_dialplan_dtor(), ast_channel_snapshot_dialplan::context, ast_channel_snapshot_dialplan::data, ast_channel_snapshot_dialplan::exten, NULL, and ast_channel_snapshot_dialplan::priority.

Referenced by ast_channel_snapshot_create().

channel_snapshot_dialplan_dtor()

static void channel_snapshot_dialplan_dtor ( void *  obj )

static

Definition at line 426 of file stasis_channels.c.

{
    struct ast_channel_snapshot_dialplan *snapshot = obj;
 
    ast_string_field_free_memory(snapshot);
}

References ast_string_field_free_memory.

Referenced by channel_snapshot_dialplan_create().

channel_snapshot_dtor()

static void channel_snapshot_dtor ( void *  obj )

static

Definition at line 265 of file stasis_channels.c.

{
    struct ast_channel_snapshot *snapshot = obj;
 
    ao2_cleanup(snapshot->base);
    ao2_cleanup(snapshot->peer);
    ao2_cleanup(snapshot->caller);
    ao2_cleanup(snapshot->connected);
    ao2_cleanup(snapshot->bridge);
    ao2_cleanup(snapshot->dialplan);
    ao2_cleanup(snapshot->hangup);
    ao2_cleanup(snapshot->manager_vars);
    ao2_cleanup(snapshot->ari_vars);
}

References ao2_cleanup, ast_channel_snapshot::ari_vars, ast_channel_snapshot::base, ast_channel_snapshot::bridge, ast_channel_snapshot::caller, ast_channel_snapshot::connected, ast_channel_snapshot::dialplan, ast_channel_snapshot::hangup, ast_channel_snapshot::manager_vars, and ast_channel_snapshot::peer.

Referenced by ast_channel_snapshot_create().

channel_snapshot_hangup_create()

static struct ast_channel_snapshot_hangup * channel_snapshot_hangup_create ( struct ast_channel *  chan )

static

Definition at line 461 of file stasis_channels.c.

{
    const char *hangupsource = S_OR(ast_channel_hangupsource(chan), "");
    struct ast_channel_snapshot_hangup *snapshot;
 
    snapshot = ao2_alloc_options(sizeof(*snapshot) + strlen(hangupsource) + 1, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!snapshot) {
        return NULL;
    }
 
    snapshot->cause = ast_channel_hangupcause(chan);
    snapshot->tech_cause = ast_channel_tech_hangupcause(chan);
    snapshot->source = snapshot->buffer;
    strcpy(snapshot->source, hangupsource); /* Safe */
 
    return snapshot;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_channel_hangupcause(), ast_channel_hangupsource(), ast_channel_tech_hangupcause(), ast_channel_snapshot_hangup::cause, NULL, S_OR, ast_channel_snapshot_hangup::source, and ast_channel_snapshot_hangup::tech_cause.

Referenced by ast_channel_snapshot_create().

channel_snapshot_hash_cb()

static int channel_snapshot_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 163 of file stasis_channels.c.

{
    const struct ast_channel_snapshot *object = obj;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        key = object->base->name;
        break;
    default:
        ast_assert(0);
        return 0;
    }
    return ast_str_case_hash(key);
}

References ast_assert, ast_str_case_hash(), ast_channel_snapshot::base, ast_channel_snapshot::flags, ast_channel_snapshot_base::name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, and OBJ_SEARCH_OBJECT.

Referenced by ast_multi_channel_blob_get_channels(), and ast_stasis_channels_init().

channel_snapshot_peer_create()

static struct ast_channel_snapshot_peer * channel_snapshot_peer_create ( struct ast_channel *  chan )

static

Definition at line 320 of file stasis_channels.c.

{
    const char *linkedid = S_OR(ast_channel_linkedid(chan), "");
    const char *peeraccount = S_OR(ast_channel_peeraccount(chan), "");
    size_t linkedid_len = strlen(linkedid) + 1;
    size_t peeraccount_len = strlen(peeraccount) + 1;
    struct ast_channel_snapshot_peer *snapshot;
 
    snapshot = ao2_alloc_options(sizeof(*snapshot) + linkedid_len + peeraccount_len, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!snapshot) {
        return NULL;
    }
 
    strcpy(snapshot->account, peeraccount); /* Safe */
    snapshot->linkedid = snapshot->account + peeraccount_len;
    ast_copy_string(snapshot->linkedid, linkedid, linkedid_len); /* Safe */
 
    return snapshot;
}

References ast_channel_snapshot_peer::account, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_channel_linkedid(), ast_channel_peeraccount(), ast_copy_string(), ast_channel_snapshot_peer::linkedid, NULL, and S_OR.

Referenced by ast_channel_snapshot_create().

channel_snapshot_uniqueid_cmp_cb()

static int channel_snapshot_uniqueid_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 239 of file stasis_channels.c.

{
    const struct ast_channel_snapshot *object_left = obj;
    const struct ast_channel_snapshot *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = object_right->base->uniqueid;
    case OBJ_SEARCH_KEY:
        cmp = strcasecmp(object_left->base->uniqueid, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        cmp = strncasecmp(object_left->base->uniqueid, right_key, strlen(right_key));
        break;
    default:
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    return CMP_MATCH;
}

References ast_channel_snapshot::base, CMP_MATCH, ast_channel_snapshot::flags, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and ast_channel_snapshot_base::uniqueid.

Referenced by ast_stasis_channels_init().

channel_snapshot_uniqueid_hash_cb()

static int channel_snapshot_uniqueid_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 216 of file stasis_channels.c.

{
    const struct ast_channel_snapshot *object = obj;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        key = object->base->uniqueid;
        break;
    default:
        ast_assert(0);
        return 0;
    }
    return ast_str_case_hash(key);
}

References ast_assert, ast_str_case_hash(), ast_channel_snapshot::base, ast_channel_snapshot::flags, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and ast_channel_snapshot_base::uniqueid.

Referenced by ast_stasis_channels_init().

channel_snapshot_update_create()

static struct ast_channel_snapshot_update * channel_snapshot_update_create ( struct ast_channel *  chan )

static

Definition at line 594 of file stasis_channels.c.

{
    struct ast_channel_snapshot_update *update;
 
    update = ao2_alloc_options(sizeof(*update), channel_snapshot_update_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!update) {
        return NULL;
    }
 
    update->old_snapshot = ao2_bump(ast_channel_snapshot(chan));
    update->new_snapshot = ast_channel_snapshot_create(chan);
    if (!update->new_snapshot) {
        ao2_ref(update, -1);
        return NULL;
    }
 
    return update;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, ast_channel_snapshot_create(), channel_snapshot_update_dtor(), NULL, and update().

Referenced by ast_channel_publish_final_snapshot(), and ast_channel_publish_snapshot().

channel_snapshot_update_dtor()

static void channel_snapshot_update_dtor ( void *  obj )

static

Definition at line 586 of file stasis_channels.c.

{
    struct ast_channel_snapshot_update *update = obj;
 
    ao2_cleanup(update->old_snapshot);
    ao2_cleanup(update->new_snapshot);
}

References ao2_cleanup, and update().

Referenced by channel_snapshot_update_create().

create_channel_blob_message()

static struct stasis_message * create_channel_blob_message ( struct ast_channel_snapshot *  snapshot, struct stasis_message_type *  type, struct ast_json *  blob  )

static

Definition at line 773 of file stasis_channels.c.

{
    struct stasis_message *msg;
    struct ast_channel_blob *obj;
 
    obj = ao2_alloc(sizeof(*obj), channel_blob_dtor);
    if (!obj) {
        return NULL;
    }
 
    if (snapshot) {
        obj->snapshot = snapshot;
        ao2_ref(obj->snapshot, +1);
    }
    if (!blob) {
        blob = ast_json_null();
    }
    obj->blob = ast_json_ref(blob);
 
    msg = stasis_message_create(type, obj);
    ao2_cleanup(obj);
    return msg;
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_json_null(), ast_json_ref(), ast_channel_blob::blob, channel_blob_dtor(), NULL, ast_channel_blob::snapshot, stasis_message_create(), and type.

Referenced by ast_channel_blob_create(), and ast_channel_blob_create_from_cache().

dial_masquerade_breakdown()

static void dial_masquerade_breakdown ( void *  data, struct ast_channel *  old_chan, struct ast_channel *  new_chan  )

static

Definition at line 2139 of file stasis_channels.c.

{
    struct dial_masquerade_datastore *masq_data = data;
    struct dial_target *cur;
 
    ao2_lock(masq_data);
 
    if (!masq_data->caller) {
        ao2_unlock(masq_data);
        return;
    }
 
    if (masq_data->caller == new_chan) {
        /*
         * The caller channel is being masqueraded into.
         * The masquerade is likely because of a blonde transfer.
         */
        ast_debug(1, "Caller channel %s being masqueraded into by %s (is_empty:%d)\n",
            ast_channel_name(old_chan), ast_channel_name(new_chan),
            AST_LIST_EMPTY(&masq_data->dialed_peers));
        AST_LIST_TRAVERSE(&masq_data->dialed_peers, cur, list) {
            ast_channel_publish_dial_internal(old_chan, cur->peer, NULL,
                cur->dialstring, "NOANSWER", NULL);
            ast_channel_publish_dial_internal(new_chan, cur->peer, NULL,
                cur->dialstring, NULL, NULL);
        }
 
        ao2_unlock(masq_data);
        return;
    }
 
    /*
     * One of the peer channels is being masqueraded into.
     * The masquerade is likely because of a call pickup.
     */
    AST_LIST_TRAVERSE(&masq_data->dialed_peers, cur, list) {
        if (cur->peer == new_chan) {
            ast_debug(1, "Peer channel %s being masqueraded into by %s\n",
                ast_channel_name(old_chan), ast_channel_name(new_chan));
            ast_channel_publish_dial_internal(masq_data->caller, old_chan, NULL,
                cur->dialstring, "CANCEL", NULL);
            ast_channel_publish_dial_internal(masq_data->caller, new_chan, NULL,
                cur->dialstring, NULL, NULL);
            break;
        }
    }
 
    ao2_unlock(masq_data);
}

References ao2_lock, ao2_unlock, ast_channel_name(), ast_channel_publish_dial_internal(), ast_debug, AST_LIST_EMPTY, AST_LIST_TRAVERSE, dial_masquerade_datastore::caller, dial_masquerade_datastore::dialed_peers, dial_target::dialstring, dial_target::list, NULL, and dial_target::peer.

dial_masquerade_caller_datastore_destroy()

static void dial_masquerade_caller_datastore_destroy ( void *  data )

static

Definition at line 2072 of file stasis_channels.c.

{
    dial_masquerade_datastore_cleanup(data);
    ao2_ref(data, -1);
}

References ao2_ref, and dial_masquerade_datastore_cleanup().

dial_masquerade_datastore_add()

static struct dial_masquerade_datastore * dial_masquerade_datastore_add ( struct ast_channel *  chan, struct dial_masquerade_datastore *  masq_data  )

static

Definition at line 2234 of file stasis_channels.c.

{
    struct ast_datastore *datastore;
 
    datastore = ast_datastore_alloc(!masq_data ? &dial_masquerade_caller_info : &dial_masquerade_info, NULL);
    if (!datastore) {
        return NULL;
    }
 
    if (!masq_data) {
        masq_data = dial_masquerade_datastore_alloc();
        if (!masq_data) {
            ast_datastore_free(datastore);
            return NULL;
        }
        masq_data->caller = chan;
    }
 
    datastore->data = masq_data;
    ast_channel_datastore_add(chan, datastore);
 
    return masq_data;
}

References ast_channel_datastore_add(), ast_datastore_alloc, ast_datastore_free(), dial_masquerade_datastore::caller, ast_datastore::data, dial_masquerade_caller_info, dial_masquerade_datastore_alloc(), dial_masquerade_info, and NULL.

Referenced by set_dial_masquerade().

dial_masquerade_datastore_alloc()

static struct dial_masquerade_datastore * dial_masquerade_datastore_alloc ( void  )

static

Definition at line 2046 of file stasis_channels.c.

{
    struct dial_masquerade_datastore *masq_data;
 
    masq_data = ao2_alloc(sizeof(struct dial_masquerade_datastore),
        dial_masquerade_datastore_dtor);
    if (!masq_data) {
        return NULL;
    }
    AST_LIST_HEAD_INIT_NOLOCK(&masq_data->dialed_peers);
    return masq_data;
}

References ao2_alloc, AST_LIST_HEAD_INIT_NOLOCK, dial_masquerade_datastore_dtor(), dial_masquerade_datastore::dialed_peers, and NULL.

Referenced by dial_masquerade_datastore_add().

dial_masquerade_datastore_cleanup()

static void dial_masquerade_datastore_cleanup ( struct dial_masquerade_datastore *  masq_data )

static

Definition at line 2012 of file stasis_channels.c.

{
    struct dial_target *cur;
 
    while ((cur = AST_LIST_REMOVE_HEAD(&masq_data->dialed_peers, list))) {
        dial_target_free(cur);
    }
}

References AST_LIST_REMOVE_HEAD, dial_target_free(), dial_masquerade_datastore::dialed_peers, and dial_target::list.

Referenced by dial_masquerade_caller_datastore_destroy(), dial_masquerade_datastore_dtor(), dial_masquerade_datastore_remove_chan(), and dial_masquerade_fixup().

dial_masquerade_datastore_destroy()

static void dial_masquerade_datastore_destroy ( void *  data )

static

Definition at line 2063 of file stasis_channels.c.

{
    ao2_ref(data, -1);
}

References ao2_ref.

dial_masquerade_datastore_dtor()

static void dial_masquerade_datastore_dtor ( void *  vdoomed )

static

Definition at line 2041 of file stasis_channels.c.

{
    dial_masquerade_datastore_cleanup(vdoomed);
}

References dial_masquerade_datastore_cleanup().

Referenced by dial_masquerade_datastore_alloc().

dial_masquerade_datastore_find()

static struct ast_datastore * dial_masquerade_datastore_find ( struct ast_channel *  chan )

static

Definition at line 2211 of file stasis_channels.c.

{
    struct ast_datastore *datastore;
 
    datastore = ast_channel_datastore_find(chan, &dial_masquerade_info, NULL);
    if (!datastore) {
        datastore = ast_channel_datastore_find(chan, &dial_masquerade_caller_info, NULL);
    }
 
    return datastore;
}

References ast_channel_datastore_find(), dial_masquerade_caller_info, dial_masquerade_info, and NULL.

Referenced by dial_masquerade_fixup(), remove_dial_masquerade(), remove_dial_masquerade_caller(), and set_dial_masquerade().

dial_masquerade_datastore_remove_chan()

static void dial_masquerade_datastore_remove_chan ( struct dial_masquerade_datastore *  masq_data, struct ast_channel *  chan  )

static

Definition at line 2021 of file stasis_channels.c.

{
    struct dial_target *cur;
 
    ao2_lock(masq_data);
    if (masq_data->caller == chan) {
        dial_masquerade_datastore_cleanup(masq_data);
    } else {
        AST_LIST_TRAVERSE_SAFE_BEGIN(&masq_data->dialed_peers, cur, list) {
            if (cur->peer == chan) {
                AST_LIST_REMOVE_CURRENT(list);
                dial_target_free(cur);
                break;
            }
        }
        AST_LIST_TRAVERSE_SAFE_END;
    }
    ao2_unlock(masq_data);
}

References ao2_lock, ao2_unlock, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, dial_masquerade_datastore::caller, dial_masquerade_datastore_cleanup(), dial_target_free(), dial_masquerade_datastore::dialed_peers, dial_target::list, and dial_target::peer.

Referenced by remove_dial_masquerade(), remove_dial_masquerade_caller(), and set_dial_masquerade().

dial_masquerade_fixup()

static void dial_masquerade_fixup ( void *  data, struct ast_channel *  old_chan, struct ast_channel *  new_chan  )

static

Definition at line 2080 of file stasis_channels.c.

{
    struct dial_masquerade_datastore *masq_data = data;
    struct dial_target *cur;
    struct ast_datastore *datastore;
 
    ao2_lock(masq_data);
    if (!masq_data->caller) {
        /* Nothing to do but remove the datastore */
    } else if (masq_data->caller == old_chan) {
        /* The caller channel is being masqueraded out. */
        ast_debug(1, "Caller channel %s being masqueraded out to %s (is_empty:%d)\n",
            ast_channel_name(new_chan), ast_channel_name(old_chan),
            AST_LIST_EMPTY(&masq_data->dialed_peers));
        AST_LIST_TRAVERSE(&masq_data->dialed_peers, cur, list) {
            ast_channel_publish_dial_internal(new_chan, cur->peer, NULL,
                cur->dialstring, "NOANSWER", NULL);
            ast_channel_publish_dial_internal(old_chan, cur->peer, NULL,
                cur->dialstring, NULL, NULL);
        }
        dial_masquerade_datastore_cleanup(masq_data);
    } else {
        /* One of the peer channels is being masqueraded out. */
        AST_LIST_TRAVERSE_SAFE_BEGIN(&masq_data->dialed_peers, cur, list) {
            if (cur->peer == old_chan) {
                ast_debug(1, "Peer channel %s being masqueraded out to %s\n",
                    ast_channel_name(new_chan), ast_channel_name(old_chan));
                ast_channel_publish_dial_internal(masq_data->caller, new_chan, NULL,
                    cur->dialstring, "CANCEL", NULL);
                ast_channel_publish_dial_internal(masq_data->caller, old_chan, NULL,
                    cur->dialstring, NULL, NULL);
 
                AST_LIST_REMOVE_CURRENT(list);
                dial_target_free(cur);
                break;
            }
        }
        AST_LIST_TRAVERSE_SAFE_END;
    }
    ao2_unlock(masq_data);
 
    /* Remove the datastore from the channel. */
    datastore = dial_masquerade_datastore_find(old_chan);
    if (!datastore) {
        return;
    }
    ast_channel_datastore_remove(old_chan, datastore);
    ast_datastore_free(datastore);
}

References ao2_lock, ao2_unlock, ast_channel_datastore_remove(), ast_channel_name(), ast_channel_publish_dial_internal(), ast_datastore_free(), ast_debug, AST_LIST_EMPTY, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, dial_masquerade_datastore::caller, dial_masquerade_datastore_cleanup(), dial_masquerade_datastore_find(), dial_target_free(), dial_masquerade_datastore::dialed_peers, dial_target::dialstring, NULL, and dial_target::peer.

dial_target_free()

static void dial_target_free ( struct dial_target *  doomed )

static

Definition at line 1990 of file stasis_channels.c.

{
    if (!doomed) {
        return;
    }
    ast_free(doomed->dialstring);
    ast_channel_cleanup(doomed->peer);
    ast_free(doomed);
}

References ast_channel_cleanup, ast_free, dial_target::dialstring, and dial_target::peer.

Referenced by dial_masquerade_datastore_cleanup(), dial_masquerade_datastore_remove_chan(), and dial_masquerade_fixup().

dial_to_json()

static struct ast_json * dial_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1498 of file stasis_channels.c.

{
    struct ast_multi_channel_blob *payload = stasis_message_data(message);
    struct ast_json *blob = ast_multi_channel_blob_get_json(payload);
    const char *dialstatus =
        ast_json_string_get(ast_json_object_get(blob, "dialstatus"));
    const char *forward =
        ast_json_string_get(ast_json_object_get(blob, "forward"));
    const char *dialstring =
        ast_json_string_get(ast_json_object_get(blob, "dialstring"));
    struct ast_json *caller_json = ast_channel_snapshot_to_json(ast_multi_channel_blob_get_channel(payload, "caller"), sanitize);
    struct ast_json *peer_json = ast_channel_snapshot_to_json(ast_multi_channel_blob_get_channel(payload, "peer"), sanitize);
    struct ast_json *forwarded_json = ast_channel_snapshot_to_json(ast_multi_channel_blob_get_channel(payload, "forwarded"), sanitize);
    struct ast_json *json;
    const struct timeval *tv = stasis_message_timestamp(message);
    int res = 0;
 
    json = ast_json_pack("{s: s, s: o, s: s, s: s, s: s}",
        "type", "Dial",
        "timestamp", ast_json_timeval(*tv, NULL),
        "dialstatus", dialstatus,
        "forward", forward,
        "dialstring", dialstring);
    if (!json) {
        ast_json_unref(caller_json);
        ast_json_unref(peer_json);
        ast_json_unref(forwarded_json);
        return NULL;
    }
 
    if (caller_json) {
        res |= ast_json_object_set(json, "caller", caller_json);
    }
    if (peer_json) {
        res |= ast_json_object_set(json, "peer", peer_json);
    }
    if (forwarded_json) {
        res |= ast_json_object_set(json, "forwarded", forwarded_json);
    }
 
    if (res) {
        ast_json_unref(json);
        return NULL;
    }
 
    return json;
}

References ast_channel_snapshot_to_json(), ast_json_object_get(), ast_json_object_set(), ast_json_pack(), ast_json_string_get(), ast_json_timeval(), ast_json_unref(), ast_multi_channel_blob_get_channel(), ast_multi_channel_blob_get_json(), NULL, stasis_message_data(), and stasis_message_timestamp().

dtmf_end_to_json()

static struct ast_json * dtmf_end_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1450 of file stasis_channels.c.

{
    struct ast_channel_blob *channel_blob = stasis_message_data(message);
    struct ast_json *blob = channel_blob->blob;
    struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
    const char *direction =
        ast_json_string_get(ast_json_object_get(blob, "direction"));
    const char *digit =
        ast_json_string_get(ast_json_object_get(blob, "digit"));
    long duration_ms =
        ast_json_integer_get(ast_json_object_get(blob, "duration_ms"));
    const struct timeval *tv = stasis_message_timestamp(message);
    struct ast_json *json_channel;
 
    /* Only present received DTMF end events as JSON */
    if (strcasecmp("Received", direction) != 0) {
        return NULL;
    }
 
    json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
    if (!json_channel) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: s, s: I, s: o}",
        "type", "ChannelDtmfReceived",
        "timestamp", ast_json_timeval(*tv, NULL),
        "digit", digit,
        "duration_ms", (ast_json_int_t)duration_ms,
        "channel", json_channel);
}

References ast_channel_snapshot_to_json(), ast_json_integer_get(), ast_json_object_get(), ast_json_pack(), ast_json_string_get(), ast_json_timeval(), ast_channel_blob::blob, digit, NULL, ast_channel_blob::snapshot, stasis_message_data(), and stasis_message_timestamp().

hangup_request_to_json()

static struct ast_json * hangup_request_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1491 of file stasis_channels.c.

{
    return channel_blob_to_json(message, "ChannelHangupRequest", sanitize);
}

References channel_blob_to_json().

hold_to_json()

static struct ast_json * hold_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1600 of file stasis_channels.c.

{
    struct ast_channel_blob *channel_blob = stasis_message_data(message);
    struct ast_json *blob = channel_blob->blob;
    struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
    const char *musicclass = ast_json_string_get(ast_json_object_get(blob, "musicclass"));
    const struct timeval *tv = stasis_message_timestamp(message);
    struct ast_json *json_channel;
 
    json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
    if (!json_channel) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: s, s: o}",
        "type", "ChannelHold",
        "timestamp", ast_json_timeval(*tv, NULL),
        "musicclass", S_OR(musicclass, "N/A"),
        "channel", json_channel);
}

References ast_channel_snapshot_to_json(), ast_json_object_get(), ast_json_pack(), ast_json_string_get(), ast_json_timeval(), ast_channel_blob::blob, NULL, S_OR, ast_channel_blob::snapshot, stasis_message_data(), and stasis_message_timestamp().

multi_channel_blob_dtor()

static void multi_channel_blob_dtor ( void *  obj )

static

Definition at line 901 of file stasis_channels.c.

{
    struct ast_multi_channel_blob *multi_blob = obj;
 
    ao2_cleanup(multi_blob->channel_snapshots);
    ast_json_unref(multi_blob->blob);
}

References ao2_cleanup, ast_json_unref(), ast_multi_channel_blob::blob, and ast_multi_channel_blob::channel_snapshots.

Referenced by ast_multi_channel_blob_create().

publish_message_for_channel_topics()

static void publish_message_for_channel_topics ( struct stasis_message *  message, struct ast_channel *  chan  )

static

Definition at line 614 of file stasis_channels.c.

{
    if (chan) {
        stasis_publish(ast_channel_topic(chan), message);
    } else {
        stasis_publish(ast_channel_topic_all(), message);
    }
}

References ast_channel_topic(), ast_channel_topic_all(), and stasis_publish().

Referenced by ast_channel_publish_dial_internal().

remove_dial_masquerade()

static void remove_dial_masquerade ( struct ast_channel *  peer )

static

Definition at line 2338 of file stasis_channels.c.

{
    struct ast_datastore *datastore;
    struct dial_masquerade_datastore *masq_data;
 
    datastore = dial_masquerade_datastore_find(peer);
    if (!datastore) {
        return;
    }
 
    masq_data = datastore->data;
    if (masq_data) {
        dial_masquerade_datastore_remove_chan(masq_data, peer);
    }
 
    ast_channel_datastore_remove(peer, datastore);
    ast_datastore_free(datastore);
}

References ast_channel_datastore_remove(), ast_datastore_free(), ast_datastore::data, dial_masquerade_datastore_find(), and dial_masquerade_datastore_remove_chan().

Referenced by ast_channel_publish_dial_forward().

remove_dial_masquerade_caller()

static void remove_dial_masquerade_caller ( struct ast_channel *  caller )

static

Definition at line 2357 of file stasis_channels.c.

{
    struct ast_datastore *datastore;
    struct dial_masquerade_datastore *masq_data;
 
    datastore = dial_masquerade_datastore_find(caller);
    if (!datastore) {
        return;
    }
 
    masq_data = datastore->data;
    if (!masq_data || !AST_LIST_EMPTY(&masq_data->dialed_peers)) {
        return;
    }
 
    dial_masquerade_datastore_remove_chan(masq_data, caller);
 
    ast_channel_datastore_remove(caller, datastore);
    ast_datastore_free(datastore);
}

References ast_channel_datastore_remove(), ast_datastore_free(), AST_LIST_EMPTY, dial_masquerade_datastore::caller, ast_datastore::data, dial_masquerade_datastore_find(), dial_masquerade_datastore_remove_chan(), and dial_masquerade_datastore::dialed_peers.

Referenced by ast_channel_publish_dial_forward().

set_dial_masquerade()

static int set_dial_masquerade ( struct ast_channel *  caller, struct ast_channel *  peer, const char *  dialstring  )

static

Definition at line 2259 of file stasis_channels.c.

{
    struct ast_datastore *datastore;
    struct dial_masquerade_datastore *masq_data;
    struct dial_target *target;
 
    /* Find or create caller datastore */
    datastore = dial_masquerade_datastore_find(caller);
    if (!datastore) {
        masq_data = dial_masquerade_datastore_add(caller, NULL);
    } else {
        masq_data = datastore->data;
    }
    if (!masq_data) {
        return -1;
    }
    ao2_ref(masq_data, +1);
 
    /*
     * Someone likely forgot to do an ast_channel_publish_dial()
     * or ast_channel_publish_dial_forward() with a final dial
     * status on the channel.
     */
    ast_assert(masq_data->caller == caller);
 
    /* Create peer target to put into datastore */
    target = ast_calloc(1, sizeof(*target));
    if (!target) {
        ao2_ref(masq_data, -1);
        return -1;
    }
    if (dialstring) {
        target->dialstring = ast_strdup(dialstring);
        if (!target->dialstring) {
            ast_free(target);
            ao2_ref(masq_data, -1);
            return -1;
        }
    }
    target->peer = ast_channel_ref(peer);
 
    /* Put peer target into datastore */
    ao2_lock(masq_data);
    dial_masquerade_datastore_remove_chan(masq_data, peer);
    AST_LIST_INSERT_HEAD(&masq_data->dialed_peers, target, list);
    ao2_unlock(masq_data);
 
    datastore = dial_masquerade_datastore_find(peer);
    if (datastore) {
        if (datastore->data == masq_data) {
            /*
             * Peer already had the datastore for this dial masquerade.
             * This was a redundant peer dial masquerade setup.
             */
            ao2_ref(masq_data, -1);
            return 0;
        }
 
        /* Something is wrong.  Try to fix if the assert doesn't abort. */
        ast_assert(0);
 
        /* Remove the stale dial masquerade datastore */
        dial_masquerade_datastore_remove_chan(datastore->data, peer);
        ast_channel_datastore_remove(peer, datastore);
        ast_datastore_free(datastore);
    }
 
    /* Create the peer dial masquerade datastore */
    if (dial_masquerade_datastore_add(peer, masq_data)) {
        /* Success */
        return 0;
    }
 
    /* Failed to create the peer datastore */
    dial_masquerade_datastore_remove_chan(masq_data, peer);
    ao2_ref(masq_data, -1);
    return -1;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_assert, ast_calloc, ast_channel_datastore_remove(), ast_channel_ref, ast_datastore_free(), ast_free, AST_LIST_INSERT_HEAD, ast_strdup, dial_masquerade_datastore::caller, ast_datastore::data, dial_masquerade_datastore_add(), dial_masquerade_datastore_find(), dial_masquerade_datastore_remove_chan(), dial_masquerade_datastore::dialed_peers, dial_target::dialstring, dial_target::list, NULL, and dial_target::peer.

Referenced by ast_channel_publish_dial_forward().

stasis_channels_cleanup()

static void stasis_channels_cleanup ( void  )

static

Definition at line 1885 of file stasis_channels.c.

{
    ao2_cleanup(channel_topic_all);
    channel_topic_all = NULL;
    ao2_cleanup(channel_cache);
    channel_cache = NULL;
    ao2_cleanup(channel_cache_by_name);
    channel_cache_by_name = NULL;
 
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_snapshot_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_dial_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_varset_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_hangup_request_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_masquerade_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_dtmf_begin_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_dtmf_end_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_flash_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_wink_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_hold_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_unhold_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_chanspy_start_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_chanspy_stop_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_fax_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_hangup_handler_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_moh_start_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_moh_stop_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_mixmonitor_start_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_mixmonitor_stop_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_mixmonitor_mute_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_agent_login_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_agent_logoff_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_talking_start);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_talking_stop);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_tone_detect);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_channel_transfer_request_type);
}

References ao2_cleanup, ast_channel_agent_login_type(), ast_channel_agent_logoff_type(), ast_channel_chanspy_start_type(), ast_channel_chanspy_stop_type(), ast_channel_dial_type(), ast_channel_dtmf_begin_type(), ast_channel_dtmf_end_type(), ast_channel_fax_type(), ast_channel_flash_type(), ast_channel_hangup_handler_type(), ast_channel_hangup_request_type(), ast_channel_hold_type(), ast_channel_masquerade_type(), ast_channel_mixmonitor_mute_type(), ast_channel_mixmonitor_start_type(), ast_channel_mixmonitor_stop_type(), ast_channel_moh_start_type(), ast_channel_moh_stop_type(), ast_channel_snapshot_type(), ast_channel_talking_start(), ast_channel_talking_stop(), ast_channel_tone_detect(), ast_channel_transfer_request_type(), ast_channel_unhold_type(), ast_channel_varset_type(), ast_channel_wink_type(), channel_cache, channel_cache_by_name, channel_topic_all, NULL, and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by ast_stasis_channels_init().

STASIS_MESSAGE_TYPE_DEFN() [1/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_agent_login_type	,
		.	to_ami = agent_login_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN() [2/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_agent_logoff_type	,
		.	to_ami = agent_logoff_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN() [3/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_chanspy_start_type

)

STASIS_MESSAGE_TYPE_DEFN() [4/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_chanspy_stop_type

)

STASIS_MESSAGE_TYPE_DEFN() [5/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_dial_type	,
		.	to_json = dial_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [6/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_dtmf_begin_type

)

STASIS_MESSAGE_TYPE_DEFN() [7/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_dtmf_end_type	,
		.	to_json = dtmf_end_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [8/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_fax_type

)

STASIS_MESSAGE_TYPE_DEFN() [9/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_flash_type

)

STASIS_MESSAGE_TYPE_DEFN() [10/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_hangup_handler_type

)

STASIS_MESSAGE_TYPE_DEFN() [11/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_hangup_request_type	,
		.	to_json = hangup_request_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [12/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_hold_type	,
		.	to_json = hold_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [13/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_masquerade_type

)

STASIS_MESSAGE_TYPE_DEFN() [14/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_mixmonitor_mute_type

)

STASIS_MESSAGE_TYPE_DEFN() [15/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_mixmonitor_start_type

)

STASIS_MESSAGE_TYPE_DEFN() [16/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_mixmonitor_stop_type

)

STASIS_MESSAGE_TYPE_DEFN() [17/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_moh_start_type

)

STASIS_MESSAGE_TYPE_DEFN() [18/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_moh_stop_type

)

STASIS_MESSAGE_TYPE_DEFN() [19/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_snapshot_type

)

Define channel message types.

STASIS_MESSAGE_TYPE_DEFN() [20/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_talking_start	,
		.	to_ami = talking_start_to_ami,
		.	to_json = talking_start_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [21/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_talking_stop	,
		.	to_ami = talking_stop_to_ami,
		.	to_json = talking_stop_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [22/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_tone_detect	,
		.	to_json = tone_detect_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [23/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_transfer_request_type	,
		.	to_json = ari_transfer_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [24/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_unhold_type	,
		.	to_json = unhold_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [25/26]

STASIS_MESSAGE_TYPE_DEFN	(	ast_channel_varset_type	,
		.	to_ami = varset_to_ami,
		.	to_json = varset_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [26/26]

STASIS_MESSAGE_TYPE_DEFN

(

ast_channel_wink_type

)

state2str()

static const char * state2str ( enum ast_control_transfer  state )

static

Definition at line 1648 of file stasis_channels.c.

                                                              {
    switch (state) {
    case AST_TRANSFER_FAILED:
        return "channel_declined";
    case AST_TRANSFER_SUCCESS:
        return "channel_answered";
    case AST_TRANSFER_PROGRESS:
        return "channel_progress";
    case AST_TRANSFER_UNAVAILABLE:
        return "channel_declined";
    default:
        return "invalid";
    }
}

References AST_TRANSFER_FAILED, AST_TRANSFER_PROGRESS, AST_TRANSFER_SUCCESS, and AST_TRANSFER_UNAVAILABLE.

Referenced by ari_transfer_to_json().

talking_start_to_ami()

static struct ast_manager_event_blob * talking_start_to_ami ( struct stasis_message *  msg )

static

Definition at line 1548 of file stasis_channels.c.

{
    struct ast_str *channel_string;
    struct ast_channel_blob *obj = stasis_message_data(msg);
    struct ast_manager_event_blob *blob;
 
    channel_string = ast_manager_build_channel_state_string(obj->snapshot);
    if (!channel_string) {
        return NULL;
    }
 
    blob = ast_manager_event_blob_create(EVENT_FLAG_CALL, "ChannelTalkingStart",
                                         "%s", ast_str_buffer(channel_string));
    ast_free(channel_string);
 
    return blob;
}

References ast_free, ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_str_buffer(), EVENT_FLAG_CALL, NULL, ast_channel_blob::snapshot, and stasis_message_data().

talking_start_to_json()

static struct ast_json * talking_start_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1566 of file stasis_channels.c.

{
    return channel_blob_to_json(message, "ChannelTalkingStarted", sanitize);
}

References channel_blob_to_json().

talking_stop_to_ami()

static struct ast_manager_event_blob * talking_stop_to_ami ( struct stasis_message *  msg )

static

Definition at line 1572 of file stasis_channels.c.

{
    struct ast_str *channel_string;
    struct ast_channel_blob *obj = stasis_message_data(msg);
    int duration = ast_json_integer_get(ast_json_object_get(obj->blob, "duration"));
    struct ast_manager_event_blob *blob;
 
    channel_string = ast_manager_build_channel_state_string(obj->snapshot);
    if (!channel_string) {
        return NULL;
    }
 
    blob = ast_manager_event_blob_create(EVENT_FLAG_CALL, "ChannelTalkingStop",
                                         "%s"
                                         "Duration: %d\r\n",
                                         ast_str_buffer(channel_string),
                                         duration);
    ast_free(channel_string);
 
    return blob;
}

References ast_free, ast_json_integer_get(), ast_json_object_get(), ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_str_buffer(), ast_channel_blob::blob, EVENT_FLAG_CALL, NULL, ast_channel_blob::snapshot, and stasis_message_data().

talking_stop_to_json()

static struct ast_json * talking_stop_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1594 of file stasis_channels.c.

{
    return channel_blob_to_json(message, "ChannelTalkingFinished", sanitize);
}

References channel_blob_to_json().

tone_detect_to_json()

static struct ast_json * tone_detect_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1623 of file stasis_channels.c.

{
    return channel_blob_to_json(message, "ChannelToneDetected", sanitize);
}

References channel_blob_to_json().

unhold_to_json()

static struct ast_json * unhold_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1629 of file stasis_channels.c.

{
    struct ast_channel_blob *channel_blob = stasis_message_data(message);
    struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
    const struct timeval *tv = stasis_message_timestamp(message);
    struct ast_json *json_channel;
 
    json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
    if (!json_channel) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: o}",
        "type", "ChannelUnhold",
        "timestamp", ast_json_timeval(*tv, NULL),
        "channel", json_channel);
}

References ast_channel_snapshot_to_json(), ast_json_pack(), ast_json_timeval(), NULL, ast_channel_blob::snapshot, stasis_message_data(), and stasis_message_timestamp().

varset_to_ami()

static struct ast_manager_event_blob * varset_to_ami ( struct stasis_message *  msg )

static

Definition at line 1231 of file stasis_channels.c.

{
    struct ast_str *channel_event_string;
    struct ast_channel_blob *obj = stasis_message_data(msg);
    const char *variable =
        ast_json_string_get(ast_json_object_get(obj->blob, "variable"));
    char *value;
    struct ast_manager_event_blob *ev;
 
    value = ast_escape_c_alloc(ast_json_string_get(ast_json_object_get(obj->blob,
        "value")));
    if (!value) {
        return NULL;
    }
 
    if (obj->snapshot) {
        channel_event_string = ast_manager_build_channel_state_string(obj->snapshot);
    } else {
        channel_event_string = ast_str_create(35);
        ast_str_set(&channel_event_string, 0,
            "Channel: none\r\n"
            "Uniqueid: none\r\n");
    }
    if (!channel_event_string) {
        ast_free(value);
        return NULL;
    }
 
    ev = ast_manager_event_blob_create(EVENT_FLAG_DIALPLAN, "VarSet",
        "%s"
        "Variable: %s\r\n"
        "Value: %s\r\n",
        ast_str_buffer(channel_event_string), variable, value);
    ast_free(channel_event_string);
    ast_free(value);
    return ev;
}

References ast_escape_c_alloc(), ast_free, ast_json_object_get(), ast_json_string_get(), ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_channel_blob::blob, EVENT_FLAG_DIALPLAN, NULL, ast_channel_blob::snapshot, stasis_message_data(), and value.

varset_to_json()

static struct ast_json * varset_to_json ( struct stasis_message *  message, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 1484 of file stasis_channels.c.

{
    return channel_blob_to_json(message, "ChannelVarset", sanitize);
}

References channel_blob_to_json().

Variable Documentation

channel_cache

struct ao2_container* channel_cache

static

Definition at line 141 of file stasis_channels.c.

Referenced by ast_channel_cache_all(), ast_channel_publish_final_snapshot(), ast_channel_publish_snapshot(), ast_channel_snapshot_get_latest(), ast_stasis_channels_init(), channels_scrape_cb(), and stasis_channels_cleanup().

channel_cache_by_name

struct ao2_container* channel_cache_by_name

static

Definition at line 142 of file stasis_channels.c.

Referenced by ast_channel_cache_by_name(), ast_channel_publish_final_snapshot(), ast_channel_publish_snapshot(), ast_channel_snapshot_get_latest_by_name(), ast_stasis_channels_init(), and stasis_channels_cleanup().

channel_topic_all

struct stasis_topic* channel_topic_all

static

Definition at line 140 of file stasis_channels.c.

Referenced by ast_channel_topic_all(), ast_stasis_channels_init(), and stasis_channels_cleanup().

dial_masquerade_caller_info

const struct ast_datastore_info dial_masquerade_caller_info

static

Definition at line 2196 of file stasis_channels.c.

                                                                     {
    .type = "stasis-chan-dial-masq",
    .destroy = dial_masquerade_caller_datastore_destroy,
    .chan_fixup = dial_masquerade_fixup,
    .chan_breakdown = dial_masquerade_breakdown,
};

Referenced by dial_masquerade_datastore_add(), and dial_masquerade_datastore_find().

dial_masquerade_info

const struct ast_datastore_info dial_masquerade_info

static

Definition at line 2189 of file stasis_channels.c.

                                                              {
    .type = "stasis-chan-dial-masq",
    .destroy = dial_masquerade_datastore_destroy,
    .chan_fixup = dial_masquerade_fixup,
    .chan_breakdown = dial_masquerade_breakdown,
};

Referenced by dial_masquerade_datastore_add(), and dial_masquerade_datastore_find().