chan_motif.c File Reference

Motif Jingle Channel Driver. More...

#include "asterisk.h"
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <iksemel.h>
#include <pthread.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config_options.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/acl.h"
#include "asterisk/callerid.h"
#include "asterisk/file.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/manager.h"
#include "asterisk/stringfields.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/xmpp.h"
#include "asterisk/endpoints.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/format_cache.h"

Include dependency graph for chan_motif.c:

Go to the source code of this file.

Data Structures
struct	jingle_action_handler
	Defined handlers for different Jingle actions. More...
struct	jingle_config
struct	jingle_endpoint
	Endpoint which contains configuration information and active sessions. More...
struct	jingle_endpoint_state
	Endpoint state information. More...
struct	jingle_reason_mapping
	Reason text <-> cause code mapping. More...
struct	jingle_session
	Session which contains information about an active session. More...

Macros
#define	DEFAULT_MAX_ICE_CANDIDATES   "10"
	Default maximum number of ICE candidates we will offer.
#define	DEFAULT_MAX_PAYLOADS   "30"
	Default maximum number of payloads we will offer.
#define	ENDPOINT_BUCKETS   37
	Number of buckets for endpoints.
#define	GOOGLE_PHONE_NS   "http://www.google.com/session/phone"
	Namespace for Google Phone description.
#define	GOOGLE_SESSION_NS   "http://www.google.com/session"
	Namespace for Google Session.
#define	GOOGLE_TRANSPORT_NS   "http://www.google.com/transport/p2p"
	Namespace for Google Talk ICE-UDP.
#define	GOOGLE_TRANSPORT_RAW_NS   "http://www.google.com/transport/raw-udp"
	Namespace for Google Talk Raw UDP.
#define	GOOGLE_VIDEO_NS   "http://www.google.com/session/video"
	Namespace for Google Video description.
#define	JINGLE_ICE_UDP_NS   "urn:xmpp:jingle:transports:ice-udp:1"
	Namespace for Jingle ICE-UDP.
#define	JINGLE_NS   "urn:xmpp:jingle:1"
	Namespace for Jingle itself.
#define	JINGLE_RTP_INFO_NS   "urn:xmpp:jingle:apps:rtp:info:1"
	Namespace for Jingle RTP info.
#define	JINGLE_RTP_NS   "urn:xmpp:jingle:apps:rtp:1"
	Namespace for Jingle RTP sessions.
#define	SESSION_BUCKETS   37
	Number of buckets for sessions, on a per-endpoint basis.
#define	XMPP_STANZAS_NS   "urn:ietf:params:xml:ns:xmpp-stanzas"
	Namespace for XMPP stanzas.

Enumerations
enum	jingle_transport { JINGLE_TRANSPORT_ICE_UDP = 3 , JINGLE_TRANSPORT_GOOGLE_V2 = 2 , JINGLE_TRANSPORT_GOOGLE_V1 = 1 , JINGLE_TRANSPORT_NONE = 0 }
	The various transport methods supported, from highest priority to lowest priority when doing fallback. More...

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static	AO2_GLOBAL_OBJ_STATIC (globals)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	CONFIG_INFO_STANDARD (cfg_info, globals, jingle_config_alloc,.files=ACO_FILES(&jingle_conf),)
static int	custom_connection_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Custom handler for connection.
static int	custom_group_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Custom handler for groups.
static int	custom_transport_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Custom handler for transport.
static int	jingle_action_hook (void *data, ikspak *pak)
	Callback for when a Jingle action is received from an endpoint.
