core_unreal.h File Reference

Unreal channel derivative framework. More...

#include "asterisk/astobj2.h"
#include "asterisk/channel.h"
#include "asterisk/bridge.h"
#include "asterisk/abstract_jb.h"

Include dependency graph for core_unreal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_unreal_pvt
	The base pvt structure for local channel derivatives. More...
struct	ast_unreal_pvt_callbacks
	Callbacks that can be provided by concrete implementations of the unreal channel driver that will be called when events occur in the unreal layer. More...

Macros
#define	AST_UNREAL_CARETAKER_THREAD   (1 << 0)
#define	AST_UNREAL_IS_OUTBOUND(a, b)   ((a) == (b)->chan ? 1 : 0)
#define	AST_UNREAL_MOH_INTERCEPT   (1 << 2)
#define	AST_UNREAL_NO_OPTIMIZATION   (1 << 1)
#define	AST_UNREAL_OPTIMIZE_BEGUN   (1 << 3)

Enumerations
enum	ast_unreal_channel_indicator { AST_UNREAL_OWNER , AST_UNREAL_CHAN }

Functions
struct ast_unreal_pvt *	ast_unreal_alloc (size_t size, ao2_destructor_fn destructor, struct ast_format_cap *cap)
	Allocate the base unreal struct for a derivative.
struct ast_unreal_pvt *	ast_unreal_alloc_stream_topology (size_t size, ao2_destructor_fn destructor, struct ast_stream_topology *topology)
	Allocate the base unreal struct for a derivative.
int	ast_unreal_answer (struct ast_channel *ast)
void	ast_unreal_call_setup (struct ast_channel *semi1, struct ast_channel *semi2)
	Setup unreal owner and chan channels before initiating call.
int	ast_unreal_channel_push_to_bridge (struct ast_channel *ast, struct ast_bridge *bridge, unsigned int flags)
	Push the semi2 unreal channel into a bridge from either member of the unreal pair.
void	ast_unreal_destructor (void *vdoomed)
	struct ast_unreal_pvt destructor.
int	ast_unreal_digit_begin (struct ast_channel *ast, char digit)
int	ast_unreal_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
int	ast_unreal_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
int	ast_unreal_hangup (struct ast_unreal_pvt *p, struct ast_channel *ast)
	Hangup one end (maybe both ends) of an unreal channel derivative.
int	ast_unreal_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
void	ast_unreal_lock_all (struct ast_unreal_pvt *p, struct ast_channel **outchan, struct ast_channel **outowner)
	Send an unreal pvt in with no locks held and get all locks.
struct ast_channel *	ast_unreal_new_channels (struct ast_unreal_pvt *p, const struct ast_channel_tech *tech, int semi1_state, int semi2_state, const char *exten, const char *context, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid)
	Create the semi1 and semi2 unreal channels.
int	ast_unreal_queryoption (struct ast_channel *ast, int option, void *data, int *datalen)
struct ast_frame *	ast_unreal_read (struct ast_channel *ast)
int	ast_unreal_sendhtml (struct ast_channel *ast, int subclass, const char *data, int datalen)
int	ast_unreal_sendtext (struct ast_channel *ast, const char *text)
int	ast_unreal_setoption (struct ast_channel *chan, int option, void *data, int datalen)
int	ast_unreal_write (struct ast_channel *ast, struct ast_frame *f)
int	ast_unreal_write_stream (struct ast_channel *ast, int stream_num, struct ast_frame *f)

Detailed Description

Unreal channel derivative framework.

Author

Richard Mudgett rmudg.nosp@m.ett@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

See Also:

• CREDITS

Definition in file core_unreal.h.

Macro Definition Documentation

AST_UNREAL_CARETAKER_THREAD

#define AST_UNREAL_CARETAKER_THREAD   (1 << 0)

The ;2 side launched a PBX, was pushed into a bridge, or was masqueraded into an application.

Definition at line 107 of file core_unreal.h.

AST_UNREAL_IS_OUTBOUND

#define AST_UNREAL_IS_OUTBOUND	(		a,
			b
	)		((a) == (b)->chan ? 1 : 0)

Definition at line 105 of file core_unreal.h.

AST_UNREAL_MOH_INTERCEPT

#define AST_UNREAL_MOH_INTERCEPT   (1 << 2)

Intercept and act on hold/unhold control frames

Definition at line 109 of file core_unreal.h.

AST_UNREAL_NO_OPTIMIZATION

#define AST_UNREAL_NO_OPTIMIZATION   (1 << 1)

Do not optimize out the unreal channels

Definition at line 108 of file core_unreal.h.

AST_UNREAL_OPTIMIZE_BEGUN

#define AST_UNREAL_OPTIMIZE_BEGUN   (1 << 3)

Indicates that an optimization attempt has been started

Definition at line 110 of file core_unreal.h.

Enumeration Type Documentation

ast_unreal_channel_indicator

enum ast_unreal_channel_indicator

Enumerator
AST_UNREAL_OWNER
AST_UNREAL_CHAN

Definition at line 49 of file core_unreal.h.

                                  {
    AST_UNREAL_OWNER,
    AST_UNREAL_CHAN,
};

Function Documentation

ast_unreal_alloc()

struct ast_unreal_pvt * ast_unreal_alloc	(	size_t	size,
		ao2_destructor_fn	destructor,
		struct ast_format_cap *	cap
	)

Allocate the base unreal struct for a derivative.

Since

12.0.0

Parameters

size	Size of the unreal struct to allocate.
destructor	Destructor callback.
cap	Format capabilities to give the unreal private struct.

Returns

pvt on success.

Return values

NULL

on error.

Definition at line 1110 of file core_unreal.c.

{
    struct ast_stream_topology *topology;
    struct ast_unreal_pvt *unreal;
 
    topology = ast_stream_topology_create_from_format_cap(cap);
    if (!topology) {
        return NULL;
    }
 
    unreal = ast_unreal_alloc_stream_topology(size, destructor, topology);
 
    ast_stream_topology_free(topology);
 
    return unreal;
}

References ast_stream_topology_create_from_format_cap(), ast_stream_topology_free(), ast_unreal_alloc_stream_topology(), and NULL.

Referenced by announce_request(), and media_request_helper().

ast_unreal_alloc_stream_topology()

struct ast_unreal_pvt * ast_unreal_alloc_stream_topology	(	size_t	size,
		ao2_destructor_fn	destructor,
		struct ast_stream_topology *	topology
	)

