bridge_native_dahdi.c File Reference

Native DAHDI bridging support. More...

#include "asterisk.h"
#include "../sig_analog.h"
#include "../chan_dahdi.h"
#include "bridge_native_dahdi.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_technology.h"
#include "asterisk/frame.h"
#include "asterisk/format_cache.h"

Include dependency graph for bridge_native_dahdi.c:

Go to the source code of this file.

Data Structures
struct	native_pvt_bridge
struct	native_pvt_chan

Functions
int	dahdi_native_load (const struct ast_channel_tech *tech)
void	dahdi_native_unload (void)
static int	native_bridge_changed (struct ast_bridge *bridge)
static int	native_bridge_compatible (struct ast_bridge *bridge)
static int	native_bridge_create (struct ast_bridge *bridge)
static void	native_bridge_destroy (struct ast_bridge *bridge)
static int	native_bridge_is_capable (struct ast_bridge_channel *bridge_channel)
static int	native_bridge_join (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static void	native_bridge_leave (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static int	native_bridge_start (struct ast_bridge *bridge)
static void	native_bridge_stop (struct ast_bridge *bridge)
static void	native_bridge_suspend (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static void	native_bridge_unsuspend (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static int	native_bridge_write (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
static int	native_chan_changed (struct ast_bridge_channel *bridge_channel)
static void	native_request_start (struct ast_bridge *bridge)
static void	native_request_stop (struct ast_bridge *bridge)
static int	native_start (struct ast_bridge *bridge)
static void	native_stop (struct ast_bridge *bridge)

Variables
static const struct ast_channel_tech *	dahdi_tech
static struct ast_bridge_technology	native_bridge

Detailed Description

Native DAHDI bridging support.

Author

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

See Also:

• CREDITS

Definition in file bridge_native_dahdi.c.

Function Documentation

dahdi_native_load()

int dahdi_native_load

(

const struct ast_channel_tech *

tech

)

Definition at line 904 of file bridge_native_dahdi.c.

References ast_bridge_technology_register, and dahdi_native_unload().

Referenced by load_module().

{
 dahdi_tech = tech;

 if (ast_bridge_technology_register(&native_bridge)) {
 dahdi_native_unload();
 return -1;
 }

 return 0;
}

dahdi_native_unload()

void dahdi_native_unload

(

void

)

Definition at line 891 of file bridge_native_dahdi.c.

References ast_bridge_technology_unregister().

Referenced by __unload_module(), and dahdi_native_load().

{
 ast_bridge_technology_unregister(&native_bridge);
}

native_bridge_changed()

static int native_bridge_changed ( struct ast_bridge *  bridge )

static

Definition at line 793 of file bridge_native_dahdi.c.

References ast_channel_name(), ast_debug, AST_LIST_TRAVERSE, ast_bridge_channel::chan, ast_bridge::channels, native_chan_changed(), and ast_bridge::uniqueid.

Referenced by native_bridge_write().

{
 struct ast_bridge_channel *cur;

 AST_LIST_TRAVERSE(&bridge->channels, cur, entry) {
 if (native_chan_changed(cur)) {
 ast_debug(1, "Bridge %s: Something changed on channel '%s'.\n",
 bridge->uniqueid, ast_channel_name(cur->chan));
 return -1;
 }
 }
 return 0;
}

native_bridge_compatible()

static int native_bridge_compatible ( struct ast_bridge *  bridge )

static

Definition at line 705 of file bridge_native_dahdi.c.

References ast_channel_name(), ast_debug, AST_LIST_TRAVERSE, ast_bridge_channel::chan, ast_bridge::channels, native_bridge_is_capable(), ast_bridge::num_channels, and ast_bridge::uniqueid.

{
 struct ast_bridge_channel *cur;

 /* We require two channels before even considering native bridging. */
 if (bridge->num_channels != 2) {
 ast_debug(1, "Bridge %s: Cannot use native DAHDI. Must have two channels.\n",
 bridge->uniqueid);
 return 0;
 }

 AST_LIST_TRAVERSE(&bridge->channels, cur, entry) {
 if (!native_bridge_is_capable(cur)) {
 ast_debug(1, "Bridge %s: Cannot use native DAHDI. Channel '%s' not compatible.\n",
 bridge->uniqueid, ast_channel_name(cur->chan));
 return 0;
 }
 }

 return -1;
}

native_bridge_create()

static int native_bridge_create ( struct ast_bridge *  bridge )

static

Definition at line 98 of file bridge_native_dahdi.c.

References ast_assert, ast_calloc, and ast_bridge::tech_pvt.

{
 struct native_pvt_bridge *tech_pvt;

 ast_assert(!bridge->tech_pvt);

 tech_pvt = ast_calloc(1, sizeof(*tech_pvt));
 if (!tech_pvt) {
 return -1;
 }

 bridge->tech_pvt = tech_pvt;
 return 0;
}

native_bridge_destroy()

static void native_bridge_destroy ( struct ast_bridge *  bridge )

static

Definition at line 120 of file bridge_native_dahdi.c.

References ast_free, NULL, and ast_bridge::tech_pvt.

{
 struct native_pvt_bridge *tech_pvt;

 tech_pvt = bridge->tech_pvt;
 bridge->tech_pvt = NULL;
 ast_free(tech_pvt);
}

native_bridge_is_capable()

static int native_bridge_is_capable ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 643 of file bridge_native_dahdi.c.

References ao2_container_count(), ast_channel_has_audio_frame_or_monitor(), ast_channel_lock, ast_channel_name(), ast_channel_tech(), ast_channel_tech_pvt(), ast_channel_unlock, ast_debug, ast_mutex_lock, ast_mutex_unlock, dahdi_pvt::callwaiting, dahdi_pvt::callwaitingcallerid, ast_bridge_channel::chan, ast_bridge_features::dtmf_hooks, ast_bridge_channel::features, dahdi_pvt::lock, native_pvt_chan::pvt, dahdi_pvt::sig, and ast_channel_tech::type.

Referenced by native_bridge_compatible().

{
 struct ast_channel *chan = bridge_channel->chan;
 struct dahdi_pvt *pvt;
 int is_capable;

 if (ao2_container_count(bridge_channel->features->dtmf_hooks)) {
 ast_debug(2, "Channel '%s' has DTMF hooks.\n", ast_channel_name(chan));
 return 0;
 }

 ast_channel_lock(chan);

 if (dahdi_tech != ast_channel_tech(chan)) {
 ast_debug(2, "Channel '%s' is not %s.\n",
 ast_channel_name(chan), dahdi_tech->type);
 ast_channel_unlock(chan);
 return 0;
 }
 if (ast_channel_has_audio_frame_or_monitor(chan)) {
 ast_debug(2, "Channel '%s' has an active monitor, audiohook, or framehook.\n",
 ast_channel_name(chan));
 ast_channel_unlock(chan);
 return 0;
 }
 pvt = ast_channel_tech_pvt(chan);
 if (!pvt || !pvt->sig) {
 /* No private; or signaling is for a pseudo channel. */
 ast_channel_unlock(chan);
 return 0;
 }

 is_capable = 1;
 ast_mutex_lock(&pvt->lock);

 if (pvt->callwaiting && pvt->callwaitingcallerid) {
 /*
 * Call Waiting Caller ID requires DTMF detection to know if it
 * can send the CID spill.
 */
 ast_debug(2, "Channel '%s' has call waiting caller ID enabled.\n",
 ast_channel_name(chan));
 is_capable = 0;
 }

 ast_mutex_unlock(&pvt->lock);
 ast_channel_unlock(chan);

 return is_capable;
}

native_bridge_join()

static int native_bridge_join ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 563 of file bridge_native_dahdi.c.

References ast_assert, ast_calloc, ast_channel_make_compatible(), AST_LIST_FIRST, AST_LIST_LAST, ast_bridge::channels, native_request_start(), ast_channel::tech_pvt, and ast_bridge_channel::tech_pvt.

{
 struct native_pvt_chan *tech_pvt;
 struct ast_channel *c0;
 struct ast_channel *c1;

 ast_assert(!bridge_channel->tech_pvt);

 tech_pvt = ast_calloc(1, sizeof(*tech_pvt));
 if (!tech_pvt) {
 return -1;
 }

 bridge_channel->tech_pvt = tech_pvt;
 native_request_start(bridge);

 /*
 * Make the channels compatible in case the native bridge did
 * not start for some reason and we need to fallback to 1-1
 * bridging.
 */
 c0 = AST_LIST_FIRST(&bridge->channels)->chan;
 c1 = AST_LIST_LAST(&bridge->channels)->chan;
 if (c0 == c1) {
 return 0;
 }
 return ast_channel_make_compatible(c0, c1);
}

native_bridge_leave()

static void native_bridge_leave ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 599 of file bridge_native_dahdi.c.

References ast_free, native_request_stop(), NULL, and ast_bridge_channel::tech_pvt.

{
 struct native_pvt_chan *tech_pvt;

 native_request_stop(bridge);

 tech_pvt = bridge_channel->tech_pvt;
 bridge_channel->tech_pvt = NULL;
 ast_free(tech_pvt);
}

native_bridge_start()

static int native_bridge_start ( struct ast_bridge *  bridge )

static

Definition at line 520 of file bridge_native_dahdi.c.

References ast_assert, native_request_start(), NULL, native_pvt_bridge::saw_start, and ast_bridge::tech_pvt.

{
 struct native_pvt_bridge *tech_pvt;

 ast_assert(bridge->tech_pvt != NULL);

 tech_pvt = bridge->tech_pvt;
 tech_pvt->saw_start = 1;

 native_request_start(bridge);
 return 0;
}

native_bridge_stop()

static void native_bridge_stop ( struct ast_bridge *  bridge )

static

Definition at line 540 of file bridge_native_dahdi.c.

References native_request_stop(), native_pvt_bridge::saw_start, and ast_bridge::tech_pvt.

{
 struct native_pvt_bridge *tech_pvt;

 tech_pvt = bridge->tech_pvt;
 if (!tech_pvt) {
 return;
 }

 tech_pvt->saw_start = 0;
 native_request_stop(bridge);
}

native_bridge_suspend()

static void native_bridge_suspend ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 617 of file bridge_native_dahdi.c.

References native_request_stop().

{
 native_request_stop(bridge);
}

native_bridge_unsuspend()

static void native_bridge_unsuspend ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 629 of file bridge_native_dahdi.c.

References native_request_start().

{
 native_request_start(bridge);
}

native_bridge_write()

static int native_bridge_write ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel, struct ast_frame *  frame  )

static

Definition at line 819 of file bridge_native_dahdi.c.

References ast_assert, ast_bridge_queue_everyone_else(), AST_FRAME_VIDEO, AST_FRAME_VOICE, native_pvt_bridge::connected, ast_frame::frametype, native_bridge_changed(), native_request_start(), native_request_stop(), NULL, and ast_bridge::tech_pvt.

{
 struct native_pvt_bridge *tech_pvt;

 /*
 * When we are not native bridged by DAHDI, we are like a normal
 * 1-1 bridge.
 */

 ast_assert(bridge->tech_pvt != NULL);

 /* Recheck native bridging validity. */
 tech_pvt = bridge->tech_pvt;
 switch (frame->frametype) {
 case AST_FRAME_VOICE:
 case AST_FRAME_VIDEO:
 if (!tech_pvt->connected) {
 /* Don't try to start native mode on media frames. */
 break;
 }
 if (native_bridge_changed(bridge)) {
 native_request_stop(bridge);
 native_request_start(bridge);
 if (!tech_pvt->connected) {
 break;
 }
 }

 /*
 * Native bridge handles voice frames in hardware. However, it
 * also passes the frames up to Asterisk anyway. Discard the
 * media frames.
 */
 return 0;
 default:
 if (!tech_pvt->connected) {
 native_request_start(bridge);
 break;
 }
 if (native_bridge_changed(bridge)) {
 native_request_stop(bridge);
 native_request_start(bridge);
 }
 break;
 }

 return ast_bridge_queue_everyone_else(bridge, bridge_channel, frame);
}

native_chan_changed()

static int native_chan_changed ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 739 of file bridge_native_dahdi.c.

References ast_assert, ast_channel_fd(), ast_channel_lock, ast_channel_tech_pvt(), ast_channel_unlock, ast_bridge_channel::chan, dahdi_get_index, native_pvt_chan::fd0, native_pvt_chan::index, native_pvt_chan::inthreeway, dahdi_subchannel::inthreeway, NULL, native_pvt_chan::owner, dahdi_subchannel::owner, dahdi_pvt::owner, native_pvt_chan::pvt, native_pvt_chan::state, SUB_REAL, dahdi_pvt::subs, and ast_bridge_channel::tech_pvt.

Referenced by native_bridge_changed().

{
 struct native_pvt_chan *tech_pvt;
 struct ast_channel *chan;
 struct dahdi_pvt *pvt;
 int idx = -1;

 ast_assert(bridge_channel->tech_pvt != NULL);

 tech_pvt = bridge_channel->tech_pvt;

 chan = bridge_channel->chan;
 ast_channel_lock(chan);
 pvt = ast_channel_tech_pvt(chan);
 if (tech_pvt->pvt == pvt) {
 idx = dahdi_get_index(chan, pvt, 1);
 }
 ast_channel_unlock(chan);

 if (/* Did chan get masqueraded or PRI change associated B channel? */
 tech_pvt->pvt != pvt
 /* Did the pvt active owner change? */
 || tech_pvt->owner != pvt->owner
 /* Did the pvt three way call status change? */
 || tech_pvt->inthreeway != pvt->subs[SUB_REAL].inthreeway
 /* Did the owner index change? */
 || tech_pvt->index != idx
 /*
 * Did chan file descriptor change? (This seems redundant with
 * masquerade and active owner change checks.)
 */
 || tech_pvt->fd0 != ast_channel_fd(chan, 0)
 /* Did chan state change? i.e. Did it stop ringing? */
 || (pvt->subs[SUB_REAL].owner
 && tech_pvt->state > -1
 && tech_pvt->state != ast_channel_state(pvt->subs[SUB_REAL].owner))) {
 return -1;
 }

 return 0;
}

native_request_start()

static void native_request_start ( struct ast_bridge *  bridge )

static

Definition at line 484 of file bridge_native_dahdi.c.

References ast_assert, AST_LIST_TRAVERSE, ast_bridge::channels, native_pvt_bridge::connected, native_start(), NULL, ast_bridge::num_channels, native_pvt_bridge::saw_start, ast_bridge_channel::suspended, ast_bridge_channel::tech_pvt, and ast_bridge::tech_pvt.

Referenced by native_bridge_join(), native_bridge_start(), native_bridge_unsuspend(), and native_bridge_write().

{
 struct native_pvt_bridge *tech_pvt;
 struct ast_bridge_channel *cur;

 ast_assert(bridge->tech_pvt != NULL);

 tech_pvt = bridge->tech_pvt;

 if (bridge->num_channels != 2 || !tech_pvt->saw_start || tech_pvt->connected) {
 return;
 }
 AST_LIST_TRAVERSE(&bridge->channels, cur, entry) {
 if (cur->suspended || !cur->tech_pvt) {
 return;
 }
 }

 /* Actually try starting the native bridge. */
 if (native_start(bridge)) {
 return;
 }
 tech_pvt->connected = 1;
}

native_request_stop()

static void native_request_stop ( struct ast_bridge *  bridge )

static

Definition at line 184 of file bridge_native_dahdi.c.

References ast_assert, native_pvt_bridge::connected, native_stop(), NULL, and ast_bridge::tech_pvt.

Referenced by native_bridge_leave(), native_bridge_stop(), native_bridge_suspend(), and native_bridge_write().

{
 struct native_pvt_bridge *tech_pvt;

 ast_assert(bridge->tech_pvt != NULL);

 tech_pvt = bridge->tech_pvt;
 if (!tech_pvt->connected) {
 return;
 }
 tech_pvt->connected = 0;

 /* Now to actually stop the bridge. */
 native_stop(bridge);
}

native_start()

static int native_start ( struct ast_bridge *  bridge )

static

Definition at line 213 of file bridge_native_dahdi.c.

References ast_assert, ast_channel_fd(), ast_channel_lock, ast_channel_name(), ast_channel_tech_pvt(), ast_channel_trylock, ast_channel_unlock, ast_debug, AST_LIST_FIRST, AST_LIST_LAST, ast_log, ast_mutex_lock, ast_mutex_trylock, ast_mutex_unlock, AST_STATE_RINGING, call(), ast_bridge_channel::chan, dahdi_pvt::channel, ast_bridge::channels, dahdi_conf_update(), dahdi_dtmf_detect_disable(), dahdi_ec_disable(), dahdi_get_index, dahdi_master_slave_link(), dahdi_sig_pri_lib_handles(), dahdi_subchannel::dfd, dahdi_pvt::echocanbridged, native_pvt_chan::fd0, dahdi_pvt::inconference, native_pvt_chan::index, native_pvt_chan::inthreeway, dahdi_subchannel::inthreeway, dahdi_pvt::lock, LOG_WARNING, native_pvt_bridge::master, dahdi_pvt::master, NULL, native_pvt_chan::owner, dahdi_subchannel::owner, dahdi_pvt::owner, native_pvt_chan::pvt, dahdi_pvt::sig, dahdi_pvt::sig_pvt, native_pvt_bridge::slave, native_pvt_chan::state, SUB_CALLWAIT, SUB_REAL, SUB_THREEWAY, subnames, dahdi_pvt::subs, ast_bridge_channel::tech_pvt, ast_bridge::tech_pvt, and dahdi_pvt::transfer.

Referenced by native_request_start().

{
 struct native_pvt_bridge *tech_pvt;
 struct ast_bridge_channel *bc0;
 struct ast_bridge_channel *bc1;
 struct native_pvt_chan *npc0;
 struct native_pvt_chan *npc1;
 struct ast_channel *c0;
 struct ast_channel *c1;
 struct dahdi_pvt *p0;
 struct dahdi_pvt *p1;
 struct dahdi_pvt *master;
 struct dahdi_pvt *slave;
 int inconf;
 int nothing_ok;

 ast_assert(bridge->tech_pvt != NULL);

 bc0 = AST_LIST_FIRST(&bridge->channels);
 bc1 = AST_LIST_LAST(&bridge->channels);
 c0 = bc0->chan;
 c1 = bc1->chan;

 /* Lock channels and privates */
 for (;;) {
 ast_channel_lock(c0);
 if (!ast_channel_trylock(c1)) {
 p0 = ast_channel_tech_pvt(c0);
 if (!ast_mutex_trylock(&p0->lock)) {
 p1 = ast_channel_tech_pvt(c1);
 if (!ast_mutex_trylock(&p1->lock)) {
 /* Got all locks */
 break;
 }
 ast_mutex_unlock(&p0->lock);
 }
 ast_channel_unlock(c1);
 }
 ast_channel_unlock(c0);
 sched_yield();
 }

 npc0 = bc0->tech_pvt;
 ast_assert(npc0 != NULL);
 npc0->pvt = p0;
 npc0->owner = p0->owner;
 npc0->index = dahdi_get_index(c0, p0, 0);
 npc0->fd0 = ast_channel_fd(c0, 0);
 npc0->state = -1;
 npc0->inthreeway = p0->subs[SUB_REAL].inthreeway;

 npc1 = bc1->tech_pvt;
 ast_assert(npc1 != NULL);
 npc1->pvt = p1;
 npc1->owner = p1->owner;
 npc1->index = dahdi_get_index(c1, p1, 0);
 npc1->fd0 = ast_channel_fd(c1, 0);
 npc1->state = -1;
 npc1->inthreeway = p1->subs[SUB_REAL].inthreeway;

 /*
 * Check things that can change on the privates while in native
 * bridging and cause native to not activate.
 */
 if (npc0->index < 0 || npc1->index < 0
#if defined(HAVE_PRI)
 /*
 * PRI nobch channels (hold and call waiting) are equivalent to
 * pseudo channels and cannot be nativly bridged.
 */
 || (dahdi_sig_pri_lib_handles(p0->sig)
 && ((struct sig_pri_chan *) p0->sig_pvt)->no_b_channel)
 || (dahdi_sig_pri_lib_handles(p1->sig)
 && ((struct sig_pri_chan *) p1->sig_pvt)->no_b_channel)
#endif /* defined(HAVE_PRI) */
 ) {
 ast_mutex_unlock(&p0->lock);
 ast_mutex_unlock(&p1->lock);
 ast_channel_unlock(c0);
 ast_channel_unlock(c1);
 return -1;
 }

 inconf = 0;
 nothing_ok = 1;
 master = NULL;
 slave = NULL;
 if (npc0->index == SUB_REAL && npc1->index == SUB_REAL) {
 if (p0->owner && p1->owner) {
 /*
 * If we don't have a call-wait in a 3-way, and we aren't in a
 * 3-way, we can be master.
 */
 if (!p0->subs[SUB_CALLWAIT].inthreeway && !p1->subs[SUB_REAL].inthreeway) {
 master = p0;
 slave = p1;
 inconf = 1;
 } else if (!p1->subs[SUB_CALLWAIT].inthreeway && !p0->subs[SUB_REAL].inthreeway) {
 master = p1;
 slave = p0;
 inconf = 1;
 } else {
 ast_log(LOG_WARNING, "Huh? Both calls are callwaits or 3-ways? That's clever...?\n");
 ast_log(LOG_WARNING, "p0: chan %d/%d/CW%d/3W%d, p1: chan %d/%d/CW%d/3W%d\n",
 p0->channel,
 npc0->index, (p0->subs[SUB_CALLWAIT].dfd > -1) ? 1 : 0,
 p0->subs[SUB_REAL].inthreeway,
 p0->channel,
 npc0->index, (p1->subs[SUB_CALLWAIT].dfd > -1) ? 1 : 0,
 p1->subs[SUB_REAL].inthreeway);
 }
 nothing_ok = 0;
 }
 } else if (npc0->index == SUB_REAL && npc1->index == SUB_THREEWAY) {
 if (p1->subs[SUB_THREEWAY].inthreeway) {
 master = p1;
 slave = p0;
 nothing_ok = 0;
 }
 } else if (npc0->index == SUB_THREEWAY && npc1->index == SUB_REAL) {
 if (p0->subs[SUB_THREEWAY].inthreeway) {
 master = p0;
 slave = p1;
 nothing_ok = 0;
 }
 } else if (npc0->index == SUB_REAL && npc1->index == SUB_CALLWAIT) {
 /*
 * We have a real and a call wait. If we're in a three way
 * call, put us in it, otherwise, don't put us in anything.
 */
 if (p1->subs[SUB_CALLWAIT].inthreeway) {
 master = p1;
 slave = p0;
 nothing_ok = 0;
 }
 } else if (npc0->index == SUB_CALLWAIT && npc1->index == SUB_REAL) {
 /* Same as previous */
 if (p0->subs[SUB_CALLWAIT].inthreeway) {
 master = p0;
 slave = p1;
 nothing_ok = 0;
 }
 }
 ast_debug(3, "master: %d, slave: %d, nothing_ok: %d\n",
 master ? master->channel : 0,
 slave ? slave->channel : 0,
 nothing_ok);
 if (master && slave) {
 /*
 * Stop any tones, or play ringtone as appropriate. If they are
 * bridged in an active threeway call with a channel that is
 * ringing, we should indicate ringing.
 */
 if (npc1->index == SUB_THREEWAY
 && p1->subs[SUB_THREEWAY].inthreeway
 && p1->subs[SUB_REAL].owner
 && p1->subs[SUB_REAL].inthreeway
 && ast_channel_state(p1->subs[SUB_REAL].owner) == AST_STATE_RINGING) {
 ast_debug(2,
 "Playing ringback on %d/%d(%s) since %d/%d(%s) is in a ringing three-way\n",
 p0->channel, npc0->index, ast_channel_name(c0),
 p1->channel, npc1->index, ast_channel_name(c1));
 tone_zone_play_tone(p0->subs[npc0->index].dfd, DAHDI_TONE_RINGTONE);
 npc1->state = ast_channel_state(p1->subs[SUB_REAL].owner);
 } else {
 ast_debug(2, "Stopping tones on %d/%d(%s) talking to %d/%d(%s)\n",
 p0->channel, npc0->index, ast_channel_name(c0),
 p1->channel, npc1->index, ast_channel_name(c1));
 tone_zone_play_tone(p0->subs[npc0->index].dfd, -1);
 }

 if (npc0->index == SUB_THREEWAY
 && p0->subs[SUB_THREEWAY].inthreeway
 && p0->subs[SUB_REAL].owner
 && p0->subs[SUB_REAL].inthreeway
 && ast_channel_state(p0->subs[SUB_REAL].owner) == AST_STATE_RINGING) {
 ast_debug(2,
 "Playing ringback on %d/%d(%s) since %d/%d(%s) is in a ringing three-way\n",
 p1->channel, npc1->index, ast_channel_name(c1),
 p0->channel, npc0->index, ast_channel_name(c0));
 tone_zone_play_tone(p1->subs[npc1->index].dfd, DAHDI_TONE_RINGTONE);
 npc0->state = ast_channel_state(p0->subs[SUB_REAL].owner);
 } else {
 ast_debug(2, "Stopping tones on %d/%d(%s) talking to %d/%d(%s)\n",
 p1->channel, npc1->index, ast_channel_name(c1),
 p0->channel, npc0->index, ast_channel_name(c0));
 tone_zone_play_tone(p1->subs[npc1->index].dfd, -1);
 }

 if (npc0->index == SUB_REAL && npc1->index == SUB_REAL) {
 if (!p0->echocanbridged || !p1->echocanbridged) {
 /* Disable echo cancellation if appropriate */
 dahdi_ec_disable(p0);
 dahdi_ec_disable(p1);
 }
 }
 dahdi_master_slave_link(slave, master);
 master->inconference = inconf;
 } else if (!nothing_ok) {
 ast_log(LOG_WARNING, "Can't link %d/%s with %d/%s\n",
 p0->channel, subnames[npc0->index],
 p1->channel, subnames[npc1->index]);
 }
 dahdi_conf_update(p0);
 dahdi_conf_update(p1);

 ast_channel_unlock(c0);
 ast_channel_unlock(c1);

 /* Native bridge failed */
 if ((!master || !slave) && !nothing_ok) {
 ast_mutex_unlock(&p0->lock);
 ast_mutex_unlock(&p1->lock);
 return -1;
 }

 if (npc0->index == SUB_REAL) {
 dahdi_dtmf_detect_disable(p0);
 }
 if (npc1->index == SUB_REAL) {
 dahdi_dtmf_detect_disable(p1);
 }

 ast_mutex_unlock(&p0->lock);
 ast_mutex_unlock(&p1->lock);

 tech_pvt = bridge->tech_pvt;
 tech_pvt->master = master;
 tech_pvt->slave = slave;

 ast_debug(2, "Start native bridging %s and %s\n",
 ast_channel_name(c0), ast_channel_name(c1));

#if defined(HAVE_PRI) && defined(PRI_2BCT)
 if (!tech_pvt->tried_trombone_removal) {
 tech_pvt->tried_trombone_removal = 1;

 if (p0->pri && p0->pri == p1->pri && p0->pri->transfer) {
 q931_call *q931_c0;
 q931_call *q931_c1;

 /* Try to eliminate the tromboned call. */
 ast_mutex_lock(&p0->pri->lock);
 ast_assert(dahdi_sig_pri_lib_handles(p0->sig));
 ast_assert(dahdi_sig_pri_lib_handles(p1->sig));
 q931_c0 = ((struct sig_pri_chan *) (p0->sig_pvt))->call;
 q931_c1 = ((struct sig_pri_chan *) (p1->sig_pvt))->call;
 if (q931_c0 && q931_c1) {
 pri_channel_bridge(q931_c0, q931_c1);
 ast_debug(2, "Attempt to eliminate tromboned call with %s and %s\n",
 ast_channel_name(c0), ast_channel_name(c1));
 }
 ast_mutex_unlock(&p0->pri->lock);
 }
 }
#endif /* defined(HAVE_PRI) && defined(PRI_2BCT) */
 return 0;
}

native_stop()

static void native_stop ( struct ast_bridge *  bridge )

static

Definition at line 140 of file bridge_native_dahdi.c.

References ast_assert, ast_channel_name(), ast_channel_tech_pvt(), ast_debug, AST_LIST_FIRST, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_mutex_lock, ast_mutex_unlock, ast_bridge_channel::chan, ast_bridge::channels, dahdi_dtmf_detect_enable(), dahdi_ec_enable(), dahdi_master_slave_unlink(), native_pvt_chan::index, dahdi_pvt::lock, native_pvt_bridge::master, NULL, native_pvt_chan::pvt, native_pvt_bridge::slave, SUB_REAL, ast_bridge_channel::tech_pvt, and ast_bridge::tech_pvt.

Referenced by native_request_stop().

{
 struct native_pvt_bridge *bridge_tech_pvt;
 struct ast_bridge_channel *cur;

 ast_assert(bridge->tech_pvt != NULL);

 AST_LIST_TRAVERSE(&bridge->channels, cur, entry) {
 struct native_pvt_chan *chan_tech_pvt;

 chan_tech_pvt = cur->tech_pvt;
 if (!chan_tech_pvt) {
 continue;
 }

 ast_mutex_lock(&chan_tech_pvt->pvt->lock);
 if (chan_tech_pvt->pvt == ast_channel_tech_pvt(cur->chan)) {
 dahdi_ec_enable(chan_tech_pvt->pvt);
 }
 if (chan_tech_pvt->index == SUB_REAL) {
 dahdi_dtmf_detect_enable(chan_tech_pvt->pvt);
 }
 ast_mutex_unlock(&chan_tech_pvt->pvt->lock);
 }

 bridge_tech_pvt = bridge->tech_pvt;
 dahdi_master_slave_unlink(bridge_tech_pvt->slave, bridge_tech_pvt->master, 1);

 ast_debug(2, "Stop native bridging %s and %s\n",
 ast_channel_name(AST_LIST_FIRST(&bridge->channels)->chan),
 ast_channel_name(AST_LIST_LAST(&bridge->channels)->chan));
}

Variable Documentation

dahdi_tech

const struct ast_channel_tech* dahdi_tech

static

Definition at line 49 of file bridge_native_dahdi.c.

native_bridge

struct ast_bridge_technology native_bridge

static

Definition at line 868 of file bridge_native_dahdi.c.