static void	jingle_action_session_accept (struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
	Handler function for the 'session-accept' action.
static void	jingle_action_session_info (struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
	Handler function for the 'session-info' action.
static void	jingle_action_session_initiate (struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
	Action handlers.
static void	jingle_action_session_terminate (struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
	Handler function for the 'session-terminate' action.
static void	jingle_action_transport_info (struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
	Handler function for the 'transport-info' action.
static int	jingle_add_content (struct jingle_session *session, iks *jingle, iks *content, iks *description, iks *transport, const char *name, enum ast_media_type type, struct ast_rtp_instance *rtp, iks **payloads)
	Helper function which adds content to a description.
static int	jingle_add_google_candidates_to_transport (struct ast_rtp_instance *rtp, iks *transport, iks **candidates, unsigned int video, enum jingle_transport transport_type, unsigned int maximum)
	Internal helper function which adds Google candidates to a transport node.
static int	jingle_add_ice_udp_candidates_to_transport (struct ast_rtp_instance *rtp, iks *transport, iks **candidates, unsigned int maximum)
	Internal helper function which adds ICE-UDP candidates to a transport node.
static int	jingle_add_payloads_to_description (struct jingle_session *session, struct ast_rtp_instance *rtp, iks *description, iks **payloads, enum ast_media_type type)
	Internal helper function which adds payloads to a description.
static struct jingle_session *	jingle_alloc (struct jingle_endpoint *endpoint, const char *from, const char *sid)
	Internal helper function used to allocate Jingle session on an endpoint.
static int	jingle_answer (struct ast_channel *ast)
	Function called by core when we should answer a Jingle session.
static int	jingle_call (struct ast_channel *ast, const char *dest, int timeout)
	Function called by core to actually start calling a remote party.
static void *	jingle_config_alloc (void)
	Allocator called when module configuration should appear.
static void	jingle_config_destructor (void *obj)
	Destructor called when module configuration goes away.
static int	jingle_digit_begin (struct ast_channel *chan, char digit)
	Function called by core to start a DTMF digit.
static int	jingle_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
	Function called by core to stop a DTMF digit.
static void	jingle_enable_video (struct jingle_session *session)
	Internal helper function which enables video support on a session if possible.
static void *	jingle_endpoint_alloc (const char *cat)
	Allocator function for Jingle endpoints.
static int	jingle_endpoint_cmp (void *obj, void *arg, int flags)
	Comparator function for Jingle endpoints.
static void	jingle_endpoint_destructor (void *obj)
	Destructor for Jingle endpoints.
static void *	jingle_endpoint_find (struct ao2_container *tmp_container, const char *category)
	Find function for Jingle endpoints.
static int	jingle_endpoint_hash (const void *obj, const int flags)
	Hashing function for Jingle endpoints.
static struct jingle_endpoint_state *	jingle_endpoint_state_create (void)
	Allocator function for Jingle endpoint state.
static void	jingle_endpoint_state_destructor (void *obj)
	Destructor for Jingle endpoint state.
static struct jingle_endpoint_state *	jingle_endpoint_state_find_or_create (const char *category)
	State find/create function.
static int	jingle_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
	Function called by core to change the underlying owner channel.
static void	jingle_get_codec (struct ast_channel *chan, struct ast_format_cap *result)
	Function called by RTP engine to get peer capabilities.
static enum ast_rtp_glue_result	jingle_get_rtp_peer (struct ast_channel *chan, struct ast_rtp_instance **instance)
	Function called by RTP engine to get local RTP peer.
static int	jingle_hangup (struct ast_channel *ast)
	Function called by core to hang up a Jingle session.
static int	jingle_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
	Function called by core to ask the channel to indicate some sort of condition.
static int	jingle_interpret_content (struct jingle_session *session, ikspak *pak)
	Helper function which locates content stanzas and interprets them.
static int	jingle_interpret_description (struct jingle_session *session, iks *description, const char *name, struct ast_rtp_instance **rtp)
	Helper function which handles content descriptions.
static int	jingle_interpret_google_transport (struct jingle_session *session, iks *transport, struct ast_rtp_instance *rtp)
	Helper function which handles Google transport information.
static int	jingle_interpret_ice_udp_transport (struct jingle_session *session, iks *transport, struct ast_rtp_instance *rtp)
	Helper function which handles ICE-UDP transport information.
static struct ast_channel *	jingle_new (struct jingle_endpoint *endpoint, struct jingle_session *session, int state, const char *title, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *cid_name)
	Function called to create a new Jingle Asterisk channel.
static int	jingle_outgoing_hook (void *data, ikspak *pak)
	Callback for when a response is received for an outgoing session-initiate message.
static void	jingle_queue_hangup_with_cause (struct jingle_session *session, int cause)
	Helper function which queues a hangup frame with cause code.
static struct ast_frame *	jingle_read (struct ast_channel *ast)
	Function called by core to read any waiting frames.
static struct ast_channel *	jingle_request (const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
	Asterisk core interaction functions.
static void	jingle_send_error_response (struct ast_xmpp_client *connection, ikspak *pak, const char *type, const char *reasonstr, const char *reasonstr2)
	Internal helper function which sends an error response.
static void	jingle_send_response (struct ast_xmpp_client *connection, ikspak *pak)
	Internal helper function which sends a response.
static void	jingle_send_session_accept (struct jingle_session *session)
	Internal function which sends a session-accept message.
static void	jingle_send_session_action (struct jingle_session *session, const char *action)
	Internal function which sends a complete session message.
static void	jingle_send_session_info (struct jingle_session *session, const char *info)
	Internal function which sends a session-info message.
static void	jingle_send_session_initiate (struct jingle_session *session)
	Internal function which sends a session-initiate message.
static void	jingle_send_session_terminate (struct jingle_session *session, const char *reasontext)
	Internal function which sends a session-terminate message.
static void	jingle_send_transport_info (struct jingle_session *session, const char *from)
	Internal function which sends a transport-info message.
static int	jingle_sendtext (struct ast_channel *chan, const char *text)
	Function called by core to send text to the remote party of the Jingle session.
static int	jingle_session_cmp (void *obj, void *arg, int flags)
	Comparator function for Jingle sessions.
static void	jingle_session_destructor (void *obj)
	Destructor for Jingle sessions.
static int	jingle_session_hash (const void *obj, const int flags)
	Hashing function for Jingle sessions.
static struct ast_channel *	jingle_session_lock_full (struct jingle_session *pvt)
static void	jingle_set_owner (struct jingle_session *session, struct ast_channel *chan)
	Set the channel owner on the jingle_session object and related objects.
static int	jingle_set_rtp_peer (struct ast_channel *chan, struct ast_rtp_instance *rtp, struct ast_rtp_instance *vrtp, struct ast_rtp_instance *tpeer, const struct ast_format_cap *cap, int nat_active)
	Function called by RTP engine to change where the remote party should send media.
static int	jingle_write (struct ast_channel *ast, struct ast_frame *frame)
	Function called by core to write frames.
static int	load_module (void)
	Load the module.
static int	reload (void)
	Reload module.
static int	unload_module (void)
	Unload the jingle channel from Asterisk.

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Motif Jingle Channel Driver" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, .requires = "res_xmpp", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static const char	channel_type [] = "Motif"
static struct aco_type	endpoint_option
struct aco_type *	endpoint_options [] = ACO_TYPES(&endpoint_option)
static const struct jingle_action_handler	jingle_action_handlers []
struct aco_file	jingle_conf
static const struct jingle_reason_mapping	jingle_reason_mappings []
static struct ast_rtp_glue	jingle_rtp_glue
	Local glue for interacting with the RTP engine core.
static struct ast_channel_tech	jingle_tech
	PBX interface structure for channel registration.
static struct ast_sched_context *	sched

Detailed Description

Motif Jingle Channel Driver.

Author

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

Iksemel http://iksemel.jabberstudio.org/

Definition in file chan_motif.c.

Macro Definition Documentation

DEFAULT_MAX_ICE_CANDIDATES

#define DEFAULT_MAX_ICE_CANDIDATES   "10"

Default maximum number of ICE candidates we will offer.

Definition at line 262 of file chan_motif.c.

DEFAULT_MAX_PAYLOADS

#define DEFAULT_MAX_PAYLOADS   "30"

Default maximum number of payloads we will offer.

Definition at line 265 of file chan_motif.c.

ENDPOINT_BUCKETS

#define ENDPOINT_BUCKETS   37

Number of buckets for endpoints.

Definition at line 268 of file chan_motif.c.

GOOGLE_PHONE_NS

#define GOOGLE_PHONE_NS   "http://www.google.com/session/phone"

Namespace for Google Phone description.

Definition at line 295 of file chan_motif.c.

GOOGLE_SESSION_NS

#define GOOGLE_SESSION_NS   "http://www.google.com/session"

Namespace for Google Session.

Definition at line 292 of file chan_motif.c.

GOOGLE_TRANSPORT_NS

#define GOOGLE_TRANSPORT_NS   "http://www.google.com/transport/p2p"

Namespace for Google Talk ICE-UDP.

Definition at line 286 of file chan_motif.c.

GOOGLE_TRANSPORT_RAW_NS

#define GOOGLE_TRANSPORT_RAW_NS   "http://www.google.com/transport/raw-udp"

Namespace for Google Talk Raw UDP.

Definition at line 289 of file chan_motif.c.

GOOGLE_VIDEO_NS

#define GOOGLE_VIDEO_NS   "http://www.google.com/session/video"

Namespace for Google Video description.

Definition at line 298 of file chan_motif.c.

JINGLE_ICE_UDP_NS

#define JINGLE_ICE_UDP_NS   "urn:xmpp:jingle:transports:ice-udp:1"

Namespace for Jingle ICE-UDP.

Definition at line 283 of file chan_motif.c.

JINGLE_NS

#define JINGLE_NS   "urn:xmpp:jingle:1"

Namespace for Jingle itself.

Definition at line 274 of file chan_motif.c.

JINGLE_RTP_INFO_NS

#define JINGLE_RTP_INFO_NS   "urn:xmpp:jingle:apps:rtp:info:1"

Namespace for Jingle RTP info.

Definition at line 280 of file chan_motif.c.

JINGLE_RTP_NS

#define JINGLE_RTP_NS   "urn:xmpp:jingle:apps:rtp:1"

Namespace for Jingle RTP sessions.

Definition at line 277 of file chan_motif.c.

SESSION_BUCKETS

#define SESSION_BUCKETS   37

Number of buckets for sessions, on a per-endpoint basis.

Definition at line 271 of file chan_motif.c.

XMPP_STANZAS_NS

#define XMPP_STANZAS_NS   "urn:ietf:params:xml:ns:xmpp-stanzas"

Namespace for XMPP stanzas.

Definition at line 301 of file chan_motif.c.

Enumeration Type Documentation

jingle_transport

enum jingle_transport

The various transport methods supported, from highest priority to lowest priority when doing fallback.

Enumerator
JINGLE_TRANSPORT_ICE_UDP	XEP-0176
JINGLE_TRANSPORT_GOOGLE_V2	https://developers.google.com/talk/call_signaling
JINGLE_TRANSPORT_GOOGLE_V1	Undocumented initial Google specification
JINGLE_TRANSPORT_NONE	No transport specified

Definition at line 304 of file chan_motif.c.

                      {
    JINGLE_TRANSPORT_ICE_UDP = 3,   /*!< XEP-0176 */
    JINGLE_TRANSPORT_GOOGLE_V2 = 2, /*!< https://developers.google.com/talk/call_signaling */
    JINGLE_TRANSPORT_GOOGLE_V1 = 1, /*!< Undocumented initial Google specification */
    JINGLE_TRANSPORT_NONE = 0,      /*!< No transport specified */
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2872 of file chan_motif.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2872 of file chan_motif.c.

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( globals  )

static

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2872 of file chan_motif.c.

CONFIG_INFO_STANDARD()

CONFIG_INFO_STANDARD	(	cfg_info	,
		globals	,
		jingle_config_alloc	,
		.	files = ACO_FILES(&jingle_conf)
	)

custom_connection_handler()

static int custom_connection_handler ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Custom handler for connection.

Definition at line 2716 of file chan_motif.c.

{
    struct jingle_endpoint *endpoint = obj;
 
    /* You might think... but Josh, shouldn't you do this in a prelink callback? Well I *could* but until the original is destroyed
     * this will not actually get called, so even if the config turns out to be bogus this is harmless.
     */
    if (!(endpoint->connection = ast_xmpp_client_find(var->value))) {
        ast_log(LOG_ERROR, "Connection '%s' configured on endpoint '%s' could not be found\n", var->value, endpoint->name);
        return -1;
    }
 
    if (!(endpoint->rule = iks_filter_add_rule(endpoint->connection->filter, jingle_action_hook, endpoint,
                           IKS_RULE_TYPE, IKS_PAK_IQ,
                           IKS_RULE_NS, JINGLE_NS,
                           IKS_RULE_NS, GOOGLE_SESSION_NS,
                           IKS_RULE_DONE))) {
        ast_log(LOG_ERROR, "Action hook could not be added to connection '%s' on endpoint '%s'\n", var->value, endpoint->name);
        return -1;
    }
 
    return 0;
}

References ast_log, ast_xmpp_client_find(), jingle_endpoint::connection, ast_xmpp_client::filter, GOOGLE_SESSION_NS, jingle_action_hook(), JINGLE_NS, LOG_ERROR, jingle_endpoint::name, jingle_endpoint::rule, and var.

Referenced by load_module().

custom_group_handler()

static int custom_group_handler ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Custom handler for groups.

Definition at line 2700 of file chan_motif.c.

{
    struct jingle_endpoint *endpoint = obj;
 
    if (!strcasecmp(var->name, "callgroup")) {
        endpoint->callgroup = ast_get_group(var->value);
    } else if (!strcasecmp(var->name, "pickupgroup")) {
        endpoint->pickupgroup = ast_get_group(var->value);
    } else {
        return -1;
    }
 
    return 0;
}

References ast_get_group(), jingle_endpoint::callgroup, jingle_endpoint::pickupgroup, and var.

Referenced by load_module().

custom_transport_handler()

static int custom_transport_handler ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Custom handler for transport.

Definition at line 2741 of file chan_motif.c.

{
    struct jingle_endpoint *endpoint = obj;
 
    if (!strcasecmp(var->value, "ice-udp")) {
        endpoint->transport = JINGLE_TRANSPORT_ICE_UDP;
    } else if (!strcasecmp(var->value, "google")) {
        endpoint->transport = JINGLE_TRANSPORT_GOOGLE_V2;
    } else if (!strcasecmp(var->value, "google-v1")) {
        endpoint->transport = JINGLE_TRANSPORT_GOOGLE_V1;
    } else {
        ast_log(LOG_WARNING, "Unknown transport type '%s' on endpoint '%s', defaulting to 'ice-udp'\n", var->value, endpoint->name);
        endpoint->transport = JINGLE_TRANSPORT_ICE_UDP;
    }
 
    return 0;
}

References ast_log, JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_GOOGLE_V2, JINGLE_TRANSPORT_ICE_UDP, LOG_WARNING, jingle_endpoint::name, jingle_endpoint::transport, and var.

Referenced by load_module().

jingle_action_hook()

static int jingle_action_hook ( void *  data, ikspak *  pak  )

static

Callback for when a Jingle action is received from an endpoint.

Definition at line 2637 of file chan_motif.c.

{
    char *action;
    const char *sid = NULL;
    struct jingle_session *session = NULL;
    struct jingle_endpoint *endpoint = data;
    int i, handled = 0;
 
    /* We accept both Jingle and Google-V1 */
    if (!(action = iks_find_attrib(pak->query, "action")) &&
        !(action = iks_find_attrib(pak->query, "type"))) {
        /* This occurs if either receive a packet masquerading as Jingle or Google-V1 that is actually not OR we receive a response
         * to a message that has no response hook. */
        return IKS_FILTER_EAT;
    }
 
    /* Bump the endpoint reference count up in case a reload occurs. Unfortunately the available synchronization between iksemel and us
     * does not permit us to make this completely safe. */
    ao2_ref(endpoint, +1);
 
    /* If a Jingle session identifier is present use it */
    if (!(sid = iks_find_attrib(pak->query, "sid"))) {
        /* If a Google-V1 session identifier is present use it */
        sid = iks_find_attrib(pak->query, "id");
    }
 
    /* If a session identifier was present in the message attempt to find the session, it is up to the action handler whether
     * this is required or not */
    if (!ast_strlen_zero(sid)) {
        session = ao2_find(endpoint->state->sessions, sid, OBJ_KEY);
    }
 
    /* If a session is present associate the callid with this thread */
    if (session) {
        ast_callid_threadassoc_add(session->callid);
    }
 
    /* Iterate through supported action handlers looking for one that is able to handle this */
    for (i = 0; i < ARRAY_LEN(jingle_action_handlers); i++) {
        if (!strcasecmp(jingle_action_handlers[i].action, action)) {
            jingle_action_handlers[i].handler(endpoint, session, pak);
            handled = 1;
            break;
        }
    }
 
    /* If no action handler is present for the action they sent us make it evident */
    if (!handled) {
        ast_log(LOG_NOTICE, "Received action '%s' for session '%s' that has no handler\n", action, sid);
    }
 
    /* If a session was successfully found for this message deref it now since the handler is done */
    if (session) {
        ast_callid_threadassoc_remove();
        ao2_ref(session, -1);
    }
 
    ao2_ref(endpoint, -1);
 
    return IKS_FILTER_EAT;
}

References ao2_find, ao2_ref, ARRAY_LEN, ast_callid_threadassoc_add(), ast_callid_threadassoc_remove(), ast_log, ast_strlen_zero(), jingle_action_handler::handler, jingle_action_handlers, LOG_NOTICE, NULL, OBJ_KEY, session, jingle_endpoint_state::sessions, and jingle_endpoint::state.

Referenced by custom_connection_handler().

jingle_action_session_accept()

static void jingle_action_session_accept ( struct jingle_endpoint *  endpoint, struct jingle_session *  session, ikspak *  pak  )

static

Handler function for the 'session-accept' action.

Definition at line 2516 of file chan_motif.c.

{
    struct ast_channel *chan;
 
    if (!session) {
        jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
                       "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
        return;
    }
 
 
    jingle_interpret_content(session, pak);
 
    if ((chan = jingle_session_lock_full(session))) {
        ast_queue_control(chan, AST_CONTROL_ANSWER);
        ast_channel_unlock(chan);
        ast_channel_unref(chan);
    }
    ao2_unlock(session);
 
    jingle_send_response(endpoint->connection, pak);
}

References ao2_unlock, ast_channel_unlock, ast_channel_unref, AST_CONTROL_ANSWER, ast_queue_control(), ast_channel::endpoint, jingle_interpret_content(), jingle_send_error_response(), jingle_send_response(), jingle_session_lock_full(), and session.

jingle_action_session_info()

static void jingle_action_session_info ( struct jingle_endpoint *  endpoint, struct jingle_session *  session, ikspak *  pak  )

static

Handler function for the 'session-info' action.

Definition at line 2540 of file chan_motif.c.

{
    struct ast_channel *chan;
 
    if (!session) {
        jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
                       "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
        return;
    }
 
    if (!(chan = jingle_session_lock_full(session))) {
        ao2_unlock(session);
        jingle_send_response(endpoint->connection, pak);
        return;
    }
 
    if (iks_find_with_attrib(pak->query, "ringing", "xmlns", JINGLE_RTP_INFO_NS)) {
        ast_queue_control(chan, AST_CONTROL_RINGING);
        if (ast_channel_state(chan) != AST_STATE_UP) {
            ast_setstate(chan, AST_STATE_RINGING);
        }
    } else if (iks_find_with_attrib(pak->query, "hold", "xmlns", JINGLE_RTP_INFO_NS)) {
        ast_queue_hold(chan, NULL);
    } else if (iks_find_with_attrib(pak->query, "unhold", "xmlns", JINGLE_RTP_INFO_NS)) {
        ast_queue_unhold(chan);
    }
 
    ast_channel_unlock(chan);
    ast_channel_unref(chan);
    ao2_unlock(session);
 
    jingle_send_response(endpoint->connection, pak);
}

References ao2_unlock, ast_channel_unlock, ast_channel_unref, AST_CONTROL_RINGING, ast_queue_control(), ast_queue_hold(), ast_queue_unhold(), ast_setstate(), AST_STATE_RINGING, AST_STATE_UP, ast_channel::endpoint, JINGLE_RTP_INFO_NS, jingle_send_error_response(), jingle_send_response(), jingle_session_lock_full(), NULL, and session.

jingle_action_session_initiate()

static void jingle_action_session_initiate ( struct jingle_endpoint *  endpoint, struct jingle_session *  session, ikspak *  pak  )

static

Action handlers.

Handler function for the 'session-initiate' action.

Definition at line 2432 of file chan_motif.c.

{
    char *sid;
    enum jingle_transport transport = JINGLE_TRANSPORT_NONE;
    struct ast_channel *chan;
    int res;
 
    if (session) {
        /* This is a duplicate session setup, so respond accordingly */
        jingle_send_error_response(endpoint->connection, pak, "result", "out-of-order", NULL);
        return;
    }
 
    /* Retrieve the session identifier from the message, note that this may alter the transport */
    if ((sid = iks_find_attrib(pak->query, "id"))) {
        /* The presence of the session identifier in the 'id' attribute tells us that this is Google-V1 as everything else uses 'sid' */
        transport = JINGLE_TRANSPORT_GOOGLE_V1;
    } else if (!(sid = iks_find_attrib(pak->query, "sid"))) {
        jingle_send_error_response(endpoint->connection, pak, "bad-request", NULL, NULL);
        return;
    }
 
    /* Create a new local session */
    if (!(session = jingle_alloc(endpoint, pak->from->full, sid))) {
        jingle_send_error_response(endpoint->connection, pak, "cancel", "service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
        return;
    }
 
    /* If we determined that the transport should change as a result of how we got the SID change it */
    if (transport != JINGLE_TRANSPORT_NONE) {
        session->transport = transport;
    }
 
    /* Create a new Asterisk channel using the above local session */
    if (!(chan = jingle_new(endpoint, session, AST_STATE_DOWN, pak->from->user, NULL, NULL, pak->from->full))) {
        ao2_ref(session, -1);
        jingle_send_error_response(endpoint->connection, pak, "cancel", "service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
        return;
    }
 
    ao2_link(endpoint->state->sessions, session);
 
    ast_channel_lock(chan);
    ast_setstate(chan, AST_STATE_RING);
    ast_channel_unlock(chan);
    res = ast_pbx_start(chan);
 
    switch (res) {
    case AST_PBX_FAILED:
        ast_log(LOG_WARNING, "Failed to start PBX :(\n");
        jingle_send_error_response(endpoint->connection, pak, "cancel", "service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
        session->gone = 1;
        ast_hangup(chan);
        break;
    case AST_PBX_CALL_LIMIT:
        ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
        jingle_send_error_response(endpoint->connection, pak, "wait", "resource-constraint xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
        ast_hangup(chan);
        break;
    case AST_PBX_SUCCESS:
        jingle_send_response(endpoint->connection, pak);
 
        /* Only send a transport-info message if we successfully interpreted the available content */
        if (!jingle_interpret_content(session, pak)) {
            jingle_send_transport_info(session, iks_find_attrib(pak->x, "from"));
        }
        break;
    }
}

References ao2_link, ao2_ref, ast_channel_lock, ast_channel_unlock, ast_hangup(), ast_log, AST_PBX_CALL_LIMIT, AST_PBX_FAILED, ast_pbx_start(), AST_PBX_SUCCESS, ast_setstate(), AST_STATE_DOWN, AST_STATE_RING, ast_channel::endpoint, jingle_alloc(), jingle_interpret_content(), jingle_new(), jingle_send_error_response(), jingle_send_response(), jingle_send_transport_info(), JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_NONE, LOG_WARNING, NULL, session, and ast_endpoint::state.

jingle_action_session_terminate()

static void jingle_action_session_terminate ( struct jingle_endpoint *  endpoint, struct jingle_session *  session, ikspak *  pak  )

static

Handler function for the 'session-terminate' action.

Definition at line 2575 of file chan_motif.c.

{
    struct ast_channel *chan;
    iks *reason, *text;
    int cause = AST_CAUSE_NORMAL;
    struct ast_control_pvt_cause_code *cause_code;
    int data_size = sizeof(*cause_code);
 
    if (!session) {
        jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
                       "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
        return;
    }
 
    if (!(chan = jingle_session_lock_full(session))) {
        ao2_unlock(session);
        jingle_send_response(endpoint->connection, pak);
        return;
    }
 
    /* Pull the reason text from the session-terminate message and translate it into a cause code */
    if ((reason = iks_find(pak->query, "reason")) && (text = iks_child(reason))) {
        int i;
 
        /* Size of the string making up the cause code is "Motif " + text */
        data_size += 6 + strlen(iks_name(text));
        cause_code = ast_alloca(data_size);
        memset(cause_code, 0, data_size);
 
        /* Get the appropriate cause code mapping for this reason */
        for (i = 0; i < ARRAY_LEN(jingle_reason_mappings); i++) {
            if (!strcasecmp(jingle_reason_mappings[i].reason, iks_name(text))) {
                cause = jingle_reason_mappings[i].cause;
                break;
            }
        }
 
        /* Store the technology specific information */
        snprintf(cause_code->code, data_size - sizeof(*cause_code) + 1, "Motif %s", iks_name(text));
    } else {
        /* No technology specific information is available */
        cause_code = ast_alloca(data_size);
        memset(cause_code, 0, data_size);
    }
 
    ast_copy_string(cause_code->chan_name, ast_channel_name(chan), AST_CHANNEL_NAME);
    cause_code->ast_cause = cause;
    ast_queue_control_data(chan, AST_CONTROL_PVT_CAUSE_CODE, cause_code, data_size);
    ast_channel_hangupcause_hash_set(chan, cause_code, data_size);
 
    ast_debug(3, "Hanging up channel '%s' due to session terminate message with cause '%d'\n", ast_channel_name(chan), cause);
    ast_queue_hangup_with_cause(chan, cause);
    session->gone = 1;
 
    ast_channel_unlock(chan);
    ast_channel_unref(chan);
    ao2_unlock(session);
 
    jingle_send_response(endpoint->connection, pak);
}

References ao2_unlock, ARRAY_LEN, ast_alloca, ast_control_pvt_cause_code::ast_cause, AST_CAUSE_NORMAL, ast_channel_hangupcause_hash_set(), AST_CHANNEL_NAME, ast_channel_name(), ast_channel_unlock, ast_channel_unref, AST_CONTROL_PVT_CAUSE_CODE, ast_copy_string(), ast_debug, ast_queue_control_data(), ast_queue_hangup_with_cause(), jingle_reason_mapping::cause, ast_control_pvt_cause_code::chan_name, ast_control_pvt_cause_code::code, jingle_endpoint::connection, jingle_reason_mappings, jingle_send_error_response(), jingle_send_response(), jingle_session_lock_full(), session, and text.

jingle_action_transport_info()

static void jingle_action_transport_info ( struct jingle_endpoint *  endpoint, struct jingle_session *  session, ikspak *  pak  )

static

Handler function for the 'transport-info' action.

Definition at line 2503 of file chan_motif.c.

{
    if (!session) {
        jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
                       "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
        return;
    }
 
    jingle_interpret_content(session, pak);
    jingle_send_response(endpoint->connection, pak);
}

References ast_channel::endpoint, jingle_interpret_content(), jingle_send_error_response(), jingle_send_response(), and session.

jingle_add_content()

static int jingle_add_content ( struct jingle_session *  session, iks *  jingle, iks *  content, iks *  description, iks *  transport, const char *  name, enum ast_media_type  type, struct ast_rtp_instance *  rtp, iks **  payloads  )

static

Helper function which adds content to a description.

Definition at line 1434 of file chan_motif.c.

{
    int res = 0;
 
    if (session->transport != JINGLE_TRANSPORT_GOOGLE_V1) {
        iks_insert_attrib(content, "creator", session->outgoing ? "initiator" : "responder");
        iks_insert_attrib(content, "name", name);
        iks_insert_node(jingle, content);
 
        iks_insert_attrib(description, "xmlns", JINGLE_RTP_NS);
        if (type == AST_MEDIA_TYPE_AUDIO) {
            iks_insert_attrib(description, "media", "audio");
        } else if (type == AST_MEDIA_TYPE_VIDEO) {
            iks_insert_attrib(description, "media", "video");
        } else {
            return -1;
        }
        iks_insert_node(content, description);
    } else {
        iks_insert_attrib(description, "xmlns", GOOGLE_PHONE_NS);
        iks_insert_node(jingle, description);
    }
 
    if (!(res = jingle_add_payloads_to_description(session, rtp, description, payloads, type))) {
        if (session->transport == JINGLE_TRANSPORT_ICE_UDP) {
            iks_insert_attrib(transport, "xmlns", JINGLE_ICE_UDP_NS);
            iks_insert_node(content, transport);
        } else if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2) {
            iks_insert_attrib(transport, "xmlns", GOOGLE_TRANSPORT_NS);
            iks_insert_node(content, transport);
        }
    }
 
    return res;
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, GOOGLE_PHONE_NS, GOOGLE_TRANSPORT_NS, jingle_add_payloads_to_description(), JINGLE_ICE_UDP_NS, JINGLE_RTP_NS, JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_GOOGLE_V2, JINGLE_TRANSPORT_ICE_UDP, name, session, and type.

Referenced by jingle_send_session_action().

jingle_add_google_candidates_to_transport()

static int jingle_add_google_candidates_to_transport ( struct ast_rtp_instance *  rtp, iks *  transport, iks **  candidates, unsigned int  video, enum jingle_transport  transport_type, unsigned int  maximum  )

static

Internal helper function which adds Google candidates to a transport node.

Definition at line 1022 of file chan_motif.c.

{
    struct ast_rtp_engine_ice *ice;
    struct ao2_container *local_candidates;
    struct ao2_iterator it;
    struct ast_rtp_engine_ice_candidate *candidate;
    int i = 0, res = 0;
 
    if (!(ice = ast_rtp_instance_get_ice(rtp)) || !(local_candidates = ice->get_local_candidates(rtp))) {
        ast_log(LOG_ERROR, "Unable to add Google ICE candidates as ICE support not available or no candidates available\n");
        return -1;
    }
 
    if (transport_type != JINGLE_TRANSPORT_GOOGLE_V1) {
        iks_insert_attrib(transport, "xmlns", GOOGLE_TRANSPORT_NS);
    }
 
    it = ao2_iterator_init(local_candidates, 0);
 
    while ((candidate = ao2_iterator_next(&it)) && (i < maximum)) {
        iks *local_candidate;
        /* In Google land a username is 16 bytes, explicitly */
        char ufrag[17] = "";
 
        if (!(local_candidate = iks_new("candidate"))) {
            res = -1;
            ast_log(LOG_ERROR, "Unable to allocate IKS candidate stanza for Google ICE transport\n");
            break;
        }
 
        if (candidate->id == 1) {
            iks_insert_attrib(local_candidate, "name", !video ? "rtp" : "video_rtp");
        } else if (candidate->id == 2) {
            iks_insert_attrib(local_candidate, "name", !video ? "rtcp" : "video_rtcp");
        } else {
            iks_delete(local_candidate);
            continue;
        }
 
        iks_insert_attrib(local_candidate, "address", ast_sockaddr_stringify_host(&candidate->address));
        iks_insert_attrib(local_candidate, "port", ast_sockaddr_stringify_port(&candidate->address));
 
        if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_HOST) {
            iks_insert_attrib(local_candidate, "preference", "0.95");
            iks_insert_attrib(local_candidate, "type", "local");
        } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_SRFLX) {
            iks_insert_attrib(local_candidate, "preference", "0.9");
            iks_insert_attrib(local_candidate, "type", "stun");
        }
 
        iks_insert_attrib(local_candidate, "protocol", "udp");
        iks_insert_attrib(local_candidate, "network", "0");
        snprintf(ufrag, sizeof(ufrag), "%s", ice->get_ufrag(rtp));
        iks_insert_attrib(local_candidate, "username", ufrag);
        iks_insert_attrib(local_candidate, "generation", "0");
 
        if (transport_type == JINGLE_TRANSPORT_GOOGLE_V1) {
            iks_insert_attrib(local_candidate, "password", "");
            iks_insert_attrib(local_candidate, "foundation", "0");
            iks_insert_attrib(local_candidate, "component", "1");
        } else {
            iks_insert_attrib(local_candidate, "password", ice->get_password(rtp));
        }
 
        /* You may notice a lack of relay support up above - this is because we don't support it for use with
         * the Google talk transport due to their arcane support. */
 
        iks_insert_node(transport, local_candidate);
        candidates[i++] = local_candidate;
    }
 
    ao2_iterator_destroy(&it);
    ao2_ref(local_candidates, -1);
 
    return res;
}

References ast_rtp_engine_ice_candidate::address, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, AST_RTP_ICE_CANDIDATE_TYPE_HOST, AST_RTP_ICE_CANDIDATE_TYPE_SRFLX, ast_rtp_instance_get_ice(), ast_sockaddr_stringify_host(), ast_sockaddr_stringify_port(), ast_rtp_engine_ice::get_local_candidates, ast_rtp_engine_ice::get_password, ast_rtp_engine_ice::get_ufrag, GOOGLE_TRANSPORT_NS, ast_rtp_engine_ice_candidate::id, JINGLE_TRANSPORT_GOOGLE_V1, LOG_ERROR, ast_rtp_engine_ice_candidate::transport, and ast_rtp_engine_ice_candidate::type.

Referenced by jingle_send_transport_info().

jingle_add_ice_udp_candidates_to_transport()

static int jingle_add_ice_udp_candidates_to_transport ( struct ast_rtp_instance *  rtp, iks *  transport, iks **  candidates, unsigned int  maximum  )

static

Internal helper function which adds ICE-UDP candidates to a transport node.

Definition at line 960 of file chan_motif.c.

{
    struct ast_rtp_engine_ice *ice;
    struct ao2_container *local_candidates;
    struct ao2_iterator it;
    struct ast_rtp_engine_ice_candidate *candidate;
    int i = 0, res = 0;
 
    if (!(ice = ast_rtp_instance_get_ice(rtp)) || !(local_candidates = ice->get_local_candidates(rtp))) {
        ast_log(LOG_ERROR, "Unable to add ICE-UDP candidates as ICE support not available or no candidates available\n");
        return -1;
    }
 
    iks_insert_attrib(transport, "xmlns", JINGLE_ICE_UDP_NS);
    iks_insert_attrib(transport, "pwd", ice->get_password(rtp));
    iks_insert_attrib(transport, "ufrag", ice->get_ufrag(rtp));
 
    it = ao2_iterator_init(local_candidates, 0);
 
    while ((candidate = ao2_iterator_next(&it)) && (i < maximum)) {
        iks *local_candidate;
        char tmp[30];
 
        if (!(local_candidate = iks_new("candidate"))) {
            res = -1;
            ast_log(LOG_ERROR, "Unable to allocate IKS candidate stanza for ICE-UDP transport\n");
            break;
        }
 
        snprintf(tmp, sizeof(tmp), "%u", candidate->id);
        iks_insert_attrib(local_candidate, "component", tmp);
        snprintf(tmp, sizeof(tmp), "%d", ast_str_hash(candidate->foundation));
        iks_insert_attrib(local_candidate, "foundation", tmp);
        iks_insert_attrib(local_candidate, "generation", "0");
        iks_insert_attrib(local_candidate, "network", "0");
        snprintf(tmp, sizeof(tmp), "%04lx", (unsigned long)(ast_random() & 0xffff));
        iks_insert_attrib(local_candidate, "id", tmp);
        iks_insert_attrib(local_candidate, "ip", ast_sockaddr_stringify_host(&candidate->address));
        iks_insert_attrib(local_candidate, "port", ast_sockaddr_stringify_port(&candidate->address));
        snprintf(tmp, sizeof(tmp), "%d", candidate->priority);
        iks_insert_attrib(local_candidate, "priority", tmp);
        iks_insert_attrib(local_candidate, "protocol", "udp");
 
        if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_HOST) {
            iks_insert_attrib(local_candidate, "type", "host");
        } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_SRFLX) {
            iks_insert_attrib(local_candidate, "type", "srflx");
        } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_RELAYED) {
            iks_insert_attrib(local_candidate, "type", "relay");
        }
 
        iks_insert_node(transport, local_candidate);
        candidates[i++] = local_candidate;
    }
 
    ao2_iterator_destroy(&it);
    ao2_ref(local_candidates, -1);
 
    return res;
}

References ast_rtp_engine_ice_candidate::address, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, ast_random(), AST_RTP_ICE_CANDIDATE_TYPE_HOST, AST_RTP_ICE_CANDIDATE_TYPE_RELAYED, AST_RTP_ICE_CANDIDATE_TYPE_SRFLX, ast_rtp_instance_get_ice(), ast_sockaddr_stringify_host(), ast_sockaddr_stringify_port(), ast_str_hash(), ast_rtp_engine_ice_candidate::foundation, ast_rtp_engine_ice::get_local_candidates, ast_rtp_engine_ice::get_password, ast_rtp_engine_ice::get_ufrag, ast_rtp_engine_ice_candidate::id, JINGLE_ICE_UDP_NS, LOG_ERROR, ast_rtp_engine_ice_candidate::priority, ast_rtp_engine_ice_candidate::transport, and ast_rtp_engine_ice_candidate::type.

Referenced by jingle_send_transport_info().

jingle_add_payloads_to_description()

static int jingle_add_payloads_to_description ( struct jingle_session *  session, struct ast_rtp_instance *  rtp, iks *  description, iks **  payloads, enum ast_media_type  type  )

static

Internal helper function which adds payloads to a description.

Definition at line 1348 of file chan_motif.c.

{
    int x = 0, i = 0, res = 0;
 
    for (x = 0; (x < ast_format_cap_count(session->jointcap)) && (i < (session->maxpayloads - 2)); x++) {
        struct ast_format *format = ast_format_cap_get_format(session->jointcap, x);
        int rtp_code;
        iks *payload;
        char tmp[32];
 
        if (ast_format_get_type(format) != type) {
            ao2_ref(format, -1);
            continue;
        }
 
        if (((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(rtp), 1, format, 0)) == -1) ||
            (!(payload = iks_new("payload-type")))) {
            ao2_ref(format, -1);
            return -1;
        }
 
        if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
            iks_insert_attrib(payload, "xmlns", GOOGLE_PHONE_NS);
        }
 
        snprintf(tmp, sizeof(tmp), "%d", rtp_code);
        iks_insert_attrib(payload, "id", tmp);
        iks_insert_attrib(payload, "name", ast_rtp_lookup_mime_subtype2(1, format, 0, 0));
        iks_insert_attrib(payload, "channels", "1");
 
        if ((ast_format_cmp(format, ast_format_g722) == AST_FORMAT_CMP_EQUAL) &&
            ((session->transport == JINGLE_TRANSPORT_GOOGLE_V1) || (session->transport == JINGLE_TRANSPORT_GOOGLE_V2))) {
            iks_insert_attrib(payload, "clockrate", "16000");
        } else {
            snprintf(tmp, sizeof(tmp), "%u", ast_rtp_lookup_sample_rate2(1, format, 0));
            iks_insert_attrib(payload, "clockrate", tmp);
        }
 
        if ((type == AST_MEDIA_TYPE_VIDEO) && (session->transport == JINGLE_TRANSPORT_GOOGLE_V2)) {
            iks *parameter;
 
            /* Google requires these parameters to be set, but alas we can not give accurate values so use some safe defaults */
            if ((parameter = iks_new("parameter"))) {
                iks_insert_attrib(parameter, "name", "width");
                iks_insert_attrib(parameter, "value", "640");
                iks_insert_node(payload, parameter);
            }
            if ((parameter = iks_new("parameter"))) {
                iks_insert_attrib(parameter, "name", "height");
                iks_insert_attrib(parameter, "value", "480");
                iks_insert_node(payload, parameter);
            }
            if ((parameter = iks_new("parameter"))) {
                iks_insert_attrib(parameter, "name", "framerate");
                iks_insert_attrib(parameter, "value", "30");
                iks_insert_node(payload, parameter);
            }
        }
 
        iks_insert_node(description, payload);
        payloads[i++] = payload;
 
        ao2_ref(format, -1);
    }
    /* If this is for audio and there is room for RFC2833 add it in */
    if ((type == AST_MEDIA_TYPE_AUDIO) && (i < session->maxpayloads)) {
        iks *payload;
 
        if ((payload = iks_new("payload-type"))) {
            if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
                iks_insert_attrib(payload, "xmlns", GOOGLE_PHONE_NS);
            }
 
            iks_insert_attrib(payload, "id", "101");
            iks_insert_attrib(payload, "name", "telephone-event");
            iks_insert_attrib(payload, "channels", "1");
            iks_insert_attrib(payload, "clockrate", "8000");
            iks_insert_node(description, payload);
            payloads[i++] = payload;
        }
    }
 
    return res;
}

References ao2_ref, ast_format_cap_count(), ast_format_cap_get_format(), ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_g722, ast_format_get_type(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_rtp_codecs_payload_code(), ast_rtp_instance_get_codecs(), ast_rtp_lookup_mime_subtype2(), ast_rtp_lookup_sample_rate2(), GOOGLE_PHONE_NS, JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_GOOGLE_V2, session, type, and ast_channel::x.

Referenced by jingle_add_content().

jingle_alloc()

static struct jingle_session * jingle_alloc ( struct jingle_endpoint *  endpoint, const char *  from, const char *  sid  )

static

Internal helper function used to allocate Jingle session on an endpoint.

Definition at line 743 of file chan_motif.c.

{
    struct jingle_session *session;
    ast_callid callid;
    struct ast_sockaddr tmp;
 
    if (!(session = ao2_alloc(sizeof(*session), jingle_session_destructor))) {
        return NULL;
    }
 
    callid = ast_read_threadstorage_callid();
    session->callid = (callid ? callid : ast_create_callid());
 
    if (ast_string_field_init(session, 512)) {
        ao2_ref(session, -1);
        return NULL;
    }
 
    if (!ast_strlen_zero(from)) {
        ast_copy_string(session->remote_original, from, sizeof(session->remote_original));
        ast_copy_string(session->remote, from, sizeof(session->remote));
    }
 
    if (ast_strlen_zero(sid)) {
        ast_string_field_build(session, sid, "%08lx%08lx", (unsigned long)ast_random(), (unsigned long)ast_random());
        session->outgoing = 1;
        ast_string_field_set(session, audio_name, "audio");
        ast_string_field_set(session, video_name, "video");
    } else {
        ast_string_field_set(session, sid, sid);
    }
 
    ao2_ref(endpoint->state, +1);
    session->state = endpoint->state;
    ao2_ref(endpoint->connection, +1);
    session->connection = endpoint->connection;
    session->transport = endpoint->transport;
 
    if (!(session->cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
        !(session->jointcap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
        !(session->peercap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
        !session->callid) {
        ao2_ref(session, -1);
        return NULL;
    }
 
    ast_format_cap_append_from_cap(session->cap, endpoint->cap, AST_MEDIA_TYPE_UNKNOWN);
 
    /* While we rely on res_xmpp for communication we still need a temporary ast_sockaddr to tell the RTP engine
     * that we want IPv4 */
    ast_sockaddr_parse(&tmp, "0.0.0.0", 0);
 
    /* Sessions always carry audio, but video is optional so don't enable it here */
    if (!(session->rtp = ast_rtp_instance_new("asterisk", sched, &tmp, NULL))) {
        ao2_ref(session, -1);
        return NULL;
    }
    ast_rtp_instance_set_prop(session->rtp, AST_RTP_PROPERTY_RTCP, 1);
    ast_rtp_instance_set_prop(session->rtp, AST_RTP_PROPERTY_DTMF, 1);
 
    session->maxicecandidates = endpoint->maxicecandidates;
    session->maxpayloads = endpoint->maxpayloads;
 
    return session;
}

References ao2_alloc, ao2_ref, ast_copy_string(), ast_create_callid(), ast_format_cap_alloc, ast_format_cap_append_from_cap(), AST_FORMAT_CAP_FLAG_DEFAULT, AST_MEDIA_TYPE_UNKNOWN, ast_random(), ast_read_threadstorage_callid(), ast_rtp_instance_new(), ast_rtp_instance_set_prop(), AST_RTP_PROPERTY_DTMF, AST_RTP_PROPERTY_RTCP, ast_sockaddr_parse(), ast_string_field_build, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), jingle_session::callid, jingle_endpoint::cap, jingle_endpoint::connection, jingle_session_destructor(), jingle_endpoint::maxicecandidates, jingle_endpoint::maxpayloads, NULL, session, jingle_endpoint::state, and jingle_endpoint::transport.

Referenced by jingle_action_session_initiate(), and jingle_request().

jingle_answer()

static int jingle_answer ( struct ast_channel *  ast )

static

Function called by core when we should answer a Jingle session.

Definition at line 1667 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(ast);
 
    /* The channel has already been answered so we don't need to do anything */
    if (ast_channel_state(ast) == AST_STATE_UP) {
        return 0;
    }
 
    jingle_send_session_accept(session);
 
    return 0;
}

References ast_channel_tech_pvt(), AST_STATE_UP, jingle_send_session_accept(), and session.

jingle_call()

static int jingle_call ( struct ast_channel *  ast, const char *  dest, int  timeout  )

static

Function called by core to actually start calling a remote party.

Definition at line 1892 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(ast);
 
    ast_setstate(ast, AST_STATE_RING);
 
    /* Since we have no idea of the remote capabilities use ours for now */
    ast_format_cap_append_from_cap(session->jointcap, session->cap, AST_MEDIA_TYPE_UNKNOWN);
 
    /* We set up a hook so we can know when our session-initiate message was accepted or rejected */
    session->rule = iks_filter_add_rule(session->connection->filter, jingle_outgoing_hook, session,
                        IKS_RULE_ID, session->connection->mid, IKS_RULE_DONE);
 
    jingle_send_session_initiate(session);
 
    return 0;
}

References ast_channel_tech_pvt(), ast_format_cap_append_from_cap(), AST_MEDIA_TYPE_UNKNOWN, ast_setstate(), AST_STATE_RING, jingle_outgoing_hook(), jingle_send_session_initiate(), and session.

jingle_config_alloc()

static void * jingle_config_alloc ( void  )

static

Allocator called when module configuration should appear.

Definition at line 640 of file chan_motif.c.

{
    struct jingle_config *cfg;
 
    if (!(cfg = ao2_alloc(sizeof(*cfg), jingle_config_destructor))) {
        return NULL;
    }
 
    cfg->endpoints = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        ENDPOINT_BUCKETS, jingle_endpoint_hash, NULL, jingle_endpoint_cmp);
    if (!cfg->endpoints) {
        ao2_ref(cfg, -1);
        return NULL;
    }
 
    return cfg;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, ENDPOINT_BUCKETS, jingle_config::endpoints, jingle_config_destructor(), jingle_endpoint_cmp(), jingle_endpoint_hash(), and NULL.

jingle_config_destructor()

static void jingle_config_destructor ( void *  obj )

static

Destructor called when module configuration goes away.

Definition at line 633 of file chan_motif.c.

{
    struct jingle_config *cfg = obj;
    ao2_cleanup(cfg->endpoints);
}

References ao2_cleanup, and jingle_config::endpoints.

Referenced by jingle_config_alloc().

jingle_digit_begin()

static int jingle_digit_begin ( struct ast_channel *  ast, char  digit  )

static

Function called by core to start a DTMF digit.

Definition at line 1868 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(chan);
 
    if (session->rtp) {
        ast_rtp_instance_dtmf_begin(session->rtp, digit);
    }
 
    return 0;
}

References ast_channel_tech_pvt(), ast_rtp_instance_dtmf_begin(), digit, and session.

jingle_digit_end()

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

static

Function called by core to stop a DTMF digit.

Definition at line 1880 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(ast);
 
    if (session->rtp) {
        ast_rtp_instance_dtmf_end_with_duration(session->rtp, digit, duration);
    }
 
    return 0;
}

References ast_channel_tech_pvt(), ast_rtp_instance_dtmf_end_with_duration(), digit, and session.

jingle_enable_video()

static void jingle_enable_video ( struct jingle_session *  session )

static

Internal helper function which enables video support on a session if possible.

Definition at line 710 of file chan_motif.c.

{
    struct ast_sockaddr tmp;
    struct ast_rtp_engine_ice *ice;
 
    /* If video is already present don't do anything */
    if (session->vrtp) {
        return;
    }
 
    /* If there are no configured video codecs do not turn video support on, it just won't work */
    if (!ast_format_cap_has_type(session->cap, AST_MEDIA_TYPE_VIDEO)) {
        return;
    }
 
    ast_sockaddr_parse(&tmp, "0.0.0.0", 0);
 
    if (!(session->vrtp = ast_rtp_instance_new("asterisk", sched, &tmp, NULL))) {
        return;
    }
 
    ast_rtp_instance_set_prop(session->vrtp, AST_RTP_PROPERTY_RTCP, 1);
    ast_rtp_instance_set_channel_id(session->vrtp, ast_channel_uniqueid(session->owner));
    ast_channel_set_fd(session->owner, 2, ast_rtp_instance_fd(session->vrtp, 0));
    ast_channel_set_fd(session->owner, 3, ast_rtp_instance_fd(session->vrtp, 1));
    ast_rtp_codecs_set_framing(ast_rtp_instance_get_codecs(session->vrtp),
        ast_format_cap_get_framing(session->cap));
    if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2 && (ice = ast_rtp_instance_get_ice(session->vrtp))) {
        ice->stop(session->vrtp);
    }
}

References ast_channel_set_fd(), ast_channel_uniqueid(), ast_format_cap_get_framing(), ast_format_cap_has_type(), AST_MEDIA_TYPE_VIDEO, ast_rtp_codecs_set_framing(), ast_rtp_instance_fd(), ast_rtp_instance_get_codecs(), ast_rtp_instance_get_ice(), ast_rtp_instance_new(), ast_rtp_instance_set_channel_id(), ast_rtp_instance_set_prop(), AST_RTP_PROPERTY_RTCP, ast_sockaddr_parse(), JINGLE_TRANSPORT_GOOGLE_V2, NULL, session, ast_rtp_engine_ice::start, and ast_rtp_engine_ice::stop.

Referenced by jingle_interpret_description(), and jingle_request().

jingle_endpoint_alloc()

static void * jingle_endpoint_alloc ( const char *  cat )

static

Allocator function for Jingle endpoints.

Definition at line 541 of file chan_motif.c.

{
    struct jingle_endpoint *endpoint;
 
    if (!(endpoint = ao2_alloc(sizeof(*endpoint), jingle_endpoint_destructor))) {
        return NULL;
    }
 
    if (ast_string_field_init(endpoint, 512)) {
        ao2_ref(endpoint, -1);
        return NULL;
    }
 
    if (!(endpoint->state = jingle_endpoint_state_find_or_create(cat))) {
        ao2_ref(endpoint, -1);
        return NULL;
    }
 
    ast_string_field_set(endpoint, name, cat);
 
    endpoint->cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    endpoint->transport = JINGLE_TRANSPORT_ICE_UDP;
 
    return endpoint;
}

References ao2_alloc, ao2_ref, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, ast_string_field_init, ast_string_field_set, jingle_endpoint::cap, jingle_endpoint_destructor(), jingle_endpoint_state_find_or_create(), JINGLE_TRANSPORT_ICE_UDP, name, NULL, jingle_endpoint::state, and jingle_endpoint::transport.

jingle_endpoint_cmp()

static int jingle_endpoint_cmp ( void *  obj, void *  arg, int  flags  )

static

Comparator function for Jingle endpoints.

Definition at line 577 of file chan_motif.c.

{
    struct jingle_endpoint *endpoint1 = obj, *endpoint2 = arg;
    const char *name = arg;
 
    return !strcmp(endpoint1->name, flags & OBJ_KEY ? name : endpoint2->name) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, name, jingle_endpoint::name, and OBJ_KEY.

Referenced by jingle_config_alloc().

jingle_endpoint_destructor()

static void jingle_endpoint_destructor ( void *  obj )

static

Destructor for Jingle endpoints.

Definition at line 483 of file chan_motif.c.

{
    struct jingle_endpoint *endpoint = obj;
 
    if (endpoint->rule) {
        iks_filter_remove_rule(endpoint->connection->filter, endpoint->rule);
    }
 
    if (endpoint->connection) {
        ast_xmpp_client_unref(endpoint->connection);
    }
 
    ao2_cleanup(endpoint->cap);
    ao2_ref(endpoint->state, -1);
 
    ast_string_field_free_memory(endpoint);
}

References ao2_cleanup, ao2_ref, ast_string_field_free_memory, ast_xmpp_client_unref(), jingle_endpoint::cap, jingle_endpoint::connection, ast_xmpp_client::filter, jingle_endpoint::rule, and jingle_endpoint::state.

Referenced by jingle_endpoint_alloc().

jingle_endpoint_find()

static void * jingle_endpoint_find ( struct ao2_container *  tmp_container, const char *  category  )

static

Find function for Jingle endpoints.

Definition at line 502 of file chan_motif.c.

{
    return ao2_find(tmp_container, category, OBJ_KEY);
}

References ao2_find, and OBJ_KEY.

Referenced by jingle_endpoint_state_find_or_create(), and jingle_request().

jingle_endpoint_hash()

static int jingle_endpoint_hash ( const void *  obj, const int  flags  )

static

Hashing function for Jingle endpoints.

Definition at line 568 of file chan_motif.c.

{
    const struct jingle_endpoint *endpoint = obj;
    const char *name = obj;
 
    return ast_str_hash(flags & OBJ_KEY ? name : endpoint->name);
}

References ast_str_hash(), name, jingle_endpoint::name, and OBJ_KEY.

Referenced by jingle_config_alloc().

jingle_endpoint_state_create()

static struct jingle_endpoint_state * jingle_endpoint_state_create ( void  )

static

Allocator function for Jingle endpoint state.

Definition at line 508 of file chan_motif.c.

{
    struct jingle_endpoint_state *state;
 
    if (!(state = ao2_alloc(sizeof(*state), jingle_endpoint_state_destructor))) {
        return NULL;
    }
 
    state->sessions = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        SESSION_BUCKETS, jingle_session_hash, NULL, jingle_session_cmp);
    if (!state->sessions) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    return state;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, jingle_endpoint_state_destructor(), jingle_session_cmp(), jingle_session_hash(), NULL, and SESSION_BUCKETS.

Referenced by jingle_endpoint_state_find_or_create().

jingle_endpoint_state_destructor()

static void jingle_endpoint_state_destructor ( void *  obj )

static

Destructor for Jingle endpoint state.

Definition at line 475 of file chan_motif.c.

{
    struct jingle_endpoint_state *state = obj;
 
    ao2_ref(state->sessions, -1);
}

References ao2_ref.

Referenced by jingle_endpoint_state_create().

jingle_endpoint_state_find_or_create()

static struct jingle_endpoint_state * jingle_endpoint_state_find_or_create ( const char *  category )

static

State find/create function.

Definition at line 527 of file chan_motif.c.

{
    RAII_VAR(struct jingle_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
    RAII_VAR(struct jingle_endpoint *, endpoint, NULL, ao2_cleanup);
 
    if (!cfg || !cfg->endpoints || !(endpoint = jingle_endpoint_find(cfg->endpoints, category))) {
        return jingle_endpoint_state_create();
    }
 
    ao2_ref(endpoint->state, +1);
    return endpoint->state;
}

References ao2_cleanup, ao2_global_obj_ref, ao2_ref, globals, jingle_endpoint_find(), jingle_endpoint_state_create(), NULL, and RAII_VAR.

Referenced by jingle_endpoint_alloc().

jingle_fixup()

static int jingle_fixup ( struct ast_channel *  oldchan, struct ast_channel *  newchan  )

static

Function called by core to change the underlying owner channel.

Definition at line 1777 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(newchan);
 
    ao2_lock(session);
 
    jingle_set_owner(session, newchan);
 
    ao2_unlock(session);
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_channel_tech_pvt(), jingle_set_owner(), and session.

jingle_get_codec()

static void jingle_get_codec ( struct ast_channel *  chan, struct ast_format_cap *  result  )

static

Function called by RTP engine to get peer capabilities.

Definition at line 679 of file chan_motif.c.

{
}

jingle_get_rtp_peer()

static enum ast_rtp_glue_result jingle_get_rtp_peer ( struct ast_channel *  chan, struct ast_rtp_instance **  instance  )

static

Function called by RTP engine to get local RTP peer.

Definition at line 663 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(chan);
    enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_LOCAL;
 
    if (!session->rtp) {
        return AST_RTP_GLUE_RESULT_FORBID;
    }
 
    ao2_ref(session->rtp, +1);
    *instance = session->rtp;
 
    return res;
}

References ao2_ref, ast_channel_tech_pvt(), AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_LOCAL, and session.

jingle_hangup()

static int jingle_hangup ( struct ast_channel *  ast )

static

Function called by core to hang up a Jingle session.

Definition at line 1911 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(ast);
 
    ao2_lock(session);
 
    if ((ast_channel_state(ast) != AST_STATE_DOWN) && !session->gone) {
        int cause = (session->owner ? ast_channel_hangupcause(session->owner) : AST_CAUSE_CONGESTION);
        const char *reason = "success";
        int i;
 
        /* Get the appropriate reason and send a session-terminate */
        for (i = 0; i < ARRAY_LEN(jingle_reason_mappings); i++) {
            if (jingle_reason_mappings[i].cause == cause) {
                reason = jingle_reason_mappings[i].reason;
                break;
            }
        }
 
        jingle_send_session_terminate(session, reason);
    }
 
    ast_channel_tech_pvt_set(ast, NULL);
    jingle_set_owner(session, NULL);
 
    ao2_unlink(session->state->sessions, session);
    ao2_ref(session->state, -1);
 
    ao2_unlock(session);
    ao2_ref(session, -1);
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_unlink, ao2_unlock, ARRAY_LEN, AST_CAUSE_CONGESTION, ast_channel_hangupcause(), ast_channel_tech_pvt(), ast_channel_tech_pvt_set(), AST_STATE_DOWN, jingle_reason_mappings, jingle_send_session_terminate(), jingle_set_owner(), NULL, jingle_reason_mapping::reason, and session.

jingle_indicate()

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

static

Function called by core to ask the channel to indicate some sort of condition.

Definition at line 1791 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(ast);
    int res = 0;
 
    switch (condition) {
    case AST_CONTROL_RINGING:
        if (ast_channel_state(ast) == AST_STATE_RING) {
            jingle_send_session_info(session, "ringing xmlns='urn:xmpp:jingle:apps:rtp:info:1'");
        } else {
            res = -1;
        }
        break;
    case AST_CONTROL_BUSY:
        if (ast_channel_state(ast) != AST_STATE_UP) {
            ast_channel_hangupcause_set(ast, AST_CAUSE_BUSY);
            ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
        } else {
            res = -1;
        }
        break;
    case AST_CONTROL_CONGESTION:
        if (ast_channel_state(ast) != AST_STATE_UP) {
            ast_channel_hangupcause_set(ast, AST_CAUSE_CONGESTION);
            ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
        } else {
            res = -1;
        }
        break;
    case AST_CONTROL_INCOMPLETE:
        if (ast_channel_state(ast) != AST_STATE_UP) {
            ast_channel_hangupcause_set(ast, AST_CAUSE_CONGESTION);
            ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
        }
        break;
    case AST_CONTROL_HOLD:
        ast_moh_start(ast, data, NULL);
        break;
    case AST_CONTROL_UNHOLD:
        ast_moh_stop(ast);
        break;
    case AST_CONTROL_SRCUPDATE:
        if (session->rtp) {
            ast_rtp_instance_update_source(session->rtp);
        }
        break;
    case AST_CONTROL_SRCCHANGE:
        if (session->rtp) {
            ast_rtp_instance_change_source(session->rtp);
        }
        break;
    case AST_CONTROL_VIDUPDATE:
    case AST_CONTROL_UPDATE_RTP_PEER:
    case AST_CONTROL_CONNECTED_LINE:
        break;
    case AST_CONTROL_PVT_CAUSE_CODE:
    case AST_CONTROL_MASQUERADE_NOTIFY:
    case -1:
        res = -1;
        break;
    default:
        ast_log(LOG_NOTICE, "Don't know how to indicate condition '%d'\n", condition);
        res = -1;
    }
 
    return res;
}

References AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, ast_channel_hangupcause_set(), ast_channel_tech_pvt(), AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HOLD, AST_CONTROL_INCOMPLETE, AST_CONTROL_MASQUERADE_NOTIFY, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_RINGING, AST_CONTROL_SRCCHANGE, AST_CONTROL_SRCUPDATE, AST_CONTROL_UNHOLD, AST_CONTROL_UPDATE_RTP_PEER, AST_CONTROL_VIDUPDATE, ast_log, ast_moh_start(), ast_moh_stop(), ast_rtp_instance_change_source(), ast_rtp_instance_update_source(), AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), AST_STATE_RING, AST_STATE_UP, jingle_send_session_info(), LOG_NOTICE, NULL, and session.