Allocate the base unreal struct for a derivative.

Since

16.12.0

17.6.0

Parameters

size	Size of the unreal struct to allocate.
destructor	Destructor callback.
topology

Returns

pvt on success.

Return values

NULL

on error.

Definition at line 1127 of file core_unreal.c.

{
    struct ast_unreal_pvt *unreal;
 
    static const struct ast_jb_conf jb_conf = {
        .flags = 0,
        .max_size = -1,
        .resync_threshold = -1,
        .impl = "",
        .target_extra = -1,
    };
 
    unreal = ao2_alloc(size, destructor);
    if (!unreal) {
        return NULL;
    }
 
    unreal->reqtopology = ast_stream_topology_clone(topology);
    if (!unreal->reqtopology) {
        ao2_ref(unreal, -1);
        return NULL;
    }
 
    unreal->reqcap = ast_stream_topology_get_formats(topology);
    if (!unreal->reqcap) {
        ao2_ref(unreal, -1);
        return NULL;
    }
 
    memcpy(&unreal->jb_conf, &jb_conf, sizeof(unreal->jb_conf));
 
    return unreal;
}

References ao2_alloc, ao2_ref, ast_stream_topology_clone(), ast_stream_topology_get_formats(), ast_unreal_pvt::jb_conf, NULL, ast_unreal_pvt::reqcap, ast_unreal_pvt::reqtopology, and jb_conf::resync_threshold.

Referenced by ast_unreal_alloc(), and local_alloc().

ast_unreal_answer()

int ast_unreal_answer

(

struct ast_channel *

ast

)

Unreal channel framework struct ast_channel_tech.answer callback

Definition at line 254 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
    int isoutbound;
    int res = -1;
 
    if (!p) {
        return -1;
    }
 
    ao2_ref(p, 1);
    ao2_lock(p);
    isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
    if (isoutbound) {
        /* Pass along answer since somebody answered us */
        struct ast_frame answer = { AST_FRAME_CONTROL, { AST_CONTROL_ANSWER } };
 
        res = unreal_queue_frame(p, isoutbound, &answer, ast, 1);
    } else {
        ast_log(LOG_WARNING, "Huh?  %s is being asked to answer?\n",
            ast_channel_name(ast));
    }
    ao2_unlock(p);
    ao2_ref(p, -1);
    return res;
}

References answer(), ao2_lock, ao2_ref, ao2_unlock, ast_channel_name(), ast_channel_tech_pvt(), AST_CONTROL_ANSWER, AST_FRAME_CONTROL, ast_log, AST_UNREAL_IS_OUTBOUND, LOG_WARNING, and unreal_queue_frame().

ast_unreal_call_setup()

void ast_unreal_call_setup	(	struct ast_channel *	semi1,
		struct ast_channel *	semi2
	)

Setup unreal owner and chan channels before initiating call.

Since

12.0.0

Parameters

semi1	Owner channel of unreal channel pair.
semi2	Outgoing channel of unreal channel pair.

Note

On entry, the semi1 and semi2 channels are already locked.

Definition at line 870 of file core_unreal.c.

{
    struct ast_var_t *varptr;
    struct ast_var_t *clone_var;
 
    ast_channel_stage_snapshot(semi2);
 
    /*
     * Note that cid_num and cid_name aren't passed in the
     * ast_channel_alloc calls in ast_unreal_new_channels().  It's
     * done here instead.
     */
    ast_party_redirecting_copy(ast_channel_redirecting(semi2), ast_channel_redirecting(semi1));
 
    ast_party_dialed_copy(ast_channel_dialed(semi2), ast_channel_dialed(semi1));
 
    /* Crossover the CallerID and conected-line to cross the unreal bridge. */
    ast_connected_line_copy_to_caller(ast_channel_caller(semi2), ast_channel_connected(semi1));
    ast_connected_line_copy_from_caller(ast_channel_connected(semi2), ast_channel_caller(semi1));
 
    ast_channel_adsicpe_set(semi2, ast_channel_adsicpe(semi1));
    ast_channel_language_set(semi2, ast_channel_language(semi1));
    ast_channel_musicclass_set(semi2, ast_channel_musicclass(semi1));
    ast_channel_parkinglot_set(semi2, ast_channel_parkinglot(semi1));
 
    /* Crossover the accountcode and peeraccount to cross the unreal bridge. */
    ast_channel_accountcode_set(semi2, ast_channel_peeraccount(semi1));
    ast_channel_peeraccount_set(semi2, ast_channel_accountcode(semi1));
 
    ast_channel_cc_params_init(semi2, ast_channel_get_cc_config_params(semi1));
 
    /*
     * Make sure we inherit the AST_CAUSE_ANSWERED_ELSEWHERE if it's
     * set on the queue/dial call request in the dialplan.
     */
    if (ast_channel_hangupcause(semi1) == AST_CAUSE_ANSWERED_ELSEWHERE) {
        ast_channel_hangupcause_set(semi2, AST_CAUSE_ANSWERED_ELSEWHERE);
    }
 
    /*
     * Copy the channel variables from the semi1 channel to the
     * outgoing channel.
     *
     * Note that due to certain assumptions, they MUST be in the
     * same order.
     */
    AST_LIST_TRAVERSE(ast_channel_varshead(semi1), varptr, entries) {
        clone_var = ast_var_assign(varptr->name, varptr->value);
        if (clone_var) {
            AST_LIST_INSERT_TAIL(ast_channel_varshead(semi2), clone_var, entries);
            ast_channel_publish_varset(semi2, ast_var_full_name(clone_var),
                ast_var_value(clone_var));
        }
    }
    ast_channel_datastore_inherit(semi1, semi2);
 
    ast_channel_stage_snapshot_done(semi2);
}

References AST_CAUSE_ANSWERED_ELSEWHERE, ast_channel_accountcode(), ast_channel_adsicpe_set(), ast_channel_caller(), ast_channel_cc_params_init(), ast_channel_connected(), ast_channel_datastore_inherit(), ast_channel_dialed(), ast_channel_get_cc_config_params(), ast_channel_hangupcause(), ast_channel_hangupcause_set(), ast_channel_language(), ast_channel_musicclass(), ast_channel_parkinglot(), ast_channel_peeraccount(), ast_channel_publish_varset(), ast_channel_redirecting(), ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_varshead(), ast_connected_line_copy_from_caller(), ast_connected_line_copy_to_caller(), AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_party_dialed_copy(), ast_party_redirecting_copy(), ast_var_assign, ast_var_full_name(), ast_var_value(), ast_var_t::entries, ast_var_t::name, and ast_var_t::value.

