bridge_simple.c File Reference

Simple two channel bridging module. More...

#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_technology.h"
#include "asterisk/frame.h"
#include "asterisk/stream.h"

Include dependency graph for bridge_simple.c:

Go to the source code of this file.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	load_module (void)
static int	simple_bridge_join (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static struct ast_stream_topology *	simple_bridge_request_stream_topology_update (struct ast_stream_topology *existing_topology, struct ast_stream_topology *requested_topology)
static void	simple_bridge_stream_topology_changed (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static int	simple_bridge_write (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Simple two channel bridging module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_bridge_technology	simple_bridge

Detailed Description

Simple two channel bridging module.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file bridge_simple.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 290 of file bridge_simple.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 290 of file bridge_simple.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 290 of file bridge_simple.c.

load_module()

static int load_module ( void  )

static

Definition at line 281 of file bridge_simple.c.

{
    if (ast_bridge_technology_register(&simple_bridge)) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_bridge_technology_register, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, simple_bridge, and unload_module().

simple_bridge_join()

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

static

Definition at line 124 of file bridge_simple.c.

{
    struct ast_stream_topology *req_top;
    struct ast_stream_topology *existing_top;
    struct ast_stream_topology *new_top;
    struct ast_channel *c0 = AST_LIST_FIRST(&bridge->channels)->chan;
    struct ast_channel *c1 = AST_LIST_LAST(&bridge->channels)->chan;
    int unhold_c0, unhold_c1;
 
    /*
     * If this is the first channel we can't make it compatible...
     * unless we make it compatible with itself.  O.o
     */
    if (c0 == c1) {
        return 0;
    }
 
    if (ast_channel_make_compatible(c0, c1)) {
        return -1;
    }
 
    /* When both channels are joined we want to try to improve the experience by
     * raising the number of streams so they match.
     */
    ast_channel_lock_both(c0, c1);
    req_top = ast_channel_get_stream_topology(c0);
    existing_top = ast_channel_get_stream_topology(c1);
    if (ast_stream_topology_get_count(req_top) < ast_stream_topology_get_count(existing_top)) {
        SWAP(req_top, existing_top);
        SWAP(c0, c1);
    }
    new_top = simple_bridge_request_stream_topology_update(existing_top, req_top);
 
    /* The ast_channel_hold_state() and ast_channel_name() accessors need to be
     * called with the associated channel lock held.
     */
    if ((unhold_c1 = ast_channel_hold_state(c1) == AST_CONTROL_HOLD)) {
        ast_debug(1, "Channel %s simulating UNHOLD for bridge simple join.\n", ast_channel_name(c1));
    }
 
    if ((unhold_c0 = ast_channel_hold_state(c0) == AST_CONTROL_HOLD)) {
        ast_debug(1, "Channel %s simulating UNHOLD for bridge simple join.\n", ast_channel_name(c0));
    }
 
    ast_channel_unlock(c0);
    ast_channel_unlock(c1);
 
    if (unhold_c1) {
        ast_indicate(c1, AST_CONTROL_UNHOLD);
    }
 
    if (unhold_c0) {
        ast_indicate(c0, AST_CONTROL_UNHOLD);
    }
 
    if (!new_top) {
        /* Failure.  We'll just have to live with the current topology. */
        return 0;
    }
 
    if (!ast_stream_topology_equal(new_top, existing_top)) {
        ast_channel_request_stream_topology_change(c1, new_top, &simple_bridge);
    } else {
        ast_debug(3, "%s: Topologies already match. Current: %s  Requested: %s\n",
                ast_channel_name(c1),
                ast_str_tmp(256, ast_stream_topology_to_str(existing_top, &STR_TMP)),
                ast_str_tmp(256, ast_stream_topology_to_str(new_top, &STR_TMP)));
    }
    ast_stream_topology_free(new_top);
 
    return 0;
}

References ast_channel_get_stream_topology(), ast_channel_hold_state(), ast_channel_lock_both, ast_channel_make_compatible(), ast_channel_name(), ast_channel_request_stream_topology_change(), ast_channel_unlock, AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, ast_debug, ast_indicate(), AST_LIST_FIRST, AST_LIST_LAST, ast_str_tmp, ast_stream_topology_equal(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_to_str(), ast_channel::bridge, ast_bridge::channels, simple_bridge, simple_bridge_request_stream_topology_update(), and SWAP.

simple_bridge_request_stream_topology_update()

static struct ast_stream_topology * simple_bridge_request_stream_topology_update ( struct ast_stream_topology *  existing_topology, struct ast_stream_topology *  requested_topology  )

static

Definition at line 61 of file bridge_simple.c.

{
    struct ast_stream *stream;
    const struct ast_format_cap *audio_formats = NULL;
    struct ast_stream_topology *new_topology;
    int i;
 
    new_topology = ast_stream_topology_clone(requested_topology);
    if (!new_topology) {
        return NULL;
    }
 
    /* We find an existing stream with negotiated audio formats that we can place into
     * any audio streams in the new topology to ensure that negotiation succeeds. Some
     * endpoints incorrectly terminate the call if SDP negotiation fails.
     */
    for (i = 0; i < ast_stream_topology_get_count(existing_topology); ++i) {
        stream = ast_stream_topology_get_stream(existing_topology, i);
 
        if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_AUDIO ||
            ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
            continue;
        }
 
        audio_formats = ast_stream_get_formats(stream);
        break;
    }
 
    if (audio_formats) {
        for (i = 0; i < ast_stream_topology_get_count(new_topology); ++i) {
            stream = ast_stream_topology_get_stream(new_topology, i);
 
            if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_AUDIO ||
                ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
                continue;
            }
 
            /* We haven't actually modified audio_formats so this is safe */
            ast_stream_set_formats(stream, (struct ast_format_cap *)audio_formats);
        }
    }
 
    for (i = 0; i < ast_stream_topology_get_count(new_topology); ++i) {
        stream = ast_stream_topology_get_stream(new_topology, i);
 
        /* For both recvonly and sendonly the stream state reflects our state, that is we
         * are receiving only and we are sending only. Since we are renegotiating a remote
         * party we need to swap this to reflect what we will be doing. That is, if we are
         * receiving from Alice then we want to be sending to Bob, so swap recvonly to
         * sendonly.
         */
        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);
        }
    }
 
    return new_topology;
}

References AST_MEDIA_TYPE_AUDIO, ast_stream_get_formats(), ast_stream_get_state(), ast_stream_get_type(), ast_stream_set_formats(), ast_stream_set_state(), AST_STREAM_STATE_RECVONLY, AST_STREAM_STATE_REMOVED, AST_STREAM_STATE_SENDONLY, ast_stream_topology_clone(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), and NULL.

Referenced by simple_bridge_join(), and simple_bridge_stream_topology_changed().

simple_bridge_stream_topology_changed()

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

static

Definition at line 232 of file bridge_simple.c.

{
    struct ast_channel *c0 = bridge_channel->chan;
    struct ast_channel *c1 = AST_LIST_FIRST(&bridge->channels)->chan;
    struct ast_stream_topology *req_top;
    struct ast_stream_topology *existing_top;
    struct ast_stream_topology *new_top;
 
    ast_bridge_channel_stream_map(bridge_channel);
 
    if (ast_channel_get_stream_topology_change_source(bridge_channel->chan)
        == &simple_bridge) {
        return;
    }
 
    if (c0 == c1) {
        c1 = AST_LIST_LAST(&bridge->channels)->chan;
    }
 
    if (c0 == c1) {
        return;
    }
 
    /* If a party renegotiates we want to renegotiate their counterpart to a matching
     * topology.
     */
    ast_channel_lock_both(c0, c1);
    req_top = ast_channel_get_stream_topology(c0);
    existing_top = ast_channel_get_stream_topology(c1);
    new_top = simple_bridge_request_stream_topology_update(existing_top, req_top);
    ast_channel_unlock(c0);
    ast_channel_unlock(c1);
 
    if (!new_top) {
        /* Failure.  We'll just have to live with the current topology. */
        return;
    }
 
    ast_channel_request_stream_topology_change(c1, new_top, &simple_bridge);
    ast_stream_topology_free(new_top);
}

References ast_bridge_channel_stream_map(), ast_channel_get_stream_topology(), ast_channel_get_stream_topology_change_source(), ast_channel_lock_both, ast_channel_request_stream_topology_change(), ast_channel_unlock, AST_LIST_FIRST, AST_LIST_LAST, ast_stream_topology_free(), ast_channel::bridge, ast_channel::bridge_channel, ast_bridge_channel::chan, ast_bridge::channels, simple_bridge, and simple_bridge_request_stream_topology_update().

simple_bridge_write()

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

static

Definition at line 197 of file bridge_simple.c.

{
    const struct ast_control_t38_parameters *t38_parameters;
    int defer = 0;
 
    if (!ast_bridge_queue_everyone_else(bridge, bridge_channel, frame)) {
        /* This frame was successfully queued so no need to defer */
        return 0;
    }
 
    /* Depending on the frame defer it so when the next channel joins it receives it */
    switch (frame->frametype) {
    case AST_FRAME_CONTROL:
        switch (frame->subclass.integer) {
        case AST_CONTROL_T38_PARAMETERS:
            t38_parameters = frame->data.ptr;
            switch (t38_parameters->request_response) {
            case AST_T38_REQUEST_NEGOTIATE:
                defer = -1;
                break;
            default:
                break;
            }
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }
 
    return defer;
}

References ast_bridge_queue_everyone_else(), AST_CONTROL_T38_PARAMETERS, AST_FRAME_CONTROL, AST_T38_REQUEST_NEGOTIATE, ast_frame::data, ast_frame::frametype, ast_frame_subclass::integer, ast_frame::ptr, ast_control_t38_parameters::request_response, and ast_frame::subclass.

unload_module()

static int unload_module ( void  )

static

Definition at line 275 of file bridge_simple.c.

{
    ast_bridge_technology_unregister(&simple_bridge);
    return 0;
}

References ast_bridge_technology_unregister(), and simple_bridge.

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Simple two channel bridging module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 290 of file bridge_simple.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 290 of file bridge_simple.c.

simple_bridge

struct ast_bridge_technology simple_bridge

static

Definition at line 52 of file bridge_simple.c.

Referenced by load_module(), simple_bridge_join(), simple_bridge_stream_topology_changed(), and unload_module().