jingle_interpret_content()

static int jingle_interpret_content ( struct jingle_session *  session, ikspak *  pak  )

static

Helper function which locates content stanzas and interprets them.

Note

The session must not be locked before calling this

Definition at line 2321 of file chan_motif.c.

{
    iks *content;
    unsigned int changed = 0;
    struct ast_channel *chan;
 
    /* Look at the content in the session initiation */
    for (content = iks_child(iks_child(pak->x)); content; content = iks_next(content)) {
        char *name;
        struct ast_rtp_instance *rtp = NULL;
        iks *description, *transport;
 
        /* Ignore specific parts if they are known not to be useful */
        if (!strcmp(iks_name(content), "conference-info")) {
            continue;
        }
 
        name = iks_find_attrib(content, "name");
 
        if (session->transport != JINGLE_TRANSPORT_GOOGLE_V1) {
            /* If this content stanza has no name consider it invalid and move on */
            if (ast_strlen_zero(name) && !(name = iks_find_attrib(content, "jin:name"))) {
                jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
                ast_log(LOG_ERROR, "Received content without a name on session '%s'\n", session->sid);
                return -1;
            }
 
            /* Try to pre-populate which RTP instance this content is relevant to */
            if (!strcmp(session->audio_name, name)) {
                rtp = session->rtp;
            } else if (!strcmp(session->video_name, name)) {
                rtp = session->vrtp;
            }
        } else {
            /* Google-V1 has no concept of associating things like the above does, so since we only support audio over it assume they want audio */
            rtp = session->rtp;
        }
 
        /* If description information is available use it */
        if ((description = iks_find_with_attrib(content, "description", "xmlns", JINGLE_RTP_NS)) ||
            (description = iks_find_with_attrib(content, "rtp:description", "xmlns:rtp", JINGLE_RTP_NS)) ||
            (description = iks_find_with_attrib(content, "pho:description", "xmlns:pho", GOOGLE_PHONE_NS)) ||
            (description = iks_find_with_attrib(pak->query, "description", "xmlns", GOOGLE_PHONE_NS)) ||
            (description = iks_find_with_attrib(pak->query, "pho:description", "xmlns:pho", GOOGLE_PHONE_NS)) ||
            (description = iks_find_with_attrib(pak->query, "vid:description", "xmlns", GOOGLE_VIDEO_NS))) {
            /* If we failed to do something with the content description abort immediately */
            if (jingle_interpret_description(session, description, name, &rtp)) {
                return -1;
            }
 
            /* If we successfully interpret the description then the codecs need updating */
            changed = 1;
        }
 
        /* If we get past the description handling and we still don't know what RTP instance this is for... it is unknown content */
        if (!rtp) {
            ast_log(LOG_ERROR, "Received a content stanza but have no RTP instance for it on session '%s'\n", session->sid);
            jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
            return -1;
        }
 
        /* If ICE UDP transport information is available use it */
        if ((transport = iks_find_with_attrib(content, "transport", "xmlns", JINGLE_ICE_UDP_NS))) {
            if (jingle_interpret_ice_udp_transport(session, transport, rtp)) {
                return -1;
            }
        } else if ((transport = iks_find_with_attrib(content, "transport", "xmlns", GOOGLE_TRANSPORT_NS)) ||
               (transport = iks_find_with_attrib(content, "p:transport", "xmlns:p", GOOGLE_TRANSPORT_NS)) ||
               (transport = iks_find_with_attrib(pak->x, "session", "xmlns", GOOGLE_SESSION_NS)) ||
               (transport = iks_find_with_attrib(pak->x, "ses:session", "xmlns:ses", GOOGLE_SESSION_NS))) {
            /* If Google transport support is available use it */
            if (jingle_interpret_google_transport(session, transport, rtp)) {
                return -1;
            }
        } else if (iks_find(content, "transport")) {
            /* If this is a transport we do not support terminate the session as it probably won't work out in the end */
            jingle_queue_hangup_with_cause(session, AST_CAUSE_FACILITY_NOT_IMPLEMENTED);
            ast_log(LOG_ERROR, "Unsupported transport type received on session '%s'\n", session->sid);
            return -1;
        }
    }
 
    if (!changed) {
        return 0;
    }
 
    if ((chan = jingle_session_lock_full(session))) {
        struct ast_format_cap *caps;
        struct ast_format *fmt;
 
        caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
        if (caps) {
            ast_format_cap_append_from_cap(caps, session->jointcap, AST_MEDIA_TYPE_UNKNOWN);
            ast_channel_nativeformats_set(chan, caps);
            ao2_ref(caps, -1);
        }
 
        fmt = ast_format_cap_get_format(session->jointcap, 0);
        ast_set_read_format(chan, fmt);
        ast_set_write_format(chan, fmt);
        ao2_ref(fmt, -1);
 
        ast_channel_unlock(chan);
        ast_channel_unref(chan);
    }
    ao2_unlock(session);
 
    return 0;
}