Referenced by local_call().

ast_unreal_channel_push_to_bridge()

int ast_unreal_channel_push_to_bridge	(	struct ast_channel *	ast,
		struct ast_bridge *	bridge,
		unsigned int	flags
	)

Push the semi2 unreal channel into a bridge from either member of the unreal pair.

Since

12.0.0

Parameters

ast	A member of the unreal channel being pushed
bridge	Which bridge we want to push the channel to
flags	Feature flags to be set on the bridge channel.

Return values

0	if the channel is successfully imparted onto the bridge
-1	on failure

Note

This is equivalent to ast_call() on unreal based channel drivers that are designed to use it instead.

Definition at line 929 of file core_unreal.c.

{
    struct ast_bridge_features *features;
    struct ast_channel *chan;
    struct ast_channel *owner;
    ast_callid bridge_callid;
    RAII_VAR(struct ast_unreal_pvt *, p, NULL, ao2_cleanup);
 
    ast_bridge_lock(bridge);
    bridge_callid = bridge->callid;
    ast_bridge_unlock(bridge);
 
    {
        SCOPED_CHANNELLOCK(lock, ast);
        p = ast_channel_tech_pvt(ast);
        if (!p) {
            return -1;
        }
        ao2_ref(p, +1);
    }
 
    {
        SCOPED_AO2LOCK(lock, p);
        chan = p->chan;
        if (!chan) {
            return -1;
        }
 
        owner = p->owner;
        if (!owner) {
            return -1;
        }
 
        ast_channel_ref(chan);
        ast_channel_ref(owner);
    }
 
    if (bridge_callid) {
        ast_callid chan_callid;
        ast_callid owner_callid;
 
        /* chan side call ID setting */
        ast_channel_lock(chan);
 
        chan_callid = ast_channel_callid(chan);
        if (!chan_callid) {
            ast_channel_callid_set(chan, bridge_callid);
        }
        ast_channel_unlock(chan);
 
        /* owner side call ID setting */
        ast_channel_lock(owner);
 
        owner_callid = ast_channel_callid(owner);
        if (!owner_callid) {
            ast_channel_callid_set(owner, bridge_callid);
        }
 
        ast_channel_unlock(owner);
    }
 
    /* We are done with the owner now that its call ID matches the bridge */
    ast_channel_unref(owner);
    owner = NULL;
 
    features = ast_bridge_features_new();
    if (!features) {
        ast_channel_unref(chan);
        return -1;
    }
 
    ast_set_flag(&features->feature_flags, flags);
 
    /* Impart the semi2 channel into the bridge */
    if (ast_bridge_impart(bridge, chan, NULL, features,
        AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
        ast_channel_unref(chan);
        return -1;
    }
 
    /* The bridge thread now controls the chan ref from the ast_unreal_pvt */
    ao2_lock(p);
    ast_set_flag(p, AST_UNREAL_CARETAKER_THREAD);
    ao2_unlock(p);
 
    ast_channel_unref(chan);
 
    return 0;
}

References ao2_cleanup, ao2_lock, ao2_ref, ao2_unlock, ast_bridge_features_new(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_INDEPENDENT, ast_bridge_lock, ast_bridge_unlock, ast_channel_callid(), ast_channel_callid_set(), ast_channel_lock, ast_channel_ref, ast_channel_tech_pvt(), ast_channel_unlock, ast_channel_unref, ast_set_flag, AST_UNREAL_CARETAKER_THREAD, ast_channel::bridge, ast_bridge::callid, ast_bridge_features::feature_flags, ast_channel::flags, lock, NULL, RAII_VAR, SCOPED_AO2LOCK, and SCOPED_CHANNELLOCK.

Referenced by ari_bridges_play_new(), ast_ari_bridges_record(), and bridge_moh_create().

ast_unreal_destructor()

void ast_unreal_destructor

(

void *

vdoomed

)

struct ast_unreal_pvt destructor.

Since

12.0.0

Parameters

vdoomed

Object to destroy.

Definition at line 1098 of file core_unreal.c.

{
    struct ast_unreal_pvt *doomed = vdoomed;
 
    ao2_cleanup(doomed->reqcap);
    doomed->reqcap = NULL;
    ast_stream_topology_free(doomed->reqtopology);
    doomed->reqtopology = NULL;
    ao2_cleanup(doomed->owner_old_topology);
    ao2_cleanup(doomed->chan_old_topology);
}

References ao2_cleanup, ast_stream_topology_free(), ast_unreal_pvt::chan_old_topology, NULL, ast_unreal_pvt::owner_old_topology, ast_unreal_pvt::reqcap, and ast_unreal_pvt::reqtopology.

Referenced by announce_pvt_destructor(), local_pvt_destructor(), and media_request_helper().

ast_unreal_digit_begin()

int ast_unreal_digit_begin	(	struct ast_channel *	ast,
		char	digit
	)

Unreal channel framework struct ast_channel_tech.send_digit_begin callback

Definition at line 779 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
    int res = -1;
    struct ast_frame f = { AST_FRAME_DTMF_BEGIN, };
    int isoutbound;
 
    if (!p) {
        return -1;
    }
 
    ao2_ref(p, 1); /* ref for unreal_queue_frame */
    ao2_lock(p);
    isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
    f.subclass.integer = digit;
    res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
    ao2_unlock(p);
    ao2_ref(p, -1);
 
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_tech_pvt(), AST_FRAME_DTMF_BEGIN, AST_UNREAL_IS_OUTBOUND, digit, ast_frame_subclass::integer, ast_frame::subclass, and unreal_queue_frame().

ast_unreal_digit_end()

int ast_unreal_digit_end	(	struct ast_channel *	ast,
		char	digit,
		unsigned int	duration
	)

Unreal channel framework struct ast_channel_tech.send_digit_end callback

Definition at line 801 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
    int res = -1;
    struct ast_frame f = { AST_FRAME_DTMF_END, };
    int isoutbound;
 
    if (!p) {
        return -1;
    }
 
    ao2_ref(p, 1); /* ref for unreal_queue_frame */
    ao2_lock(p);
    isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
    f.subclass.integer = digit;
    f.len = duration;
    res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
    ao2_unlock(p);
    ao2_ref(p, -1);
 
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_tech_pvt(), AST_FRAME_DTMF_END, AST_UNREAL_IS_OUTBOUND, digit, ast_frame_subclass::integer, ast_frame::len, ast_frame::subclass, and unreal_queue_frame().

ast_unreal_fixup()

int ast_unreal_fixup	(	struct ast_channel *	oldchan,
		struct ast_channel *	newchan
	)

Unreal channel framework struct ast_channel_tech.fixup callback

Definition at line 369 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(newchan);
    struct ast_bridge *bridge_owner;
    struct ast_bridge *bridge_chan;
 
    if (!p) {
        return -1;
    }
 
    ao2_lock(p);
 
    if ((p->owner != oldchan) && (p->chan != oldchan)) {
        ast_log(LOG_WARNING, "Old channel %p wasn't %p or %p\n", oldchan, p->owner, p->chan);
        ao2_unlock(p);
        return -1;
    }
    if (p->owner == oldchan) {
        p->owner = newchan;
    } else {
        p->chan = newchan;
    }
 
    if (ast_check_hangup(newchan) || !p->owner || !p->chan) {
        ao2_unlock(p);
        return 0;
    }
 
    /* Do not let a masquerade cause an unreal channel to be bridged to itself! */
    bridge_owner = ast_channel_internal_bridge(p->owner);
    bridge_chan = ast_channel_internal_bridge(p->chan);
    if (bridge_owner && bridge_owner == bridge_chan) {
        ast_log(LOG_WARNING, "You can not bridge an unreal channel (%s) to itself!\n",
            ast_channel_name(newchan));
        ao2_unlock(p);
        ast_queue_hangup(newchan);
        return -1;
    }
 
    ao2_unlock(p);
    return 0;
}

References ao2_lock, ao2_unlock, ast_channel_internal_bridge(), ast_channel_name(), ast_channel_tech_pvt(), ast_check_hangup(), ast_log, ast_queue_hangup(), ast_unreal_pvt::chan, LOG_WARNING, and ast_unreal_pvt::owner.

ast_unreal_hangup()

int ast_unreal_hangup	(	struct ast_unreal_pvt *	p,
		struct ast_channel *	ast
	)

Hangup one end (maybe both ends) of an unreal channel derivative.

Since

12.0.0

Parameters

p	Private channel struct (reffed)
ast	Channel being hung up. (locked)

Note

Common hangup code for unreal channels. Derived channels will need to deal with any additional resources.

Return values

0	on success.
-1	on error.

Definition at line 1019 of file core_unreal.c.

{
    int hangup_chan = 0;
    int res = 0;
    int cause;
    struct ast_channel *owner = NULL;
    struct ast_channel *chan = NULL;
 
    /* the pvt isn't going anywhere, it has a ref */
    ast_channel_unlock(ast);
 
    /* lock everything */
    ast_unreal_lock_all(p, &chan, &owner);
 
    if (ast != chan && ast != owner) {
        res = -1;
        goto unreal_hangup_cleanup;
    }
 
    cause = ast_channel_hangupcause(ast);
 
    if (ast == p->chan) {
        /* Outgoing side is hanging up. */
        ast_clear_flag(p, AST_UNREAL_CARETAKER_THREAD);
        p->chan = NULL;
        if (p->owner) {
            const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
 
            if (status) {
                ast_channel_hangupcause_set(p->owner, cause);
                pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
            }
            ast_queue_hangup_with_cause(p->owner, cause);
        }
    } else {
        /* Owner side is hanging up. */
        p->owner = NULL;
        if (p->chan) {
            if (cause == AST_CAUSE_ANSWERED_ELSEWHERE) {
                ast_channel_hangupcause_set(p->chan, AST_CAUSE_ANSWERED_ELSEWHERE);
                ast_debug(2, "%s has AST_CAUSE_ANSWERED_ELSEWHERE set.\n",
                    ast_channel_name(p->chan));
            }
            if (!ast_test_flag(p, AST_UNREAL_CARETAKER_THREAD)) {
                /*
                 * Need to actually hangup p->chan since nothing else is taking
                 * care of it.
                 */
                hangup_chan = 1;
            } else {
                ast_queue_hangup_with_cause(p->chan, cause);
            }
        }
    }
 
    /* this is one of our locked channels, doesn't matter which */
    ast_channel_tech_pvt_set(ast, NULL);
    ao2_ref(p, -1);
 
unreal_hangup_cleanup:
    ao2_unlock(p);
    if (owner) {
        ast_channel_unlock(owner);
        ast_channel_unref(owner);
    }
    if (chan) {
        ast_channel_unlock(chan);
        if (hangup_chan) {
            ast_hangup(chan);
        }
        ast_channel_unref(chan);
    }
 
    /* leave with the channel locked that came in */
    ast_channel_lock(ast);
 
    return res;
}

References ao2_ref, ao2_unlock, AST_CAUSE_ANSWERED_ELSEWHERE, ast_channel_hangupcause(), ast_channel_hangupcause_set(), ast_channel_lock, ast_channel_name(), ast_channel_tech_pvt_set(), ast_channel_unlock, ast_channel_unref, ast_clear_flag, ast_debug, ast_hangup(), ast_queue_hangup_with_cause(), ast_test_flag, AST_UNREAL_CARETAKER_THREAD, ast_unreal_lock_all(), ast_unreal_pvt::chan, NULL, ast_unreal_pvt::owner, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), and status.

