/*! \brief Return the bridged channel of a Local channel */
static struct ast_channel *local_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge)
{
struct local_pvt *p = ast_channel_tech_pvt(bridge);
struct ast_channel *bridged = bridge;
if (!p) {
ast_debug(1, "Asked for bridged channel on '%s'/'%s', returning <none>\n",
ast_channel_name(chan), ast_channel_name(bridge));
return NULL;
}
ao2_lock(p);
if (ast_test_flag(p, LOCAL_BRIDGE)) {
/* Find the opposite channel */
bridged = (bridge == p->owner ? p->chan : p->owner);
/* Now see if the opposite channel is bridged to anything */
if (!bridged) {
bridged = bridge;
} else if (ast_channel_internal_bridged_channel(bridged)) {
bridged = ast_channel_internal_bridged_channel(bridged);
}
}
ao2_unlock(p);
return bridged;
}
static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
{
struct local_pvt *p = ast_channel_tech_pvt(newchan);
if (!p) {
return -1;
}
ao2_lock(p);
if ((p->owner != oldchan) && (p->chan != oldchan)) {
ast_log(LOG_WARNING, "Old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan);
ao2_unlock(p);
return -1;
}
if (p->owner == oldchan) {
p->owner = newchan;
} else {
p->chan = newchan;
}
/* Do not let a masquerade cause a Local channel to be bridged to itself! */
if (!ast_check_hangup(newchan) && ((p->owner && ast_channel_internal_bridged_channel(p->owner) == p->chan) || (p->chan && ast_channel_internal_bridged_channel(p->chan) == p->owner))) {
ast_log(LOG_WARNING, "You can not bridge a Local channel to itself!\n");
ao2_unlock(p);
ast_queue_hangup(newchan);
return -1;
}
ao2_unlock(p);
return 0;
}
static int serialize_showchan(struct ast_channel *c, char *buf, size_t size)
{
struct timeval now;
long elapsed_seconds = 0;
int hour = 0, min = 0, sec = 0;
char nf[256];
char cgrp[256];
char pgrp[256];
struct ast_str *write_transpath = ast_str_alloca(256);
struct ast_str *read_transpath = ast_str_alloca(256);
now = ast_tvnow();
memset(buf, 0, size);
if (!c)
return 0;
if (ast_channel_cdr(c)) {
elapsed_seconds = now.tv_sec - ast_channel_cdr(c)->start.tv_sec;
hour = elapsed_seconds / 3600;
min = (elapsed_seconds % 3600) / 60;
sec = elapsed_seconds % 60;
}
snprintf(buf,size,
"Name= %s\n"
"Type= %s\n"
"UniqueID= %s\n"
"LinkedID= %s\n"
"CallerIDNum= %s\n"
"CallerIDName= %s\n"
"ConnectedLineIDNum= %s\n"
"ConnectedLineIDName=%s\n"
"DNIDDigits= %s\n"
"RDNIS= %s\n"
"Parkinglot= %s\n"
"Language= %s\n"
"State= %s (%d)\n"
"Rings= %d\n"
"NativeFormat= %s\n"
"WriteFormat= %s\n"
"ReadFormat= %s\n"
"RawWriteFormat= %s\n"
"RawReadFormat= %s\n"
"WriteTranscode= %s %s\n"
"ReadTranscode= %s %s\n"
"1stFileDescriptor= %d\n"
"Framesin= %d %s\n"
"Framesout= %d %s\n"
"TimetoHangup= %ld\n"
"ElapsedTime= %dh%dm%ds\n"
"DirectBridge= %s\n"
"IndirectBridge= %s\n"
"Context= %s\n"
"Extension= %s\n"
"Priority= %d\n"
"CallGroup= %s\n"
"PickupGroup= %s\n"
"Application= %s\n"
"Data= %s\n"
"Blocking_in= %s\n",
ast_channel_name(c),
ast_channel_tech(c)->type,
ast_channel_uniqueid(c),
ast_channel_linkedid(c),
S_COR(ast_channel_caller(c)->id.number.valid, ast_channel_caller(c)->id.number.str, "(N/A)"),
S_COR(ast_channel_caller(c)->id.name.valid, ast_channel_caller(c)->id.name.str, "(N/A)"),
S_COR(ast_channel_connected(c)->id.number.valid, ast_channel_connected(c)->id.number.str, "(N/A)"),
S_COR(ast_channel_connected(c)->id.name.valid, ast_channel_connected(c)->id.name.str, "(N/A)"),
S_OR(ast_channel_dialed(c)->number.str, "(N/A)"),
S_COR(ast_channel_redirecting(c)->from.number.valid, ast_channel_redirecting(c)->from.number.str, "(N/A)"),
ast_channel_parkinglot(c),
ast_channel_language(c),
ast_state2str(ast_channel_state(c)),
ast_channel_state(c),
ast_channel_rings(c),
ast_getformatname_multiple(nf, sizeof(nf), ast_channel_nativeformats(c)),
ast_getformatname(ast_channel_writeformat(c)),
ast_getformatname(ast_channel_readformat(c)),
ast_getformatname(ast_channel_rawwriteformat(c)),
ast_getformatname(ast_channel_rawreadformat(c)),
ast_channel_writetrans(c) ? "Yes" : "No",
ast_translate_path_to_str(ast_channel_writetrans(c), &write_transpath),
ast_channel_readtrans(c) ? "Yes" : "No",
ast_translate_path_to_str(ast_channel_readtrans(c), &read_transpath),
ast_channel_fd(c, 0),
ast_channel_fin(c) & ~DEBUGCHAN_FLAG, (ast_channel_fin(c) & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
ast_channel_fout(c) & ~DEBUGCHAN_FLAG, (ast_channel_fout(c) & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
(long)ast_channel_whentohangup(c)->tv_sec,
hour,
min,
sec,
ast_channel_internal_bridged_channel(c) ? ast_channel_name(ast_channel_internal_bridged_channel(c)) : "<none>",
ast_bridged_channel(c) ? ast_channel_name(ast_bridged_channel(c)) : "<none>",
ast_channel_context(c),
ast_channel_exten(c),
ast_channel_priority(c),
ast_print_group(cgrp, sizeof(cgrp), ast_channel_callgroup(c)),
ast_print_group(pgrp, sizeof(pgrp), ast_channel_pickupgroup(c)),
ast_channel_appl(c) ? ast_channel_appl(c) : "(N/A)",
ast_channel_data(c) ? S_OR(ast_channel_data(c), "(Empty)") : "(None)",
(ast_test_flag(ast_channel_flags(c), AST_FLAG_BLOCKING) ? ast_channel_blockproc(c) : "(Not Blocking)"));
return 0;
}
/*!
* \internal
* \note This function assumes that we're only called from the "outbound" local channel side
*
* \note it is assummed p is locked and reffed before entering this function
*/
static void check_bridge(struct ast_channel *ast, struct local_pvt *p)
{
struct ast_channel *owner;
struct ast_channel *chan;
struct ast_channel *bridged_chan;
struct ast_frame *f;
/* Do a few conditional checks early on just to see if this optimization is possible */
if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
|| !p->chan || !p->owner) {
return;
}
/* Safely get the channel bridged to p->chan */
chan = ast_channel_ref(p->chan);
ao2_unlock(p); /* don't call bridged channel with the pvt locked */
bridged_chan = ast_bridged_channel(chan);
ao2_lock(p);
chan = ast_channel_unref(chan);
/* since we had to unlock p to get the bridged chan, validate our
* data once again and verify the bridged channel is what we expect
* it to be in order to perform this optimization */
if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
|| !p->chan || !p->owner
|| (ast_channel_internal_bridged_channel(p->chan) != bridged_chan)) {
return;
}
/* only do the masquerade if we are being called on the outbound channel,
if it has been bridged to another channel and if there are no pending
frames on the owner channel (because they would be transferred to the
outbound channel during the masquerade)
*/
if (!ast_channel_internal_bridged_channel(p->chan) /* Not ast_bridged_channel! Only go one step! */
|| !AST_LIST_EMPTY(ast_channel_readq(p->owner))
|| ast != p->chan /* Sanity check (should always be false) */) {
return;
}
/* Masquerade bridged channel into owner */
/* Lock everything we need, one by one, and give up if
we can't get everything. Remember, we'll get another
chance in just a little bit */
if (ast_channel_trylock(ast_channel_internal_bridged_channel(p->chan))) {
return;
}
if (ast_check_hangup(ast_channel_internal_bridged_channel(p->chan))
|| ast_channel_trylock(p->owner)) {
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
return;
}
/*
* At this point we have 4 locks:
* p, p->chan (same as ast), p->chan->_bridge, p->owner
*
* Flush a voice or video frame on the outbound channel to make
* the queue empty faster so we can get optimized out.
*/
f = AST_LIST_FIRST(ast_channel_readq(p->chan));
if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO)) {
AST_LIST_REMOVE_HEAD(ast_channel_readq(p->chan), frame_list);
ast_frfree(f);
f = AST_LIST_FIRST(ast_channel_readq(p->chan));
}
if (f
|| ast_check_hangup(p->owner)
|| ast_channel_masquerade(p->owner, ast_channel_internal_bridged_channel(p->chan))) {
ast_channel_unlock(p->owner);
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
return;
}
/* Masquerade got setup. */
ast_debug(4, "Masquerading %s <- %s\n",
ast_channel_name(p->owner),
ast_channel_name(ast_channel_internal_bridged_channel(p->chan)));
if (ast_channel_monitor(p->owner)
&& !ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan))) {
struct ast_channel_monitor *tmp;
/* If a local channel is being monitored, we don't want a masquerade
* to cause the monitor to go away. Since the masquerade swaps the monitors,
* pre-swapping the monitors before the masquerade will ensure that the monitor
* ends up where it is expected.
*/
tmp = ast_channel_monitor(p->owner);
ast_channel_monitor_set(p->owner, ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan)));
ast_channel_monitor_set(ast_channel_internal_bridged_channel(p->chan), tmp);
}
if (ast_channel_audiohooks(p->chan)) {
struct ast_audiohook_list *audiohooks_swapper;
audiohooks_swapper = ast_channel_audiohooks(p->chan);
ast_channel_audiohooks_set(p->chan, ast_channel_audiohooks(p->owner));
ast_channel_audiohooks_set(p->owner, audiohooks_swapper);
}
/* If any Caller ID was set, preserve it after masquerade like above. We must check
* to see if Caller ID was set because otherwise we'll mistakingly copy info not
* set from the dialplan and will overwrite the real channel Caller ID. The reason
* for this whole preswapping action is because the Caller ID is set on the channel
* thread (which is the to be masqueraded away local channel) before both local
* channels are optimized away.
*/
if (ast_channel_caller(p->owner)->id.name.valid || ast_channel_caller(p->owner)->id.number.valid
|| ast_channel_caller(p->owner)->id.subaddress.valid || ast_channel_caller(p->owner)->ani.name.valid
|| ast_channel_caller(p->owner)->ani.number.valid || ast_channel_caller(p->owner)->ani.subaddress.valid) {
SWAP(*ast_channel_caller(p->owner), *ast_channel_caller(ast_channel_internal_bridged_channel(p->chan)));
}
if (ast_channel_redirecting(p->owner)->from.name.valid || ast_channel_redirecting(p->owner)->from.number.valid
|| ast_channel_redirecting(p->owner)->from.subaddress.valid || ast_channel_redirecting(p->owner)->to.name.valid
|| ast_channel_redirecting(p->owner)->to.number.valid || ast_channel_redirecting(p->owner)->to.subaddress.valid) {
SWAP(*ast_channel_redirecting(p->owner), *ast_channel_redirecting(ast_channel_internal_bridged_channel(p->chan)));
}
if (ast_channel_dialed(p->owner)->number.str || ast_channel_dialed(p->owner)->subaddress.valid) {
SWAP(*ast_channel_dialed(p->owner), *ast_channel_dialed(ast_channel_internal_bridged_channel(p->chan)));
}
ast_app_group_update(p->chan, p->owner);
ast_set_flag(p, LOCAL_ALREADY_MASQED);
ast_channel_unlock(p->owner);
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
/* Do the masquerade now. */
owner = ast_channel_ref(p->owner);
ao2_unlock(p);
ast_channel_unlock(ast);
ast_do_masquerade(owner);
ast_channel_unref(owner);
ast_channel_lock(ast);
ao2_lock(p);
}