References ao2_ref, ao2_unlock, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_FACILITY_NOT_IMPLEMENTED, AST_CAUSE_SWITCH_CONGESTION, ast_channel_nativeformats_set(), ast_channel_unlock, ast_channel_unref, ast_format_cap_alloc, ast_format_cap_append_from_cap(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_log, AST_MEDIA_TYPE_UNKNOWN, ast_set_read_format(), ast_set_write_format(), ast_strlen_zero(), GOOGLE_PHONE_NS, GOOGLE_SESSION_NS, GOOGLE_TRANSPORT_NS, GOOGLE_VIDEO_NS, JINGLE_ICE_UDP_NS, jingle_interpret_description(), jingle_interpret_google_transport(), jingle_interpret_ice_udp_transport(), jingle_queue_hangup_with_cause(), JINGLE_RTP_NS, jingle_session_lock_full(), JINGLE_TRANSPORT_GOOGLE_V1, LOG_ERROR, name, NULL, and session.

Referenced by jingle_action_session_accept(), jingle_action_session_initiate(), and jingle_action_transport_info().

jingle_interpret_description()

static int jingle_interpret_description ( struct jingle_session *  session, iks *  description, const char *  name, struct ast_rtp_instance **  rtp  )

static

Helper function which handles content descriptions.

Definition at line 2075 of file chan_motif.c.

{
    char *media = iks_find_attrib(description, "media");
    struct ast_rtp_codecs codecs;
    iks *codec;
    int othercapability = 0;
 
    /* Google-V1 is always carrying audio, but just doesn't tell us so */
    if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
        media = "audio";
    } else if (ast_strlen_zero(media)) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
        ast_log(LOG_ERROR, "Received a content description on session '%s' without a name\n", session->sid);
        return -1;
    }
 
    /* Determine the type of media that is being carried and update the RTP instance, as well as the name */
    if (!strcasecmp(media, "audio")) {
        if (!ast_strlen_zero(name)) {
            ast_string_field_set(session, audio_name, name);
        }
        *rtp = session->rtp;
        ast_format_cap_remove_by_type(session->peercap, AST_MEDIA_TYPE_AUDIO);
        ast_format_cap_remove_by_type(session->jointcap, AST_MEDIA_TYPE_AUDIO);
    } else if (!strcasecmp(media, "video")) {
        if (!ast_strlen_zero(name)) {
            ast_string_field_set(session, video_name, name);
        }
 
        jingle_enable_video(session);
        *rtp = session->vrtp;
 
        /* If video is not present cancel this session */
        if (!session->vrtp) {
            jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
            ast_log(LOG_ERROR, "Received a video content description on session '%s' but could not enable video\n", session->sid);
            return -1;
        }
 
        ast_format_cap_remove_by_type(session->peercap, AST_MEDIA_TYPE_VIDEO);
        ast_format_cap_remove_by_type(session->jointcap, AST_MEDIA_TYPE_VIDEO);
    } else {
        /* Unknown media type */
        jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
        ast_log(LOG_ERROR, "Unsupported media type '%s' received in content description on session '%s'\n", media, session->sid);
        return -1;
    }
 
    if (ast_rtp_codecs_payloads_initialize(&codecs)) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
        ast_log(LOG_ERROR, "Could not initialize codecs for negotiation on session '%s'\n", session->sid);
        return -1;
    }
 
    /* Iterate the codecs updating the relevant RTP instance as we go */
    for (codec = iks_child(description); codec; codec = iks_next(codec)) {
        char *id = iks_find_attrib(codec, "id");
        char *attr_name = iks_find_attrib(codec, "name");
        char *clockrate = iks_find_attrib(codec, "clockrate");
        int rtp_id, rtp_clockrate;
 
        if (!ast_strlen_zero(id) && !ast_strlen_zero(attr_name) && (sscanf(id, "%30d", &rtp_id) == 1)) {
            if (!ast_strlen_zero(clockrate) && (sscanf(clockrate, "%30d", &rtp_clockrate) == 1)) {
                ast_rtp_codecs_payloads_set_rtpmap_type_rate(&codecs, NULL, rtp_id, media, attr_name, 0, rtp_clockrate);
            } else {
                ast_rtp_codecs_payloads_set_rtpmap_type(&codecs, NULL, rtp_id, media, attr_name, 0);
            }
        }
    }
 
    ast_rtp_codecs_payload_formats(&codecs, session->peercap, &othercapability);
    ast_format_cap_get_compatible(session->cap, session->peercap, session->jointcap);
 
    if (!ast_format_cap_count(session->jointcap)) {
        /* We have no compatible codecs, so terminate the session appropriately */
        jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
        ast_rtp_codecs_payloads_destroy(&codecs);
        return -1;
    }
 
    ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(*rtp), *rtp);
    ast_rtp_codecs_payloads_destroy(&codecs);
 
    return 0;
}

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, ast_format_cap_count(), ast_format_cap_get_compatible(), ast_format_cap_remove_by_type(), ast_log, AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_rtp_codecs_payload_formats(), ast_rtp_codecs_payloads_copy(), ast_rtp_codecs_payloads_destroy(), ast_rtp_codecs_payloads_initialize(), ast_rtp_codecs_payloads_set_rtpmap_type(), ast_rtp_codecs_payloads_set_rtpmap_type_rate(), ast_rtp_instance_get_codecs(), ast_string_field_set, ast_strlen_zero(), codecs, ast_xmpp_resource::description, jingle_enable_video(), jingle_queue_hangup_with_cause(), JINGLE_TRANSPORT_GOOGLE_V1, LOG_ERROR, name, NULL, and session.