Referenced by announce_hangup(), local_hangup(), and media_hangup().

ast_unreal_indicate()

int ast_unreal_indicate	(	struct ast_channel *	ast,
		int	condition,
		const void *	data,
		size_t	datalen
	)

Unreal channel framework struct ast_channel_tech.indicate callback

Definition at line 622 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
    int res = 0;
    struct ast_channel *chan = NULL;
    struct ast_channel *owner = NULL;
    const struct ast_control_t38_parameters *parameters;
 
    if (!p) {
        return -1;
    }
 
    ao2_ref(p, 1); /* ref for unreal_queue_frame */
 
    switch (condition) {
    case AST_CONTROL_MASQUERADE_NOTIFY:
        /*
         * Always block this because this is the channel being
         * masqueraded; not anything down the chain.
         */
        break;
    case AST_CONTROL_CONNECTED_LINE:
    case AST_CONTROL_REDIRECTING:
        res = unreal_colp_redirect_indicate(p, ast, condition);
        break;
    case AST_CONTROL_HOLD:
        if (ast_test_flag(p, AST_UNREAL_MOH_INTERCEPT)) {
            ast_moh_start(ast, data, NULL);
            break;
        }
        res = unreal_queue_indicate(p, ast, condition, data, datalen);
        break;
    case AST_CONTROL_UNHOLD:
        if (ast_test_flag(p, AST_UNREAL_MOH_INTERCEPT)) {
            ast_moh_stop(ast);
            break;
        }
        res = unreal_queue_indicate(p, ast, condition, data, datalen);
        break;
    case AST_CONTROL_RINGING:
        /* Don't queue ringing frames if the channel is not in a "ring" state. Otherwise,
         * the real channel on the other end will likely start a playtones generator. It is
         * possible that this playtones generator will never be stopped under certain
         * circumstances.
         */
        if (ast_channel_state(ast) == AST_STATE_RING) {
            res = unreal_queue_indicate(p, ast, condition, data, datalen);
        } else {
            res = -1;
        }
        break;
    case AST_CONTROL_PVT_CAUSE_CODE:
        /* Return -1 so that asterisk core will correctly set up hangupcauses. */
        unreal_queue_indicate(p, ast, condition, data, datalen);
        res = -1;
        break;
    case AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE:
        if (ast_channel_is_multistream(ast)) {
            res = unreal_colp_stream_topology_request_change(p, ast, data);
        }
        break;
    case AST_CONTROL_T38_PARAMETERS:
        parameters = data;
        if (parameters->request_response == AST_T38_NEGOTIATED) {
            struct ast_stream *stream;
            struct ast_stream_topology *new_topology;
 
            stream = ast_stream_alloc("local_fax", AST_MEDIA_TYPE_IMAGE);
            if (!stream) {
                ast_log(LOG_ERROR, "Failed to allocate memory for stream.\n");
                res = -1;
                break;
            }
            new_topology = ast_stream_topology_alloc();
            if (!new_topology) {
                ast_log(LOG_ERROR, "Failed to allocate memory for stream topology.\n");
                ast_free(stream);
                res = -1;
                break;
            }
            ast_stream_topology_append_stream(new_topology, stream);
 
            /*
             * Lock both parts of the local channel so we can store their topologies and replace them with
             * one that has a stream with type IMAGE. We can just hold the reference on the unreal_pvt
             * structure and bump it, then steal the ref later when we are restoring the topology.
             *
             * We use ast_unreal_lock_all here because we don't know if the ;1 or ;2 side will get the
             * signaling and we need to be sure that the locking order is the same to prevent possible
             * deadlocks.
             */
            ast_channel_unlock(ast);
            ast_unreal_lock_all(p, &chan, &owner);
 
            if (owner) {
                p->owner_old_topology = ao2_bump(ast_channel_get_stream_topology(owner));
                ast_channel_set_stream_topology(owner, new_topology);
            }
 
            if (chan) {
                p->chan_old_topology = ao2_bump(ast_channel_get_stream_topology(chan));
 
                /* Bump the ref for new_topology, since it will be used by both sides of the local channel */
                ao2_ref(new_topology, +1);
                ast_channel_set_stream_topology(chan, new_topology);
            }
 
            ao2_unlock(p);
            ast_channel_lock(ast);
        } else if (parameters->request_response == AST_T38_TERMINATED) {
            /*
             * Lock both parts of the local channel so we can restore their topologies to the original.
             * The topology should be on the unreal_pvt structure, with a ref that we can steal. Same
             * conditions as above.
             */
            ast_channel_unlock(ast);
            ast_unreal_lock_all(p, &chan, &owner);
 
            if (owner) {
                ast_channel_set_stream_topology(owner, p->owner_old_topology);
                p->owner_old_topology = NULL;
            }
 
            if (chan) {
                ast_channel_set_stream_topology(chan, p->chan_old_topology);
                p->chan_old_topology = NULL;
            }
 
            ao2_unlock(p);
            ast_channel_lock(ast);
        }
 
        /*
         * We unlock ast_unreal_pvt in the above conditionals since there's no way to
         * tell if it's been unlocked already or not when we get to this point, but
         * if either of these are not NULL, we know that they are locked and need to
         * unlock them.
         */
        if (owner) {
            ast_channel_unlock(owner);
            ast_channel_unref(owner);
        }
 
        if (chan) {
            ast_channel_unlock(chan);
            ast_channel_unref(chan);
        }
        /* Fall through for all T38 conditions */
    default:
        res = unreal_queue_indicate(p, ast, condition, data, datalen);
        break;
    }
 
    ao2_ref(p, -1);
    return res;
}

