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 1273 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 1293 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 1761 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 1667 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;
}

◆ 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 1776 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 1387 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 1366 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 1397 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 1315 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;
}

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(), send_broadcast_event(), simple_bridge_channel_event(), simple_channel_event(), stasis_app_claim_channel(), 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 1926 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;
}

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 1407 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 2143 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 2076 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 2238 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 2050 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 2016 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 2067 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 2045 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 2215 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 2025 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 2084 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 1994 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 1502 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 1454 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 1495 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 1604 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 2342 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 2361 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 2263 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 1889 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);
}

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 1652 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 1552 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 1570 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 1576 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 1598 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 1627 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 1633 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 1235 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 1488 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 2200 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 2193 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().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ NUM_MULTI_CHANNEL_BLOB_BUCKETS

Function Documentation

◆ agent_login_to_ami()

◆ agent_logoff_to_ami()

◆ ari_transfer_dtor()

◆ ari_transfer_to_json()

◆ ast_ari_transfer_message_create()

◆ ast_channel_publish_dial_internal()

◆ ast_channel_snapshot_caller_id_equal()

◆ ast_channel_snapshot_cep_equal()

◆ ast_channel_snapshot_connected_line_equal()

◆ ast_channel_snapshot_to_json()

◆ ast_stasis_channels_init()

◆ channel_blob_dtor()

◆ channel_blob_to_json()

◆ channel_role_cmp_cb()

◆ channel_role_hash_cb()

◆ channel_role_snapshot_dtor()

◆ channel_snapshot_base_create()

◆ channel_snapshot_base_dtor()

◆ channel_snapshot_bridge_create()

◆ channel_snapshot_caller_create()

◆ channel_snapshot_caller_dtor()

◆ channel_snapshot_cmp_cb()

◆ channel_snapshot_connected_create()

◆ channel_snapshot_dialplan_create()

◆ channel_snapshot_dialplan_dtor()

◆ channel_snapshot_dtor()

◆ channel_snapshot_hangup_create()

◆ channel_snapshot_hash_cb()

◆ channel_snapshot_peer_create()

◆ channel_snapshot_uniqueid_cmp_cb()

◆ channel_snapshot_uniqueid_hash_cb()

◆ channel_snapshot_update_create()

◆ channel_snapshot_update_dtor()

◆ create_channel_blob_message()

◆ dial_masquerade_breakdown()

◆ dial_masquerade_caller_datastore_destroy()

◆ dial_masquerade_datastore_add()

◆ dial_masquerade_datastore_alloc()

◆ dial_masquerade_datastore_cleanup()

◆ dial_masquerade_datastore_destroy()

◆ dial_masquerade_datastore_dtor()

◆ dial_masquerade_datastore_find()

◆ dial_masquerade_datastore_remove_chan()

◆ dial_masquerade_fixup()

◆ dial_target_free()

◆ dial_to_json()

◆ dtmf_end_to_json()

◆ hangup_request_to_json()

◆ hold_to_json()

◆ multi_channel_blob_dtor()

◆ publish_message_for_channel_topics()

◆ remove_dial_masquerade()

◆ remove_dial_masquerade_caller()

◆ set_dial_masquerade()

◆ stasis_channels_cleanup()

◆ STASIS_MESSAGE_TYPE_DEFN() [1/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [2/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [3/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [4/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [5/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [6/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [7/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [8/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [9/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [10/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [11/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [12/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [13/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [14/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [15/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [16/26]

◆ STASIS_MESSAGE_TYPE_DEFN() [17/26]