Referenced by jingle_interpret_content().

jingle_interpret_google_transport()

static int jingle_interpret_google_transport ( struct jingle_session *  session, iks *  transport, struct ast_rtp_instance *  rtp  )

static

Helper function which handles Google transport information.

Definition at line 2243 of file chan_motif.c.

{
    struct ast_rtp_engine_ice *ice = ast_rtp_instance_get_ice(rtp);
    iks *candidate;
 
    if (!ice) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
        ast_log(LOG_ERROR, "Received Google transport information on session '%s' but ICE support not available\n", session->sid);
        return -1;
    }
 
    /* If this session has not transitioned to the Google transport do so now */
    if ((session->transport != JINGLE_TRANSPORT_GOOGLE_V2) &&
        (session->transport != JINGLE_TRANSPORT_GOOGLE_V1)) {
        /* Stop built-in ICE support... we need to fall back to the old old old STUN */
        ice->stop(rtp);
 
        session->transport = JINGLE_TRANSPORT_GOOGLE_V2;
    }
 
    for (candidate = iks_child(transport); candidate; candidate = iks_next(candidate)) {
        char *address = iks_find_attrib(candidate, "address"), *port = iks_find_attrib(candidate, "port");
        char *username = iks_find_attrib(candidate, "username"), *name = iks_find_attrib(candidate, "name");
        char *protocol = iks_find_attrib(candidate, "protocol");
        int real_port;
        struct ast_sockaddr target = { { 0, } };
        /* In Google land the combined value is 32 bytes */
        char combined[33] = "";
 
        /* If this is NOT actually a candidate just skip it */
        if (strcasecmp(iks_name(candidate), "candidate") &&
            strcasecmp(iks_name(candidate), "p:candidate") &&
            strcasecmp(iks_name(candidate), "ses:candidate")) {
            continue;
        }
 
        /* If this candidate is incomplete skip it */
        if (ast_strlen_zero(address) || ast_strlen_zero(port) || ast_strlen_zero(username) ||
            ast_strlen_zero(name)) {
            jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
            ast_log(LOG_ERROR, "Incomplete Google candidate received on session '%s'\n", session->sid);
            return -1;
        }
 
        /* We only support UDP so skip any other protocols */
        if (!ast_strlen_zero(protocol) && strcasecmp(protocol, "udp")) {
            continue;
        }
 
        /* We only permit audio and video, not RTCP */
        if (strcasecmp(name, "rtp") && strcasecmp(name, "video_rtp")) {
            continue;
        }
 
        /* Parse the target information so we can send a STUN request to the candidate */
        if (sscanf(port, "%30d", &real_port) != 1) {
            jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
            ast_log(LOG_ERROR, "Invalid Google candidate port '%s' received on session '%s'\n", port, session->sid);
            return -1;
        }
        ast_sockaddr_parse(&target, address, PARSE_PORT_FORBID);
        ast_sockaddr_set_port(&target, real_port);
 
        /* Per the STUN support Google talk uses combine the two usernames */
        snprintf(combined, sizeof(combined), "%s%s", username, ice->get_ufrag(rtp));
 
        /* This should appease the masses... we will actually change the remote address when we get their STUN packet */
        ast_rtp_instance_stun_request(rtp, &target, combined);
    }
 
    return 0;
}

References AST_CAUSE_PROTOCOL_ERROR, AST_CAUSE_SWITCH_CONGESTION, ast_log, ast_rtp_instance_get_ice(), ast_rtp_instance_stun_request(), ast_sockaddr_parse(), ast_sockaddr_set_port, ast_strlen_zero(), ast_rtp_engine_ice::get_ufrag, jingle_queue_hangup_with_cause(), JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_GOOGLE_V2, LOG_ERROR, name, PARSE_PORT_FORBID, session, ast_rtp_engine_ice::start, and ast_rtp_engine_ice::stop.

Referenced by jingle_interpret_content().

jingle_interpret_ice_udp_transport()

static int jingle_interpret_ice_udp_transport ( struct jingle_session *  session, iks *  transport, struct ast_rtp_instance *  rtp  )

static

Helper function which handles ICE-UDP transport information.

Definition at line 2162 of file chan_motif.c.

{
    struct ast_rtp_engine_ice *ice = ast_rtp_instance_get_ice(rtp);
    char *ufrag = iks_find_attrib(transport, "ufrag"), *pwd = iks_find_attrib(transport, "pwd");
    iks *candidate;
 
    if (!ice) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
        ast_log(LOG_ERROR, "Received ICE-UDP transport information on session '%s' but ICE support not available\n", session->sid);
        return -1;
    }
 
    if (!ast_strlen_zero(ufrag) && !ast_strlen_zero(pwd)) {
        ice->set_authentication(rtp, ufrag, pwd);
    }
 
    for (candidate = iks_child(transport); candidate; candidate = iks_next(candidate)) {
        char *component = iks_find_attrib(candidate, "component"), *foundation = iks_find_attrib(candidate, "foundation");
        char *generation = iks_find_attrib(candidate, "generation"), *id = iks_find_attrib(candidate, "id");
        char *ip = iks_find_attrib(candidate, "ip"), *port = iks_find_attrib(candidate, "port");
        char *priority = iks_find_attrib(candidate, "priority"), *protocol = iks_find_attrib(candidate, "protocol");
        char *type = iks_find_attrib(candidate, "type");
        struct ast_rtp_engine_ice_candidate local_candidate = { 0, };
        int real_port;
        struct ast_sockaddr remote_address = { { 0, } };
 
        /* If this candidate is incomplete skip it */
        if (ast_strlen_zero(component) || ast_strlen_zero(foundation) || ast_strlen_zero(generation) || ast_strlen_zero(id) ||
            ast_strlen_zero(ip) || ast_strlen_zero(port) || ast_strlen_zero(priority) ||
            ast_strlen_zero(protocol) || ast_strlen_zero(type)) {
            jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
            ast_log(LOG_ERROR, "Incomplete ICE-UDP candidate received on session '%s'\n", session->sid);
            return -1;
        }
 
        if ((sscanf(component, "%30u", &local_candidate.id) != 1) ||
            (sscanf(priority, "%30u", (unsigned *)&local_candidate.priority) != 1) ||
            (sscanf(port, "%30d", &real_port) != 1)) {
            jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
            ast_log(LOG_ERROR, "Invalid ICE-UDP candidate information received on session '%s'\n", session->sid);
            return -1;
        }
 
        local_candidate.foundation = foundation;
        local_candidate.transport = protocol;
 
        ast_sockaddr_parse(&local_candidate.address, ip, PARSE_PORT_FORBID);
 
        /* We only support IPv4 right now */
        if (!ast_sockaddr_is_ipv4(&local_candidate.address)) {
            continue;
        }
 
        ast_sockaddr_set_port(&local_candidate.address, real_port);
 
        if (!strcasecmp(type, "host")) {
            local_candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_HOST;
        } else if (!strcasecmp(type, "srflx")) {
            local_candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_SRFLX;
        } else if (!strcasecmp(type, "relay")) {
            local_candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_RELAYED;
        } else {
            continue;
        }
 
        /* Worst case use the first viable address */
        ast_rtp_instance_get_remote_address(rtp, &remote_address);
 
        if (ast_sockaddr_is_ipv4(&local_candidate.address) && ast_sockaddr_isnull(&remote_address)) {
            ast_rtp_instance_set_remote_address(rtp, &local_candidate.address);
        }
 
        ice->add_remote_candidate(rtp, &local_candidate);
    }
 
    ice->start(rtp);
 
    return 0;
}

References ast_rtp_engine_ice::add_remote_candidate, ast_rtp_engine_ice_candidate::address, AST_CAUSE_PROTOCOL_ERROR, AST_CAUSE_SWITCH_CONGESTION, ast_log, AST_RTP_ICE_CANDIDATE_TYPE_HOST, AST_RTP_ICE_CANDIDATE_TYPE_RELAYED, AST_RTP_ICE_CANDIDATE_TYPE_SRFLX, ast_rtp_instance_get_ice(), ast_rtp_instance_get_remote_address, ast_rtp_instance_set_remote_address, ast_sockaddr_is_ipv4(), ast_sockaddr_isnull(), ast_sockaddr_parse(), ast_sockaddr_set_port, ast_strlen_zero(), ast_rtp_engine_ice_candidate::foundation, ast_rtp_engine_ice_candidate::id, jingle_queue_hangup_with_cause(), LOG_ERROR, PARSE_PORT_FORBID, priority, ast_rtp_engine_ice_candidate::priority, session, ast_rtp_engine_ice::set_authentication, ast_rtp_engine_ice::start, ast_rtp_engine_ice_candidate::transport, type, and ast_rtp_engine_ice_candidate::type.

Referenced by jingle_interpret_content().

jingle_new()

static struct ast_channel * jingle_new ( struct jingle_endpoint *  endpoint, struct jingle_session *  session, int  state, const char *  title, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor, const char *  cid_name  )

static

Function called to create a new Jingle Asterisk channel.

Definition at line 810 of file chan_motif.c.