References ao2_bump, ao2_ref, ao2_unlock, ast_channel_get_stream_topology(), ast_channel_is_multistream(), ast_channel_lock, ast_channel_set_stream_topology(), ast_channel_tech_pvt(), ast_channel_unlock, ast_channel_unref, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HOLD, AST_CONTROL_MASQUERADE_NOTIFY, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_REDIRECTING, AST_CONTROL_RINGING, AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, AST_CONTROL_T38_PARAMETERS, AST_CONTROL_UNHOLD, ast_free, ast_log, AST_MEDIA_TYPE_IMAGE, ast_moh_start(), ast_moh_stop(), AST_STATE_RING, ast_stream_alloc(), ast_stream_topology_alloc(), ast_stream_topology_append_stream(), AST_T38_NEGOTIATED, AST_T38_TERMINATED, ast_test_flag, ast_unreal_lock_all(), AST_UNREAL_MOH_INTERCEPT, ast_unreal_pvt::chan_old_topology, LOG_ERROR, NULL, ast_unreal_pvt::owner_old_topology, ast_control_t38_parameters::request_response, unreal_colp_redirect_indicate(), unreal_colp_stream_topology_request_change(), and unreal_queue_indicate().

ast_unreal_lock_all()

void ast_unreal_lock_all	(	struct ast_unreal_pvt *	p,
		struct ast_channel **	outchan,
		struct ast_channel **	outowner
	)

Send an unreal pvt in with no locks held and get all locks.

Note

NO locks should be held prior to calling this function

The pvt must have a ref held before calling this function

if outchan or outowner is set != NULL after calling this function those channels are locked and reffed.

Batman.

Definition at line 47 of file core_unreal.c.