{
    struct ast_channel *chan;
    const char *str = S_OR(title, session->remote);
    struct ast_format_cap *caps;
    struct ast_format *tmpfmt;
 
    if (!ast_format_cap_count(session->cap)) {
        return NULL;
    }
 
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!caps) {
        return NULL;
    }
 
    if (!(chan = ast_channel_alloc_with_endpoint(1, state, S_OR(title, ""), S_OR(cid_name, ""), "", "", "", assignedids, requestor, 0, endpoint->connection->endpoint, "Motif/%s-%04lx", str, (unsigned long)(ast_random() & 0xffff)))) {
        ao2_ref(caps, -1);
        return NULL;
    }
 
    ast_channel_stage_snapshot(chan);
 
    ast_channel_tech_set(chan, &jingle_tech);
    ast_channel_tech_pvt_set(chan, session);
    jingle_set_owner(session, chan);
 
    ast_channel_callid_set(chan, session->callid);
 
    ast_format_cap_append_from_cap(caps, session->cap, AST_MEDIA_TYPE_UNKNOWN);
    ast_channel_nativeformats_set(chan, caps);
    ao2_ref(caps, -1);
 
    if (session->rtp) {
        struct ast_rtp_engine_ice *ice;
 
        ast_channel_set_fd(chan, 0, ast_rtp_instance_fd(session->rtp, 0));
        ast_channel_set_fd(chan, 1, ast_rtp_instance_fd(session->rtp, 1));
        ast_rtp_codecs_set_framing(ast_rtp_instance_get_codecs(session->rtp),
            ast_format_cap_get_framing(session->cap));
 
        if (((session->transport == JINGLE_TRANSPORT_GOOGLE_V2) ||
             (session->transport == JINGLE_TRANSPORT_GOOGLE_V1)) &&
            (ice = ast_rtp_instance_get_ice(session->rtp))) {
            /* We stop built in ICE support because we need to fall back to old old old STUN support */
            ice->stop(session->rtp);
        }
    }
 
    if (state == AST_STATE_RING) {
        ast_channel_rings_set(chan, 1);
    }
 
    ast_channel_adsicpe_set(chan, AST_ADSI_UNAVAILABLE);
 
    tmpfmt = ast_format_cap_get_format(session->cap, 0);
    ast_channel_set_writeformat(chan, tmpfmt);
    ast_channel_set_rawwriteformat(chan, tmpfmt);
    ast_channel_set_readformat(chan, tmpfmt);
    ast_channel_set_rawreadformat(chan, tmpfmt);
    ao2_ref(tmpfmt, -1);
 
    ao2_lock(endpoint);
 
    ast_channel_callgroup_set(chan, endpoint->callgroup);
    ast_channel_pickupgroup_set(chan, endpoint->pickupgroup);
 
    if (!ast_strlen_zero(endpoint->accountcode)) {
        ast_channel_accountcode_set(chan, endpoint->accountcode);
    }
 
    if (!ast_strlen_zero(endpoint->language)) {
        ast_channel_language_set(chan, endpoint->language);
    }
 
    if (!ast_strlen_zero(endpoint->musicclass)) {
        ast_channel_musicclass_set(chan, endpoint->musicclass);
    }
 
    ast_channel_context_set(chan, endpoint->context);
    if (ast_exists_extension(NULL, endpoint->context, endpoint->name, 1, NULL)) {
        ast_channel_exten_set(chan, endpoint->name);
    } else {
        ast_channel_exten_set(chan, "s");
    }
    ast_channel_priority_set(chan, 1);
 
    ao2_unlock(endpoint);
 
    ast_channel_stage_snapshot_done(chan);
    ast_channel_unlock(chan);
 
    return chan;
}

References jingle_endpoint::accountcode, ao2_lock, ao2_ref, ao2_unlock, AST_ADSI_UNAVAILABLE, ast_channel_adsicpe_set(), ast_channel_alloc_with_endpoint, ast_channel_callgroup_set(), ast_channel_callid_set(), ast_channel_context_set(), ast_channel_exten_set(), ast_channel_nativeformats_set(), ast_channel_pickupgroup_set(), ast_channel_priority_set(), ast_channel_rings_set(), ast_channel_set_fd(), ast_channel_set_rawreadformat(), ast_channel_set_rawwriteformat(), ast_channel_set_readformat(), ast_channel_set_writeformat(), ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_unlock, ast_exists_extension(), ast_format_cap_alloc, ast_format_cap_append_from_cap(), ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_format_cap_get_framing(), AST_MEDIA_TYPE_UNKNOWN, ast_random(), ast_rtp_codecs_set_framing(), ast_rtp_instance_fd(), ast_rtp_instance_get_codecs(), ast_rtp_instance_get_ice(), AST_STATE_RING, ast_strlen_zero(), jingle_endpoint::callgroup, jingle_endpoint::connection, jingle_endpoint::context, ast_xmpp_client::endpoint, jingle_set_owner(), jingle_tech, JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_GOOGLE_V2, jingle_endpoint::language, jingle_endpoint::musicclass, jingle_endpoint::name, NULL, jingle_endpoint::pickupgroup, S_OR, session, ast_rtp_engine_ice::start, ast_rtp_engine_ice::stop, and str.

Referenced by jingle_action_session_initiate(), and jingle_request().

jingle_outgoing_hook()

static int jingle_outgoing_hook ( void *  data, ikspak *  pak  )

static

Callback for when a response is received for an outgoing session-initiate message.

Definition at line 1566 of file chan_motif.c.

{
    struct jingle_session *session = data;
    iks *error = iks_find(pak->x, "error"), *redirect;
 
    /* In all cases this hook is done with */
    iks_filter_remove_rule(session->connection->filter, session->rule);
    session->rule = NULL;
 
    ast_callid_threadassoc_add(session->callid);
 
    /* If no error occurred they accepted our session-initiate message happily */
    if (!error) {
        struct ast_channel *chan;
 
        if ((chan = jingle_session_lock_full(session))) {
            ast_queue_control(chan, AST_CONTROL_PROCEEDING);
            ast_channel_unlock(chan);
            ast_channel_unref(chan);
        }
        ao2_unlock(session);
 
        jingle_send_transport_info(session, iks_find_attrib(pak->x, "from"));
 
        goto end;
    }
 
    /* Assume that because this is an error the session is gone, there is only one case where this is incorrect - a redirect */
    session->gone = 1;
 
    /* Map the error we received to an appropriate cause code and hang up the channel */
    if ((redirect = iks_find_with_attrib(error, "redirect", "xmlns", XMPP_STANZAS_NS))) {
        iks *to = iks_child(redirect);
        char *target;
 
        if (to && (target = iks_name(to)) && !ast_strlen_zero(target)) {
            /* Make the xmpp: go away if it is present */
            if (!strncmp(target, "xmpp:", 5)) {
                target += 5;
            }
 
            /* This is actually a fairly simple operation - we update the remote and send another session-initiate */
            ast_copy_string(session->remote, target, sizeof(session->remote));
 
            /* Add a new hook so we can get the status of redirected session */
            session->rule = iks_filter_add_rule(session->connection->filter, jingle_outgoing_hook, session,
                                IKS_RULE_ID, session->connection->mid, IKS_RULE_DONE);
 
            jingle_send_session_initiate(session);
 
            session->gone = 0;
        } else {
            jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
        }
    } else if (iks_find_with_attrib(error, "service-unavailable", "xmlns", XMPP_STANZAS_NS)) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_CONGESTION);
    } else if (iks_find_with_attrib(error, "resource-constraint", "xmlns", XMPP_STANZAS_NS)) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_REQUESTED_CHAN_UNAVAIL);
    } else if (iks_find_with_attrib(error, "bad-request", "xmlns", XMPP_STANZAS_NS)) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
    } else if (iks_find_with_attrib(error, "remote-server-not-found", "xmlns", XMPP_STANZAS_NS)) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_NO_ROUTE_DESTINATION);
    } else if (iks_find_with_attrib(error, "feature-not-implemented", "xmlns", XMPP_STANZAS_NS)) {
        /* Assume that this occurred because the remote side does not support our transport, so drop it down one and try again */
        session->transport--;
 
        /* If we still have a viable transport mechanism re-send the session-initiate */
        if (session->transport != JINGLE_TRANSPORT_NONE) {
            struct ast_rtp_engine_ice *ice;
 
            if (((session->transport == JINGLE_TRANSPORT_GOOGLE_V2) ||
                 (session->transport == JINGLE_TRANSPORT_GOOGLE_V1)) &&
                (ice = ast_rtp_instance_get_ice(session->rtp))) {
                /* We stop built in ICE support because we need to fall back to old old old STUN support */
                ice->stop(session->rtp);
            }
 
            /* Re-send the message to the *original* target and not a redirected one */
            ast_copy_string(session->remote, session->remote_original, sizeof(session->remote));
 
            session->rule = iks_filter_add_rule(session->connection->filter, jingle_outgoing_hook, session,
                                IKS_RULE_ID, session->connection->mid, IKS_RULE_DONE);
 
            jingle_send_session_initiate(session);
 
            session->gone = 0;
        } else {
            /* Otherwise we have exhausted all transports */
            jingle_queue_hangup_with_cause(session, AST_CAUSE_FACILITY_NOT_IMPLEMENTED);
        }
    } else {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
    }
 
end:
    ast_callid_threadassoc_remove();
 
    return IKS_FILTER_EAT;
}

References ao2_unlock, ast_callid_threadassoc_add(), ast_callid_threadassoc_remove(), AST_CAUSE_CONGESTION, AST_CAUSE_FACILITY_NOT_IMPLEMENTED, AST_CAUSE_NO_ROUTE_DESTINATION, AST_CAUSE_PROTOCOL_ERROR, AST_CAUSE_REQUESTED_CHAN_UNAVAIL, ast_channel_unlock, ast_channel_unref, AST_CONTROL_PROCEEDING, ast_copy_string(), ast_queue_control(), ast_rtp_instance_get_ice(), ast_strlen_zero(), end, error(), jingle_outgoing_hook(), jingle_queue_hangup_with_cause(), jingle_send_session_initiate(), jingle_send_transport_info(), jingle_session_lock_full(), JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_GOOGLE_V2, JINGLE_TRANSPORT_NONE, NULL, session, ast_rtp_engine_ice::start, ast_rtp_engine_ice::stop, and XMPP_STANZAS_NS.

Referenced by jingle_call(), and jingle_outgoing_hook().

jingle_queue_hangup_with_cause()

static void jingle_queue_hangup_with_cause ( struct jingle_session *  session, int  cause  )

static

Helper function which queues a hangup frame with cause code.

Definition at line 1239 of file chan_motif.c.

{
    struct ast_channel *chan;
 
    if ((chan = jingle_session_lock_full(session))) {
        ast_debug(3, "Hanging up channel '%s' with cause '%d'\n", ast_channel_name(chan), cause);
        ast_queue_hangup_with_cause(chan, cause);
        ast_channel_unlock(chan);
        ast_channel_unref(chan);
    }
    ao2_unlock(session);
}

References ao2_unlock, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_debug, ast_queue_hangup_with_cause(), jingle_session_lock_full(), and session.

Referenced by jingle_interpret_content(), jingle_interpret_description(), jingle_interpret_google_transport(), jingle_interpret_ice_udp_transport(), jingle_outgoing_hook(), jingle_send_session_action(), and jingle_send_transport_info().

jingle_read()

static struct ast_frame * jingle_read ( struct ast_channel *  ast )

static

Function called by core to read any waiting frames.

Definition at line 1682 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(ast);
    struct ast_frame *frame = &ast_null_frame;
 
    switch (ast_channel_fdno(ast)) {
    case 0:
        if (session->rtp) {
            frame = ast_rtp_instance_read(session->rtp, 0);
        }
        break;
    case 1:
        if (session->rtp) {
            frame = ast_rtp_instance_read(session->rtp, 1);
        }
        break;
    case 2:
        if (session->vrtp) {
            frame = ast_rtp_instance_read(session->vrtp, 0);
        }
        break;
    case 3:
        if (session->vrtp) {
            frame = ast_rtp_instance_read(session->vrtp, 1);
        }
        break;
    default:
        break;
    }
 
    if (frame && frame->frametype == AST_FRAME_VOICE &&
        ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), frame->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL) {
        if (ast_format_cap_iscompatible_format(session->jointcap, frame->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL) {
            ast_debug(1, "Bogus frame of format '%s' received from '%s'!\n",
                  ast_format_get_name(frame->subclass.format), ast_channel_name(ast));
            ast_frfree(frame);
            frame = &ast_null_frame;
        } else {
            struct ast_format_cap *caps;
 
            ast_debug(1, "Oooh, format changed to %s\n",
                  ast_format_get_name(frame->subclass.format));
 
            caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
            if (caps) {
                ast_format_cap_append(caps, frame->subclass.format, 0);
                ast_channel_nativeformats_set(ast, caps);
                ao2_ref(caps, -1);
            }
            ast_set_read_format(ast, ast_channel_readformat(ast));
            ast_set_write_format(ast, ast_channel_writeformat(ast));
        }
    }
 
    return frame;
}

References ao2_ref, ast_channel_fdno(), ast_channel_name(), ast_channel_nativeformats(), ast_channel_nativeformats_set(), ast_channel_readformat(), ast_channel_tech_pvt(), ast_channel_writeformat(), ast_debug, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_iscompatible_format(), AST_FORMAT_CMP_NOT_EQUAL, ast_format_get_name(), AST_FRAME_VOICE, ast_frfree, ast_null_frame, ast_rtp_instance_read(), ast_set_read_format(), ast_set_write_format(), ast_frame_subclass::format, ast_frame::frametype, session, and ast_frame::subclass.

jingle_request()

static struct ast_channel * jingle_request ( const char *  type, struct ast_format_cap *  cap, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor, const char *  data, int *  cause  )

static

Asterisk core interaction functions.

Function called by core to create a new outgoing Jingle session.

Definition at line 1946 of file chan_motif.c.

{
    RAII_VAR(struct jingle_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
    RAII_VAR(struct jingle_endpoint *, endpoint, NULL, ao2_cleanup);
    char *dialed, target[1024] = "";
    struct ast_xmpp_buddy *buddy;
    struct jingle_session *session;
    struct ast_channel *chan;
    enum jingle_transport transport = JINGLE_TRANSPORT_NONE;
    struct ast_rtp_engine_ice *ice;
    AST_DECLARE_APP_ARGS(args,
                 AST_APP_ARG(name);
                 AST_APP_ARG(target);
        );
 
    /* We require at a minimum one audio format to be requested */
    if (!ast_format_cap_has_type(cap, AST_MEDIA_TYPE_AUDIO)) {
        ast_log(LOG_ERROR, "Motif channel driver requires an audio format when dialing a destination\n");
        *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
        return NULL;
    }
 
    if (ast_strlen_zero(data) || !(dialed = ast_strdupa(data))) {
        ast_log(LOG_ERROR, "Unable to create channel with empty destination.\n");
        *cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
        return NULL;
    }
 
    /* Parse the given dial string and validate the results */
    AST_NONSTANDARD_APP_ARGS(args, dialed, '/');
 
    if (ast_strlen_zero(args.name) || ast_strlen_zero(args.target)) {
        ast_log(LOG_ERROR, "Unable to determine endpoint name and target.\n");
        *cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
        return NULL;
    }
 
    if (!(endpoint = jingle_endpoint_find(cfg->endpoints, args.name))) {
        ast_log(LOG_ERROR, "Endpoint '%s' does not exist.\n", args.name);
        *cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
        return NULL;
    }
 
    ao2_lock(endpoint->state);
 
    /* If we don't have a connection for the endpoint we can't exactly start a session on it */
    if (!endpoint->connection) {
        ast_log(LOG_ERROR, "Unable to create Jingle session on endpoint '%s' as no valid connection exists\n", args.name);
        *cause = AST_CAUSE_SWITCH_CONGESTION;
        ao2_unlock(endpoint->state);
        return NULL;
    }
 
    /* Find the target in the roster so we can choose a resource */
    if ((buddy = ao2_find(endpoint->connection->buddies, args.target, OBJ_KEY))) {
        struct ao2_iterator res;
        struct ast_xmpp_resource *resource;
 
        /* Iterate through finding the first viable Jingle capable resource */
        res = ao2_iterator_init(buddy->resources, 0);
        while ((resource = ao2_iterator_next(&res))) {
            if (resource->caps.jingle) {
                snprintf(target, sizeof(target), "%s/%s", args.target, resource->resource);
                transport = JINGLE_TRANSPORT_ICE_UDP;
                break;
            } else if (resource->caps.google) {
                snprintf(target, sizeof(target), "%s/%s", args.target, resource->resource);
                transport = JINGLE_TRANSPORT_GOOGLE_V2;
                break;
            }
            ao2_ref(resource, -1);
        }
        ao2_iterator_destroy(&res);
 
        ao2_ref(buddy, -1);
    } else {
        /* If the target is NOT in the roster use the provided target as-is */
        ast_copy_string(target, args.target, sizeof(target));
    }
 
    ao2_unlock(endpoint->state);
 
    /* If no target was found we can't set up a session */
    if (ast_strlen_zero(target)) {
        ast_log(LOG_ERROR, "Unable to create Jingle session on endpoint '%s' as no capable resource for target '%s' was found\n", args.name, args.target);
        *cause = AST_CAUSE_SWITCH_CONGESTION;
        return NULL;
    }
 
    if (!(session = jingle_alloc(endpoint, target, NULL))) {
        ast_log(LOG_ERROR, "Unable to create Jingle session on endpoint '%s'\n", args.name);
        *cause = AST_CAUSE_SWITCH_CONGESTION;
        return NULL;
    }
 
    /* Update the transport if we learned what we should actually use */
    if (transport != JINGLE_TRANSPORT_NONE) {
        session->transport = transport;
        /* Note that for Google-V1 and Google-V2 we don't stop built-in ICE support, this will happen in jingle_new */
    }
 
    if (!(chan = jingle_new(endpoint, session, AST_STATE_DOWN, target, assignedids, requestor, NULL))) {
        ast_log(LOG_ERROR, "Unable to create Jingle channel on endpoint '%s'\n", args.name);
        *cause = AST_CAUSE_SWITCH_CONGESTION;
        ao2_ref(session, -1);
        return NULL;
    }
 
    /* If video was requested try to enable it on the session */
    if (ast_format_cap_has_type(cap, AST_MEDIA_TYPE_VIDEO)) {
        jingle_enable_video(session);
    }
 
    /* As this is outgoing set ourselves as controlling */
    if (session->rtp && (ice = ast_rtp_instance_get_ice(session->rtp))) {
        ice->ice_lite(session->rtp);
    }
 
    if (session->vrtp && (ice = ast_rtp_instance_get_ice(session->vrtp))) {
        ice->ice_lite(session->vrtp);
    }
 
    /* We purposely don't decrement the session here as there is a reference on the channel */
    ao2_link(endpoint->state->sessions, session);
 
    return chan;
}

References ao2_cleanup, ao2_find, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_link, ao2_lock, ao2_ref, ao2_unlock, args, AST_APP_ARG, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_CHANNEL_UNACCEPTABLE, AST_CAUSE_SWITCH_CONGESTION, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_format_cap_has_type(), ast_log, AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, AST_NONSTANDARD_APP_ARGS, ast_rtp_instance_get_ice(), AST_STATE_DOWN, ast_strdupa, ast_strlen_zero(), ast_channel::dialed, ast_channel::endpoint, globals, ast_rtp_engine_ice::ice_lite, jingle_alloc(), jingle_enable_video(), jingle_endpoint_find(), jingle_new(), JINGLE_TRANSPORT_GOOGLE_V2, JINGLE_TRANSPORT_ICE_UDP, JINGLE_TRANSPORT_NONE, LOG_ERROR, name, NULL, OBJ_KEY, RAII_VAR, ast_xmpp_resource::resource, ast_xmpp_buddy::resources, session, and ast_rtp_engine_ice::start.

jingle_send_error_response()

static void jingle_send_error_response ( struct ast_xmpp_client *  connection, ikspak *  pak, const char *  type, const char *  reasonstr, const char *  reasonstr2  )

static

Internal helper function which sends an error response.

Definition at line 926 of file chan_motif.c.

{
    iks *response, *error = NULL, *reason = NULL, *reason2 = NULL;
 
    if (!(response = iks_new("iq")) ||
        !(error = iks_new("error")) ||
        !(reason = iks_new(reasonstr))) {
        ast_log(LOG_ERROR, "Unable to allocate IKS error response stanzas\n");
        goto end;
    }
 
    iks_insert_attrib(response, "type", "error");
    iks_insert_attrib(response, "from", connection->jid->full);
    iks_insert_attrib(response, "to", iks_find_attrib(pak->x, "from"));
    iks_insert_attrib(response, "id", iks_find_attrib(pak->x, "id"));
 
    iks_insert_attrib(error, "type", type);
    iks_insert_node(error, reason);
 
    if (!ast_strlen_zero(reasonstr2) && (reason2 = iks_new(reasonstr2))) {
        iks_insert_node(error, reason2);
    }
 
    iks_insert_node(response, error);
 
    ast_xmpp_client_send(connection, response);
end:
    iks_delete(reason2);
    iks_delete(reason);
    iks_delete(error);
    iks_delete(response);
}

References ast_log, ast_strlen_zero(), ast_xmpp_client_send(), end, error(), ast_xmpp_client::jid, LOG_ERROR, NULL, ast_rtp_engine_ice::start, and type.

Referenced by jingle_action_session_accept(), jingle_action_session_info(), jingle_action_session_initiate(), jingle_action_session_terminate(), and jingle_action_transport_info().

jingle_send_response()

static void jingle_send_response ( struct ast_xmpp_client *  connection, ikspak *  pak  )

static

Internal helper function which sends a response.

Definition at line 906 of file chan_motif.c.

{
    iks *response;
 
    if (!(response = iks_new("iq"))) {
        ast_log(LOG_ERROR, "Unable to allocate an IKS response stanza\n");
        return;
    }
 
    iks_insert_attrib(response, "type", "result");
    iks_insert_attrib(response, "from", connection->jid->full);
    iks_insert_attrib(response, "to", iks_find_attrib(pak->x, "from"));
    iks_insert_attrib(response, "id", iks_find_attrib(pak->x, "id"));
 
    ast_xmpp_client_send(connection, response);
 
    iks_delete(response);
}

References ast_log, ast_xmpp_client_send(), ast_xmpp_client::jid, LOG_ERROR, and ast_rtp_engine_ice::start.

Referenced by jingle_action_session_accept(), jingle_action_session_info(), jingle_action_session_initiate(), jingle_action_session_terminate(), and jingle_action_transport_info().

jingle_send_session_accept()

static void jingle_send_session_accept ( struct jingle_session *  session )

static

Internal function which sends a session-accept message.

Definition at line 1560 of file chan_motif.c.

{
    jingle_send_session_action(session, session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "accept" : "session-accept");
}

References jingle_send_session_action(), JINGLE_TRANSPORT_GOOGLE_V1, and session.

Referenced by jingle_answer().

jingle_send_session_action()

static void jingle_send_session_action ( struct jingle_session *  session, const char *  action  )

static

Internal function which sends a complete session message.

Definition at line 1472 of file chan_motif.c.

{
    iks *iq, *jingle, *audio = NULL, *audio_description = NULL, *video = NULL, *video_description = NULL;
    iks *audio_payloads[session->maxpayloads], *video_payloads[session->maxpayloads];
    iks *audio_transport = NULL, *video_transport = NULL;
    int i, res = 0;
 
    if (!(iq = iks_new("iq")) ||
        !(jingle = iks_new(session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "session" : "jingle"))) {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
        iks_delete(iq);
        return;
    }
 
    memset(audio_payloads, 0, sizeof(audio_payloads));
    memset(video_payloads, 0, sizeof(video_payloads));
 
    iks_insert_attrib(iq, "from", session->connection->jid->full);
    iks_insert_attrib(iq, "to", session->remote);
    iks_insert_attrib(iq, "type", "set");
    iks_insert_attrib(iq, "id", session->connection->mid);
    ast_xmpp_increment_mid(session->connection->mid);
 
    if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
        iks_insert_attrib(jingle, "type", action);
        iks_insert_attrib(jingle, "id", session->sid);
        iks_insert_attrib(jingle, "xmlns", GOOGLE_SESSION_NS);
    } else {
        iks_insert_attrib(jingle, "action", action);
        iks_insert_attrib(jingle, "sid", session->sid);
        iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
    }
 
    if (!strcasecmp(action, "session-initiate") || !strcasecmp(action, "initiate") || !strcasecmp(action, "accept")) {
        iks_insert_attrib(jingle, "initiator", session->outgoing ? session->connection->jid->full : session->remote);
    }
 
    iks_insert_node(iq, jingle);
 
    if (session->rtp && (audio = iks_new("content")) && (audio_description = iks_new("description")) &&
        (audio_transport = iks_new("transport"))) {
        res = jingle_add_content(session, jingle, audio, audio_description, audio_transport, session->audio_name,
                     AST_MEDIA_TYPE_AUDIO, session->rtp, audio_payloads);
    } else {
        ast_log(LOG_ERROR, "Failed to allocate audio content stanzas for session '%s', hanging up\n", session->sid);
        res = -1;
    }
 
    if ((session->transport != JINGLE_TRANSPORT_GOOGLE_V1) && !res && session->vrtp) {
        if ((video = iks_new("content")) && (video_description = iks_new("description")) &&
            (video_transport = iks_new("transport"))) {
            res = jingle_add_content(session, jingle, video, video_description, video_transport, session->video_name,
                         AST_MEDIA_TYPE_VIDEO, session->vrtp, video_payloads);
        } else {
            ast_log(LOG_ERROR, "Failed to allocate video content stanzas for session '%s', hanging up\n", session->sid);
            res = -1;
        }
    }
 
    if (!res) {
        ast_xmpp_client_send(session->connection, iq);
    } else {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
    }
 
    iks_delete(video_transport);
    iks_delete(audio_transport);
 
    for (i = 0; i < session->maxpayloads; i++) {
        iks_delete(video_payloads[i]);
        iks_delete(audio_payloads[i]);
    }
 
    iks_delete(video_description);
    iks_delete(video);
    iks_delete(audio_description);
    iks_delete(audio);
    iks_delete(jingle);
    iks_delete(iq);
}

References AST_CAUSE_SWITCH_CONGESTION, ast_log, AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_xmpp_client_send(), ast_xmpp_increment_mid(), GOOGLE_SESSION_NS, jingle_add_content(), JINGLE_NS, jingle_queue_hangup_with_cause(), JINGLE_TRANSPORT_GOOGLE_V1, LOG_ERROR, NULL, and session.

Referenced by jingle_send_session_accept(), and jingle_send_session_initiate().

jingle_send_session_info()

static void jingle_send_session_info ( struct jingle_session *  session, const char *  info  )

static

Internal function which sends a session-info message.

Definition at line 1140 of file chan_motif.c.

{
    iks *iq = NULL, *jingle = NULL, *text = NULL;
 
    /* Google-V1 has no way to send informational messages so don't even bother trying */
    if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
        return;
    }
 
    if (!(iq = iks_new("iq")) || !(jingle = iks_new("jingle")) || !(text = iks_new(info))) {
        ast_log(LOG_ERROR, "Failed to allocate stanzas for session-info message on session '%s'\n", session->sid);
        goto end;
    }
 
    iks_insert_attrib(iq, "to", session->remote);
    iks_insert_attrib(iq, "type", "set");
    iks_insert_attrib(iq, "id", session->connection->mid);
    ast_xmpp_increment_mid(session->connection->mid);
 
    iks_insert_attrib(jingle, "action", "session-info");
    iks_insert_attrib(jingle, "sid", session->sid);
    iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
    iks_insert_node(iq, jingle);
    iks_insert_node(jingle, text);
 
    ast_xmpp_client_send(session->connection, iq);
 
end:
    iks_delete(text);
    iks_delete(jingle);
    iks_delete(iq);
}

References ast_log, ast_xmpp_client_send(), ast_xmpp_increment_mid(), end, JINGLE_NS, JINGLE_TRANSPORT_GOOGLE_V1, LOG_ERROR, NULL, session, and text.

Referenced by jingle_indicate().

jingle_send_session_initiate()

static void jingle_send_session_initiate ( struct jingle_session *  session )

static

Internal function which sends a session-initiate message.

Definition at line 1554 of file chan_motif.c.

{
    jingle_send_session_action(session, session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "initiate" : "session-initiate");
}

References jingle_send_session_action(), JINGLE_TRANSPORT_GOOGLE_V1, and session.

Referenced by jingle_call(), and jingle_outgoing_hook().

jingle_send_session_terminate()

static void jingle_send_session_terminate ( struct jingle_session *  session, const char *  reasontext  )

static

Internal function which sends a session-terminate message.

Definition at line 1100 of file chan_motif.c.

{
    iks *iq = NULL, *jingle = NULL, *reason = NULL, *text = NULL;
 
    if (!(iq = iks_new("iq")) || !(jingle = iks_new(session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "session" : "jingle")) ||
        !(reason = iks_new("reason")) || !(text = iks_new(reasontext))) {
        ast_log(LOG_ERROR, "Failed to allocate stanzas for session-terminate message on session '%s'\n", session->sid);
        goto end;
    }
 
    iks_insert_attrib(iq, "to", session->remote);
    iks_insert_attrib(iq, "type", "set");
    iks_insert_attrib(iq, "id", session->connection->mid);
    ast_xmpp_increment_mid(session->connection->mid);
 
    if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
        iks_insert_attrib(jingle, "type", "terminate");
        iks_insert_attrib(jingle, "id", session->sid);
        iks_insert_attrib(jingle, "xmlns", GOOGLE_SESSION_NS);
        iks_insert_attrib(jingle, "initiator", session->outgoing ? session->connection->jid->full : session->remote);
    } else {
        iks_insert_attrib(jingle, "action", "session-terminate");
        iks_insert_attrib(jingle, "sid", session->sid);
        iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
    }
 
    iks_insert_node(iq, jingle);
    iks_insert_node(jingle, reason);
    iks_insert_node(reason, text);
 
    ast_xmpp_client_send(session->connection, iq);
 
end:
    iks_delete(text);
    iks_delete(reason);
    iks_delete(jingle);
    iks_delete(iq);
}

References ast_log, ast_xmpp_client_send(), ast_xmpp_increment_mid(), end, GOOGLE_SESSION_NS, JINGLE_NS, JINGLE_TRANSPORT_GOOGLE_V1, LOG_ERROR, NULL, session, and text.

Referenced by jingle_hangup().

jingle_send_transport_info()

static void jingle_send_transport_info ( struct jingle_session *  session, const char *  from  )

static

Internal function which sends a transport-info message.

Definition at line 1253 of file chan_motif.c.

{
    iks *iq, *jingle = NULL, *audio = NULL, *audio_transport = NULL, *video = NULL, *video_transport = NULL;
    iks *audio_candidates[session->maxicecandidates], *video_candidates[session->maxicecandidates];
    int i, res = 0;
 
    if (!(iq = iks_new("iq")) ||
        !(jingle = iks_new(session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "session" : "jingle"))) {
        iks_delete(iq);
        jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
        ast_log(LOG_ERROR, "Failed to allocate stanzas for transport-info message, hanging up session '%s'\n", session->sid);
        return;
    }
 
    memset(audio_candidates, 0, sizeof(audio_candidates));
    memset(video_candidates, 0, sizeof(video_candidates));
 
    iks_insert_attrib(iq, "from", session->connection->jid->full);
    iks_insert_attrib(iq, "to", from);
    iks_insert_attrib(iq, "type", "set");
    iks_insert_attrib(iq, "id", session->connection->mid);
    ast_xmpp_increment_mid(session->connection->mid);
 
    if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
        iks_insert_attrib(jingle, "type", "candidates");
        iks_insert_attrib(jingle, "id", session->sid);
        iks_insert_attrib(jingle, "xmlns", GOOGLE_SESSION_NS);
        iks_insert_attrib(jingle, "initiator", session->outgoing ? session->connection->jid->full : from);
    } else {
        iks_insert_attrib(jingle, "action", "transport-info");
        iks_insert_attrib(jingle, "sid", session->sid);
        iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
    }
    iks_insert_node(iq, jingle);
 
    if (session->rtp) {
        if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
            /* V1 protocol has the candidates directly in the session */
            res = jingle_add_google_candidates_to_transport(session->rtp, jingle, audio_candidates, 0, session->transport, session->maxicecandidates);
        } else if ((audio = iks_new("content")) && (audio_transport = iks_new("transport"))) {
            iks_insert_attrib(audio, "creator", session->outgoing ? "initiator" : "responder");
            iks_insert_attrib(audio, "name", session->audio_name);
            iks_insert_node(jingle, audio);
            iks_insert_node(audio, audio_transport);
 
            if (session->transport == JINGLE_TRANSPORT_ICE_UDP) {
                res = jingle_add_ice_udp_candidates_to_transport(session->rtp, audio_transport, audio_candidates, session->maxicecandidates);
            } else if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2) {
                res = jingle_add_google_candidates_to_transport(session->rtp, audio_transport, audio_candidates, 0, session->transport,
                                        session->maxicecandidates);
            }
        } else {
            res = -1;
        }
    }
 
    if ((session->transport != JINGLE_TRANSPORT_GOOGLE_V1) && !res && session->vrtp) {
        if ((video = iks_new("content")) && (video_transport = iks_new("transport"))) {
            iks_insert_attrib(video, "creator", session->outgoing ? "initiator" : "responder");
            iks_insert_attrib(video, "name", session->video_name);
            iks_insert_node(jingle, video);
            iks_insert_node(video, video_transport);
 
            if (session->transport == JINGLE_TRANSPORT_ICE_UDP) {
                res = jingle_add_ice_udp_candidates_to_transport(session->vrtp, video_transport, video_candidates, session->maxicecandidates);
            } else if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2) {
                res = jingle_add_google_candidates_to_transport(session->vrtp, video_transport, video_candidates, 1, session->transport,
                                        session->maxicecandidates);
            }
        } else {
            res = -1;
        }
    }
 
    if (!res) {
        ast_xmpp_client_send(session->connection, iq);
    } else {
        jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
    }
 
    /* Clean up after ourselves */
    for (i = 0; i < session->maxicecandidates; i++) {
        iks_delete(video_candidates[i]);
        iks_delete(audio_candidates[i]);
    }
 
    iks_delete(video_transport);
    iks_delete(video);
    iks_delete(audio_transport);
    iks_delete(audio);
    iks_delete(jingle);
    iks_delete(iq);
}