{
    struct ast_channel *chan = NULL;
    struct ast_channel *owner = NULL;
 
    ao2_lock(p);
    for (;;) {
        if (p->chan) {
            chan = p->chan;
            ast_channel_ref(chan);
        }
        if (p->owner) {
            owner = p->owner;
            ast_channel_ref(owner);
        }
        ao2_unlock(p);
 
        /* if we don't have both channels, then this is very easy */
        if (!owner || !chan) {
            if (owner) {
                ast_channel_lock(owner);
            } else if(chan) {
                ast_channel_lock(chan);
            }
        } else {
            /* lock both channels first, then get the pvt lock */
            ast_channel_lock_both(chan, owner);
        }
        ao2_lock(p);
 
        /* Now that we have all the locks, validate that nothing changed */
        if (p->owner != owner || p->chan != chan) {
            if (owner) {
                ast_channel_unlock(owner);
                owner = ast_channel_unref(owner);
            }
            if (chan) {
                ast_channel_unlock(chan);
                chan = ast_channel_unref(chan);
            }
            continue;
        }
 
        break;
    }
    *outowner = p->owner;
    *outchan = p->chan;
}

References ao2_lock, ao2_unlock, ast_channel_lock, ast_channel_lock_both, ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_unreal_pvt::chan, NULL, and ast_unreal_pvt::owner.

Referenced by ast_local_lock_all(), ast_unreal_hangup(), ast_unreal_indicate(), local_call(), publish_local_bridge_message(), stasis_app_channel_unreal_set_internal(), unreal_colp_redirect_indicate(), and unreal_colp_stream_topology_request_change().

ast_unreal_new_channels()

struct ast_channel * ast_unreal_new_channels	(	struct ast_unreal_pvt *	p,
		const struct ast_channel_tech *	tech,
		int	semi1_state,
		int	semi2_state,
		const char *	exten,
		const char *	context,
		const struct ast_assigned_ids *	assignedids,
		const struct ast_channel *	requestor,
		ast_callid	callid
	)

Create the semi1 and semi2 unreal channels.

Since

12.0.0

Parameters

p	Unreal channel private struct.
tech	Channel technology to use.
semi1_state	State to start the semi1(owner) channel in.
semi2_state	State to start the semi2(outgoing chan) channel in.
exten	Exten to start the chennels in. (NULL if s)
context	Context to start the channels in. (NULL if default)
assignedids
requestor	Channel requesting creation. (NULL if none)
callid	Thread callid to use.

Returns

semi1_channel on success.

Return values

NULL

on error.

Definition at line 1161 of file core_unreal.c.

{
    struct ast_channel *owner;
    struct ast_channel *chan;
    RAII_VAR(struct ast_format *, fmt, NULL, ao2_cleanup);
    struct ast_assigned_ids id1 = {NULL, NULL};
    struct ast_assigned_ids id2 = {NULL, NULL};
    int generated_seqno = ast_atomic_fetchadd_int((int *) &name_sequence, +1);
    int i;
    RAII_VAR(struct ast_stream_topology *, chan_topology, NULL, ast_stream_topology_free);
    struct ast_stream *stream;
 
    /* set unique ids for the two channels */
    if (assignedids && !ast_strlen_zero(assignedids->uniqueid)) {
        id1.uniqueid = assignedids->uniqueid;
        id2.uniqueid = assignedids->uniqueid2;
    }
 
    /* if id1 given but not id2, use default of id1;2 */
    if (id1.uniqueid && ast_strlen_zero(id2.uniqueid)) {
        char *uniqueid2;
 
        uniqueid2 = ast_alloca(strlen(id1.uniqueid) + 3);
        strcpy(uniqueid2, id1.uniqueid);/* Safe */
        strcat(uniqueid2, ";2");/* Safe */
        id2.uniqueid = uniqueid2;
    }
 
    /* We need to create a topology to place on the second channel, as we can't
     * share a single one between both.
     */
    chan_topology = ast_stream_topology_clone(p->reqtopology);
    if (!chan_topology) {
        return NULL;
    }
 
    for (i = 0; i < ast_stream_topology_get_count(chan_topology); ++i) {
        stream = ast_stream_topology_get_stream(chan_topology, i);
        /* We need to make sure that the ;2 channel has the opposite stream topology
         * of the first channel if the stream is one-way. I.e. if the first channel
         * is recvonly, the second channel has to be sendonly and vice versa.
         */
        if (ast_stream_get_state(stream) == AST_STREAM_STATE_RECVONLY) {
            ast_stream_set_state(stream, AST_STREAM_STATE_SENDONLY);
        } else if (ast_stream_get_state(stream) == AST_STREAM_STATE_SENDONLY) {
            ast_stream_set_state(stream, AST_STREAM_STATE_RECVONLY);
        }
    }
 
    /*
     * Allocate two new Asterisk channels
     *
     * Make sure that the ;2 channel gets the same linkedid as ;1.
     * You can't pass linkedid to both allocations since if linkedid
     * isn't set, then each channel will generate its own linkedid.
     */
    owner = ast_channel_alloc(1, semi1_state, NULL, NULL, NULL,
        exten, context, &id1, requestor, 0,
        "%s/%s-%08x;1", tech->type, p->name, (unsigned)generated_seqno);
    if (!owner) {
        ast_log(LOG_WARNING, "Unable to allocate owner channel structure\n");
        return NULL;
    }
 
    if (callid) {
        ast_channel_callid_set(owner, callid);
    }
 
    ast_channel_tech_set(owner, tech);
    ao2_ref(p, +1);
    ast_channel_tech_pvt_set(owner, p);
 
    ast_channel_nativeformats_set(owner, p->reqcap);
 
    if (ast_channel_is_multistream(owner)) {
        ast_channel_set_stream_topology(owner, p->reqtopology);
        p->reqtopology = NULL;
    }
 
    /* Determine our read/write format and set it on each channel */
    fmt = ast_format_cap_get_format(p->reqcap, 0);
    if (!fmt) {
        ast_channel_tech_pvt_set(owner, NULL);
        ao2_ref(p, -1);
        ast_channel_unlock(owner);
        ast_channel_release(owner);
        return NULL;
    }
 
    ast_channel_set_writeformat(owner, fmt);
    ast_channel_set_rawwriteformat(owner, fmt);
    ast_channel_set_readformat(owner, fmt);
    ast_channel_set_rawreadformat(owner, fmt);
 
    ast_set_flag(ast_channel_flags(owner), AST_FLAG_DISABLE_DEVSTATE_CACHE);
 
    ast_jb_configure(owner, &p->jb_conf);
 
    if (ast_channel_cc_params_init(owner, requestor
        ? ast_channel_get_cc_config_params((struct ast_channel *) requestor) : NULL)) {
        ast_channel_tech_pvt_set(owner, NULL);
        ao2_ref(p, -1);
        ast_channel_tech_pvt_set(owner, NULL);
        ast_channel_unlock(owner);
        ast_channel_release(owner);
        return NULL;
    }
 
    p->owner = owner;
    ast_channel_unlock(owner);
 
    chan = ast_channel_alloc(1, semi2_state, NULL, NULL, NULL,
        exten, context, &id2, owner, 0,
        "%s/%s-%08x;2", tech->type, p->name, (unsigned)generated_seqno);
    if (!chan) {
        ast_log(LOG_WARNING, "Unable to allocate chan channel structure\n");
        ast_channel_tech_pvt_set(owner, NULL);
        ao2_ref(p, -1);
        ast_channel_tech_pvt_set(owner, NULL);
        ast_channel_release(owner);
        return NULL;
    }
 
    if (callid) {
        ast_channel_callid_set(chan, callid);
    }
 
    ast_channel_tech_set(chan, tech);
    ao2_ref(p, +1);
    ast_channel_tech_pvt_set(chan, p);
 
    ast_channel_nativeformats_set(chan, p->reqcap);
 
    if (ast_channel_is_multistream(chan)) {
        ast_channel_set_stream_topology(chan, ao2_bump(chan_topology));
    }
 
    /* Format was already determined when setting up owner */
    ast_channel_set_writeformat(chan, fmt);
    ast_channel_set_rawwriteformat(chan, fmt);
    ast_channel_set_readformat(chan, fmt);
    ast_channel_set_rawreadformat(chan, fmt);
 
    ast_set_flag(ast_channel_flags(chan), AST_FLAG_DISABLE_DEVSTATE_CACHE);
 
    p->chan = chan;
    ast_channel_unlock(chan);
 
    return owner;
}