References AST_CAUSE_SWITCH_CONGESTION, ast_log, ast_xmpp_client_send(), ast_xmpp_increment_mid(), GOOGLE_SESSION_NS, jingle_add_google_candidates_to_transport(), jingle_add_ice_udp_candidates_to_transport(), JINGLE_NS, jingle_queue_hangup_with_cause(), JINGLE_TRANSPORT_GOOGLE_V1, JINGLE_TRANSPORT_GOOGLE_V2, JINGLE_TRANSPORT_ICE_UDP, LOG_ERROR, NULL, and session.

Referenced by jingle_action_session_initiate(), and jingle_outgoing_hook().

jingle_sendtext()

static int jingle_sendtext ( struct ast_channel *  ast, const char *  text  )

static

Function called by core to send text to the remote party of the Jingle session.

Definition at line 1860 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(chan);
 
    return ast_xmpp_client_send_message(session->connection, session->remote, text);
}

References ast_channel_tech_pvt(), ast_xmpp_client_send_message(), session, and text.

jingle_session_cmp()

static int jingle_session_cmp ( void *  obj, void *  arg, int  flags  )

static

Comparator function for Jingle sessions.

Definition at line 466 of file chan_motif.c.

{
    struct jingle_session *session1 = obj, *session2 = arg;
    const char *sid = arg;
 
    return !strcmp(session1->sid, flags & OBJ_KEY ? sid : session2->sid) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, OBJ_KEY, and jingle_session::sid.

Referenced by jingle_endpoint_state_create().

jingle_session_destructor()

static void jingle_session_destructor ( void *  obj )

static

Destructor for Jingle sessions.

Definition at line 603 of file chan_motif.c.

{
    struct jingle_session *session = obj;
 
    if (session->rule) {
        iks_filter_remove_rule(session->connection->filter, session->rule);
    }
 
    if (session->connection) {
        ast_xmpp_client_unref(session->connection);
    }
 
    if (session->rtp) {
        ast_rtp_instance_stop(session->rtp);
        ast_rtp_instance_destroy(session->rtp);
    }
 
    if (session->vrtp) {
        ast_rtp_instance_stop(session->vrtp);
        ast_rtp_instance_destroy(session->vrtp);
    }
 
    ao2_cleanup(session->cap);
    ao2_cleanup(session->jointcap);
    ao2_cleanup(session->peercap);
 
    ast_string_field_free_memory(session);
}

References ao2_cleanup, ast_rtp_instance_destroy(), ast_rtp_instance_stop(), ast_string_field_free_memory, ast_xmpp_client_unref(), and session.

Referenced by jingle_alloc().

jingle_session_hash()

static int jingle_session_hash ( const void *  obj, const int  flags  )

static

Hashing function for Jingle sessions.

Definition at line 457 of file chan_motif.c.

{
    const struct jingle_session *session = obj;
    const char *sid = obj;
 
    return ast_str_hash(flags & OBJ_KEY ? sid : session->sid);
}

References ast_str_hash(), OBJ_KEY, session, and jingle_session::sid.

Referenced by jingle_endpoint_state_create().

jingle_session_lock_full()

static struct ast_channel * jingle_session_lock_full ( struct jingle_session *  pvt )

static

Definition at line 1190 of file chan_motif.c.

{
    struct ast_channel *chan;
 
    /* Locking is simple when it is done right.  If you see a deadlock resulting
     * in this function, it is not this function's fault, Your problem exists elsewhere.
     * This function is perfect... seriously. */
    for (;;) {
        /* First, get the channel and grab a reference to it */
        ao2_lock(pvt);
        chan = pvt->owner;
        if (chan) {
            /* The channel can not go away while we hold the pvt lock.
             * Give the channel a ref so it will not go away after we let
             * the pvt lock go. */
            ast_channel_ref(chan);
        } else {
            /* no channel, return pvt locked */
            return NULL;
        }
 
        /* We had to hold the pvt lock while getting a ref to the owner channel
         * but now we have to let this lock go in order to preserve proper
         * locking order when grabbing the channel lock */
        ao2_unlock(pvt);
 
        /* Look, no deadlock avoidance, hooray! */
        ast_channel_lock(chan);
        ao2_lock(pvt);
        if (pvt->owner == chan) {
            /* done */
            break;
        }
 
        /* If the owner changed while everything was unlocked, no problem,
         * just start over and everything will work.  This is rare, do not be
         * confused by this loop and think this it is an expensive operation.
         * The majority of the calls to this function will never involve multiple
         * executions of this loop. */
        ast_channel_unlock(chan);
        ast_channel_unref(chan);
        ao2_unlock(pvt);
    }
 
    /* If owner exists, it is locked and reffed */
    return pvt->owner;
}

References ao2_lock, ao2_unlock, ast_channel_lock, ast_channel_ref, ast_channel_unlock, ast_channel_unref, NULL, and jingle_session::owner.

Referenced by jingle_action_session_accept(), jingle_action_session_info(), jingle_action_session_terminate(), jingle_interpret_content(), jingle_outgoing_hook(), and jingle_queue_hangup_with_cause().

jingle_set_owner()

static void jingle_set_owner ( struct jingle_session *  session, struct ast_channel *  chan  )

static

Set the channel owner on the jingle_session object and related objects.

Definition at line 698 of file chan_motif.c.

{
    session->owner = chan;
    if (session->rtp) {
        ast_rtp_instance_set_channel_id(session->rtp, session->owner ? ast_channel_uniqueid(session->owner) : "");
    }
    if (session->vrtp) {
        ast_rtp_instance_set_channel_id(session->vrtp, session->owner ? ast_channel_uniqueid(session->owner) : "");
    }
}

References ast_channel_uniqueid(), ast_rtp_instance_set_channel_id(), and session.

Referenced by jingle_fixup(), jingle_hangup(), and jingle_new().

jingle_set_rtp_peer()

static int jingle_set_rtp_peer ( struct ast_channel *  chan, struct ast_rtp_instance *  rtp, struct ast_rtp_instance *  vrtp, struct ast_rtp_instance *  tpeer, const struct ast_format_cap *  cap, int  nat_active  )

static

Function called by RTP engine to change where the remote party should send media.

Definition at line 684 of file chan_motif.c.

{
    return -1;
}

jingle_write()

static int jingle_write ( struct ast_channel *  ast, struct ast_frame *  f  )

static

Function called by core to write frames.

Definition at line 1740 of file chan_motif.c.

{
    struct jingle_session *session = ast_channel_tech_pvt(ast);
    int res = 0;
 
    switch (frame->frametype) {
    case AST_FRAME_VOICE:
        if (ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), frame->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL) {
            struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
            ast_log(LOG_WARNING,
                "Asked to transmit frame type %s, while native formats is %s (read/write = %s/%s)\n",
                ast_format_get_name(frame->subclass.format),
                ast_format_cap_get_names(ast_channel_nativeformats(ast), &codec_buf),
                ast_format_get_name(ast_channel_readformat(ast)),
                ast_format_get_name(ast_channel_writeformat(ast)));
            return 0;
        }
        if (session && session->rtp) {
            res = ast_rtp_instance_write(session->rtp, frame);
        }
        break;
    case AST_FRAME_VIDEO:
        if (session && session->vrtp) {
            res = ast_rtp_instance_write(session->vrtp, frame);
        }
        break;
    default:
        ast_log(LOG_WARNING, "Can't send %u type frames with Jingle write\n",
            frame->frametype);
        return 0;
    }
 
    return res;
}

References ast_channel_nativeformats(), ast_channel_readformat(), ast_channel_tech_pvt(), ast_channel_writeformat(), ast_format_cap_get_names(), ast_format_cap_iscompatible_format(), AST_FORMAT_CAP_NAMES_LEN, AST_FORMAT_CMP_NOT_EQUAL, ast_format_get_name(), AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_log, ast_rtp_instance_write(), ast_str_alloca, ast_frame_subclass::format, ast_frame::frametype, LOG_WARNING, session, and ast_frame::subclass.

load_module()

static int load_module ( void  )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 2769 of file chan_motif.c.

{
    if (!(jingle_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (aco_info_init(&cfg_info)) {
        ast_log(LOG_ERROR, "Unable to initialize configuration for chan_motif.\n");
        goto end;
    }
 
    aco_option_register(&cfg_info, "context", ACO_EXACT, endpoint_options, "default", OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, context));
    aco_option_register_custom(&cfg_info, "callgroup", ACO_EXACT, endpoint_options, NULL, custom_group_handler, 0);
    aco_option_register_custom(&cfg_info, "pickupgroup", ACO_EXACT, endpoint_options, NULL, custom_group_handler, 0);
    aco_option_register(&cfg_info, "language", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, language));
    aco_option_register(&cfg_info, "musicclass", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, musicclass));
    aco_option_register(&cfg_info, "parkinglot", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, parkinglot));
    aco_option_register(&cfg_info, "accountcode", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, accountcode));
    aco_option_register(&cfg_info, "allow", ACO_EXACT, endpoint_options, "ulaw,alaw", OPT_CODEC_T, 1, FLDSET(struct jingle_endpoint, cap));
    aco_option_register(&cfg_info, "disallow", ACO_EXACT, endpoint_options, "all", OPT_CODEC_T, 0, FLDSET(struct jingle_endpoint, cap));
    aco_option_register_custom(&cfg_info, "connection", ACO_EXACT, endpoint_options, NULL, custom_connection_handler, 0);
    aco_option_register_custom(&cfg_info, "transport", ACO_EXACT, endpoint_options, NULL, custom_transport_handler, 0);
    aco_option_register(&cfg_info, "maxicecandidates", ACO_EXACT, endpoint_options, DEFAULT_MAX_ICE_CANDIDATES, OPT_UINT_T, PARSE_DEFAULT,
                FLDSET(struct jingle_endpoint, maxicecandidates), DEFAULT_MAX_ICE_CANDIDATES);
    aco_option_register(&cfg_info, "maxpayloads", ACO_EXACT, endpoint_options, DEFAULT_MAX_PAYLOADS, OPT_UINT_T, PARSE_DEFAULT,
                FLDSET(struct jingle_endpoint, maxpayloads), DEFAULT_MAX_PAYLOADS);
 
    ast_format_cap_append_by_type(jingle_tech.capabilities, AST_MEDIA_TYPE_AUDIO);
 
    if (aco_process_config(&cfg_info, 0)) {
        ast_log(LOG_ERROR, "Unable to read config file motif.conf. Module loaded but not running.\n");
        aco_info_destroy(&cfg_info);
        ao2_cleanup(jingle_tech.capabilities);
        jingle_tech.capabilities = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (!(sched = ast_sched_context_create())) {
        ast_log(LOG_ERROR, "Unable to create scheduler context.\n");
        goto end;
    }
 
    if (ast_sched_start_thread(sched)) {
        ast_log(LOG_ERROR, "Unable to create scheduler context thread.\n");
        goto end;
    }
 
    ast_rtp_glue_register(&jingle_rtp_glue);
 
    if (ast_channel_register(&jingle_tech)) {
        ast_log(LOG_ERROR, "Unable to register channel class %s\n", channel_type);
        goto end;
    }
 
    return 0;
 
end:
    ast_rtp_glue_unregister(&jingle_rtp_glue);
 
    if (sched) {
        ast_sched_context_destroy(sched);
    }
 
    aco_info_destroy(&cfg_info);
    ao2_global_obj_release(globals);
 
    ao2_cleanup(jingle_tech.capabilities);
    jingle_tech.capabilities = NULL;
 
    return AST_MODULE_LOAD_DECLINE;
}

References accountcode, ACO_EXACT, aco_info_destroy(), aco_info_init(), aco_option_register, aco_option_register_custom, aco_process_config(), ao2_cleanup, ao2_global_obj_release, ast_channel_register(), ast_format_cap_alloc, ast_format_cap_append_by_type(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_log, AST_MEDIA_TYPE_AUDIO, AST_MODULE_LOAD_DECLINE, ast_rtp_glue_register, ast_rtp_glue_unregister(), ast_sched_context_create(), ast_sched_context_destroy(), ast_sched_start_thread(), jingle_endpoint::cap, ast_channel_tech::capabilities, channel_type, jingle_endpoint::context, custom_connection_handler(), custom_group_handler(), custom_transport_handler(), DEFAULT_MAX_ICE_CANDIDATES, DEFAULT_MAX_PAYLOADS, end, endpoint_options, FLDSET, globals, jingle_rtp_glue, jingle_tech, language, LOG_ERROR, jingle_endpoint::maxicecandidates, jingle_endpoint::maxpayloads, jingle_endpoint::musicclass, NULL, OPT_CODEC_T, OPT_STRINGFIELD_T, OPT_UINT_T, jingle_endpoint::parkinglot, PARSE_DEFAULT, and STRFLDSET.

reload()

static int reload ( void  )

static

Reload module.

Definition at line 2842 of file chan_motif.c.

{
    if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) {
        return -1;
    }
 
    return 0;
}

References aco_process_config(), and ACO_PROCESS_ERROR.

unload_module()

static int unload_module ( void  )

static

Unload the jingle channel from Asterisk.

Definition at line 2852 of file chan_motif.c.

{
    ast_channel_unregister(&jingle_tech);
    ao2_cleanup(jingle_tech.capabilities);
    jingle_tech.capabilities = NULL;
    ast_rtp_glue_unregister(&jingle_rtp_glue);
    ast_sched_context_destroy(sched);
    aco_info_destroy(&cfg_info);
    ao2_global_obj_release(globals);
 
    return 0;
}

References aco_info_destroy(), ao2_cleanup, ao2_global_obj_release, ast_channel_unregister(), ast_rtp_glue_unregister(), ast_sched_context_destroy(), ast_channel_tech::capabilities, globals, jingle_rtp_glue, jingle_tech, and NULL.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Motif Jingle Channel Driver" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, .requires = "res_xmpp", }

static

Definition at line 2872 of file chan_motif.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2872 of file chan_motif.c.

channel_type

const char channel_type[] = "Motif"

static

Definition at line 363 of file chan_motif.c.

Referenced by load_module().

endpoint_option

struct aco_type endpoint_option

static

Definition at line 585 of file chan_motif.c.

                                         {
    .type = ACO_ITEM,
    .name = "endpoint",
    .category_match = ACO_BLACKLIST_EXACT,
    .category = "general",
    .item_alloc = jingle_endpoint_alloc,
    .item_find = jingle_endpoint_find,
    .item_offset = offsetof(struct jingle_config, endpoints),
};

endpoint_options

struct aco_type* endpoint_options[] = ACO_TYPES(&endpoint_option)

Definition at line 595 of file chan_motif.c.

Referenced by load_module().

jingle_action_handlers

const struct jingle_action_handler jingle_action_handlers[]

static

Referenced by jingle_action_hook().

jingle_conf

struct aco_file jingle_conf

Initial value:

= {
    .filename = "motif.conf",
    .types = ACO_TYPES(&endpoint_option),
}

Definition at line 597 of file chan_motif.c.

                              {
    .filename = "motif.conf",
    .types = ACO_TYPES(&endpoint_option),
};

jingle_reason_mappings

const struct jingle_reason_mapping jingle_reason_mappings[]

static

Referenced by jingle_action_session_terminate(), and jingle_hangup().

jingle_rtp_glue

struct ast_rtp_glue jingle_rtp_glue

static

Local glue for interacting with the RTP engine core.

Definition at line 690 of file chan_motif.c.

                                             {
    .type = "Motif",
    .get_rtp_info = jingle_get_rtp_peer,
    .get_codec = jingle_get_codec,
    .update_peer = jingle_set_rtp_peer,
};

Referenced by load_module(), and unload_module().

jingle_tech

struct ast_channel_tech jingle_tech

static

PBX interface structure for channel registration.

Definition at line 395 of file chan_motif.c.

                                             {
    .type = "Motif",
    .description = "Motif Jingle Channel Driver",
    .requester = jingle_request,
    .send_text = jingle_sendtext,
    .send_digit_begin = jingle_digit_begin,
    .send_digit_end = jingle_digit_end,
    .call = jingle_call,
    .hangup = jingle_hangup,
    .answer = jingle_answer,
    .read = jingle_read,
    .write = jingle_write,
    .write_video = jingle_write,
    .exception = jingle_read,
    .indicate = jingle_indicate,
    .fixup = jingle_fixup,
    .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER
};

Referenced by jingle_new(), load_module(), and unload_module().

sched

struct ast_sched_context* sched

static

Scheduling context for RTCP

Definition at line 371 of file chan_motif.c.