References ao2_bump, ao2_cleanup, ao2_ref, ast_alloca, ast_atomic_fetchadd_int(), ast_channel_alloc, ast_channel_callid_set(), ast_channel_cc_params_init(), ast_channel_flags(), ast_channel_get_cc_config_params(), ast_channel_is_multistream(), ast_channel_nativeformats_set(), ast_channel_release(), ast_channel_set_rawreadformat(), ast_channel_set_rawwriteformat(), ast_channel_set_readformat(), ast_channel_set_stream_topology(), ast_channel_set_writeformat(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_unlock, AST_FLAG_DISABLE_DEVSTATE_CACHE, ast_format_cap_get_format(), ast_jb_configure(), ast_log, ast_set_flag, ast_stream_get_state(), ast_stream_set_state(), AST_STREAM_STATE_RECVONLY, AST_STREAM_STATE_SENDONLY, ast_stream_topology_clone(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_strlen_zero(), ast_unreal_pvt::chan, ast_unreal_pvt::jb_conf, LOG_WARNING, ast_unreal_pvt::name, name_sequence, NULL, ast_unreal_pvt::owner, RAII_VAR, ast_unreal_pvt::reqcap, ast_unreal_pvt::reqtopology, ast_channel_tech::type, ast_assigned_ids::uniqueid, and ast_assigned_ids::uniqueid2.

Referenced by announce_request(), local_request_with_stream_topology(), and media_request_helper().

ast_unreal_queryoption()

int ast_unreal_queryoption	(	struct ast_channel *	ast,
		int	option,
		void *	data,
		int *	datalen
	)

Unreal channel framework struct ast_channel_tech.queryoption callback

Definition at line 166 of file core_unreal.c.

{
    struct ast_unreal_pvt *p;
    struct ast_channel *peer;
    struct ast_channel *other;
    int res = 0;
 
    if (option != AST_OPTION_T38_STATE) {
        /* AST_OPTION_T38_STATE is the only supported option at this time */
        return -1;
    }
 
    /* for some reason the channel is not locked in channel.c when this function is called */
    if (!(p = ast_channel_tech_pvt(ast))) {
        return -1;
    }
 
    ao2_lock(p);
    other = AST_UNREAL_IS_OUTBOUND(ast, p) ? p->owner : p->chan;
    if (!other) {
        ao2_unlock(p);
        return -1;
    }
    ast_channel_ref(other);
    ao2_unlock(p);
    ast_channel_unlock(ast); /* Held when called, unlock before locking another channel */
 
    peer = ast_channel_bridge_peer(other);
    if (peer) {
        res = ast_channel_queryoption(peer, option, data, datalen, 0);
        ast_channel_unref(peer);
    }
    ast_channel_unref(other);
    ast_channel_lock(ast); /* Lock back before we leave */
 
    return res;
}

References ao2_lock, ao2_unlock, ast_channel_bridge_peer(), ast_channel_lock, ast_channel_queryoption(), ast_channel_ref, ast_channel_tech_pvt(), ast_channel_unlock, ast_channel_unref, AST_OPTION_T38_STATE, AST_UNREAL_IS_OUTBOUND, ast_unreal_pvt::chan, ast_channel::data, and ast_unreal_pvt::owner.

ast_unreal_read()

struct ast_frame * ast_unreal_read

(

struct ast_channel *

ast

)

Unreal channel framework struct ast_channel_tech.read and struct ast_channel_tech.exception callback

Definition at line 313 of file core_unreal.c.

{
    return &ast_null_frame;
}

References ast_null_frame.

ast_unreal_sendhtml()

int ast_unreal_sendhtml	(	struct ast_channel *	ast,
		int	subclass,
		const char *	data,
		int	datalen
	)

Unreal channel framework struct ast_channel_tech.send_html callback

Definition at line 846 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
    int res = -1;
    struct ast_frame f = { AST_FRAME_HTML, };
    int isoutbound;
 
    if (!p) {
        return -1;
    }
 
    ao2_ref(p, 1); /* ref for unreal_queue_frame */
    ao2_lock(p);
    isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
    f.subclass.integer = subclass;
    f.data.ptr = (char *)data;
    f.datalen = datalen;
    res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
    ao2_unlock(p);
    ao2_ref(p, -1);
 
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_tech_pvt(), AST_FRAME_HTML, AST_UNREAL_IS_OUTBOUND, ast_frame::data, ast_frame::datalen, ast_frame_subclass::integer, ast_frame::ptr, ast_frame::subclass, and unreal_queue_frame().

ast_unreal_sendtext()

int ast_unreal_sendtext	(	struct ast_channel *	ast,
		const char *	text
	)

Unreal channel framework struct ast_channel_tech.send_text callback

Definition at line 824 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
    int res = -1;
    struct ast_frame f = { AST_FRAME_TEXT, };
    int isoutbound;
 
    if (!p) {
        return -1;
    }
 
    ao2_ref(p, 1); /* ref for unreal_queue_frame */
    ao2_lock(p);
    isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
    f.data.ptr = (char *) text;
    f.datalen = strlen(text) + 1;
    res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
    ao2_unlock(p);
    ao2_ref(p, -1);
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_tech_pvt(), AST_FRAME_TEXT, AST_UNREAL_IS_OUTBOUND, ast_frame::data, ast_frame::datalen, ast_frame::ptr, text, and unreal_queue_frame().

ast_unreal_setoption()

int ast_unreal_setoption	(	struct ast_channel *	chan,
		int	option,
		void *	data,
		int	datalen
	)

Unreal channel framework struct ast_channel_tech.setoption callback

Definition at line 97 of file core_unreal.c.

{
    int res = 0;
    struct ast_unreal_pvt *p;
    struct ast_channel *otherchan = NULL;
    ast_chan_write_info_t *write_info;
    char *info_data;
 
    if (option != AST_OPTION_CHANNEL_WRITE) {
        return -1;
    }
 
    write_info = data;
 
    if (write_info->version != AST_CHAN_WRITE_INFO_T_VERSION) {
        ast_log(LOG_ERROR, "The chan_write_info_t type has changed, and this channel hasn't been updated!\n");
        return -1;
    }
 
    info_data = write_info->data;
    if (!strcmp(write_info->function, "CHANNEL")) {
        if (!strncasecmp(info_data, "hangup_handler_", 15)) {
            /* Block CHANNEL(hangup_handler_xxx) writes to the other unreal channel. */
            return 0;
        }
 
        /* Crossover the accountcode and peeraccount to cross the unreal bridge. */
        if (!strcasecmp(info_data, "accountcode")) {
            info_data = "peeraccount";
        } else if (!strcasecmp(info_data, "peeraccount")) {
            info_data = "accountcode";
        }
    }
 
    /* get the tech pvt */
    if (!(p = ast_channel_tech_pvt(ast))) {
        return -1;
    }
    ao2_ref(p, 1);
    ast_channel_unlock(ast); /* Held when called, unlock before locking another channel */
 
    /* get the channel we are supposed to write to */
    ao2_lock(p);
    otherchan = (write_info->chan == p->owner) ? p->chan : p->owner;
    if (!otherchan || otherchan == write_info->chan) {
        res = -1;
        otherchan = NULL;
        ao2_unlock(p);
        goto setoption_cleanup;
    }
    ast_channel_ref(otherchan);
 
    /* clear the pvt lock before grabbing the channel */
    ao2_unlock(p);
 
    ast_channel_lock(otherchan);
    res = write_info->write_fn(otherchan, write_info->function, info_data, write_info->value);
    ast_channel_unlock(otherchan);
 
setoption_cleanup:
    ao2_ref(p, -1);
    if (otherchan) {
        ast_channel_unref(otherchan);
    }
    ast_channel_lock(ast); /* Lock back before we leave */
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, AST_CHAN_WRITE_INFO_T_VERSION, ast_channel_lock, ast_channel_ref, ast_channel_tech_pvt(), ast_channel_unlock, ast_channel_unref, ast_log, AST_OPTION_CHANNEL_WRITE, ast_chan_write_info_t::chan, ast_unreal_pvt::chan, ast_chan_write_info_t::data, ast_channel::data, ast_chan_write_info_t::function, LOG_ERROR, NULL, ast_unreal_pvt::owner, ast_chan_write_info_t::value, ast_chan_write_info_t::version, and ast_chan_write_info_t::write_fn.

Referenced by local_setoption().

ast_unreal_write()

int ast_unreal_write	(	struct ast_channel *	ast,
		struct ast_frame *	f
	)

Unreal channel framework struct ast_channel_tech.write callback

Definition at line 318 of file core_unreal.c.

{
    return ast_unreal_write_stream(ast, -1, f);
}

References ast_unreal_write_stream().

ast_unreal_write_stream()

int ast_unreal_write_stream	(	struct ast_channel *	ast,
		int	stream_num,
		struct ast_frame *	f
	)

Unreal channel framework struct ast_channel_tech.write_stream callback

Definition at line 323 of file core_unreal.c.

{
    struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
    int res = -1;
 
    if (!p) {
        return -1;
    }
 
    /* If we are told to write a frame with a type that has no corresponding
     * stream on the channel then drop it.
     */
    if (f->frametype == AST_FRAME_VOICE) {
        if (!ast_channel_get_default_stream(ast, AST_MEDIA_TYPE_AUDIO)) {
            return 0;
        }
    } else if (f->frametype == AST_FRAME_VIDEO ||
        (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_VIDUPDATE)) {
        if (!ast_channel_get_default_stream(ast, AST_MEDIA_TYPE_VIDEO)) {
            return 0;
        }
    }
 
    /* Update the frame to reflect the stream */
    f->stream_num = stream_num;
 
    /* Just queue for delivery to the other side */
    ao2_ref(p, 1);
    ao2_lock(p);
    switch (f->frametype) {
    case AST_FRAME_VOICE:
    case AST_FRAME_VIDEO:
        if (got_optimized_out(ast, p)) {
            break;
        }
        /* fall through */
    default:
        res = unreal_queue_frame(p, AST_UNREAL_IS_OUTBOUND(ast, p), f, ast, 1);
        break;
    }
    ao2_unlock(p);
    ao2_ref(p, -1);
 
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_get_default_stream(), ast_channel_tech_pvt(), AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRAME_VIDEO, AST_FRAME_VOICE, AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, AST_UNREAL_IS_OUTBOUND, ast_frame::frametype, got_optimized_out(), ast_frame_subclass::integer, ast_frame::stream_num, ast_frame::subclass, and unreal_queue_frame().

Referenced by ast_unreal_write().