diff options
| -rw-r--r-- | CHANGES | 9 | ||||
| -rw-r--r-- | UPGRADE.txt | 8 | ||||
| -rw-r--r-- | channels/chan_gtalk.c | 1 | ||||
| -rw-r--r-- | channels/chan_motif.c | 2515 | ||||
| -rw-r--r-- | configs/motif.conf.sample | 85 | ||||
| -rw-r--r-- | include/asterisk/xmpp.h | 2 | ||||
| -rw-r--r-- | res/res_jabber.c | 1 | ||||
| -rw-r--r-- | res/res_xmpp.c | 3 | ||||
| -rw-r--r-- | res/res_xmpp.exports.in | 17 |
9 files changed, 2638 insertions, 3 deletions
@@ -295,6 +295,15 @@ chan_ooh323 * Direct media functionality has been added. Options in config are: directmedia (directrtp) and directrtpsetup (earlydirect) +chan_motif +---------- + * A new channel driver named chan_motif has been added which provides support for + Google Talk and Jingle in a single channel driver. This new channel driver includes + support for both audio and video, RFC2833 DTMF, all codecs supported by Asterisk, + hold, unhold, and ringing notification. It is also compliant with the current Jingle + specification, current Google Jingle specification, and the original Google Talk + protocol. + ------------------------------------------------------------------------------ --- Functionality changes from Asterisk 1.8 to Asterisk 10 ------------------- ------------------------------------------------------------------------------ diff --git a/UPGRADE.txt b/UPGRADE.txt index 10b832171..a707d9a97 100644 --- a/UPGRADE.txt +++ b/UPGRADE.txt @@ -89,6 +89,14 @@ app_followme: You now have until the last step times out to decide if you want to accept the call or not before being disconnected. +chan_gtalk: + - chan_gtalk has been deprecated in favor of the chan_motif channel driver. It is recommended + that users switch to using it as it is a core supported module. + +chan_jingle: + - chan_jingle has been deprecated in favor of the chan_motif channel driver. It is recommended + that users switch to using it as it is a core supported module. + SIP === - A new option "tonezone" for setting default tonezone for the channel driver diff --git a/channels/chan_gtalk.c b/channels/chan_gtalk.c index 8fd20c830..e1d3ab491 100644 --- a/channels/chan_gtalk.c +++ b/channels/chan_gtalk.c @@ -32,6 +32,7 @@ */ /*** MODULEINFO + <defaultenabled>no</defaultenabled> <depend>iksemel</depend> <depend>res_jabber</depend> <use type="external">openssl</use> diff --git a/channels/chan_motif.c b/channels/chan_motif.c new file mode 100644 index 000000000..619b353ad --- /dev/null +++ b/channels/chan_motif.c @@ -0,0 +1,2515 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2012, Digium, Inc. + * + * Joshua Colp <jcolp@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \author Joshua Colp <jcolp@digium.com> + * + * \brief Motif Jingle Channel Driver + * + * \extref Iksemel http://iksemel.jabberstudio.org/ + * + * \ingroup channel_drivers + */ + +/*** MODULEINFO + <depend>iksemel</depend> + <depend>res_jabber</depend> + <use type="external">openssl</use> + <support_level>core</support_level> + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include <sys/socket.h> +#include <fcntl.h> +#include <netdb.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <sys/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/astobj.h" +#include "asterisk/abstract_jb.h" +#include "asterisk/xmpp.h" + +/*! \brief Default maximum number of ICE candidates we will offer */ +#define DEFAULT_MAX_ICE_CANDIDATES "10" + +/*! \brief Default maximum number of payloads we will offer */ +#define DEFAULT_MAX_PAYLOADS "30" + +/*! \brief Number of buckets for endpoints */ +#define ENDPOINT_BUCKETS 37 + +/*! \brief Number of buckets for sessions, on a per-endpoint basis */ +#define SESSION_BUCKETS 37 + +/*! \brief Namespace for Jingle itself */ +#define JINGLE_NS "urn:xmpp:jingle:1" + +/*! \brief Namespace for Jingle RTP sessions */ +#define JINGLE_RTP_NS "urn:xmpp:jingle:apps:rtp:1" + +/*! \brief Namespace for Jingle RTP info */ +#define JINGLE_RTP_INFO_NS "urn:xmpp:jingle:apps:rtp:info:1" + +/*! \brief Namespace for Jingle ICE-UDP */ +#define JINGLE_ICE_UDP_NS "urn:xmpp:jingle:transports:ice-udp:1" + +/*! \brief Namespace for Google Talk ICE-UDP */ +#define GOOGLE_TRANSPORT_NS "http://www.google.com/transport/p2p" + +/*! \brief Namespace for Google Talk Raw UDP */ +#define GOOGLE_TRANSPORT_RAW_NS "http://www.google.com/transport/raw-udp" + +/*! \brief Namespace for Google Session */ +#define GOOGLE_SESSION_NS "http://www.google.com/session" + +/*! \brief Namespace for Google Phone description */ +#define GOOGLE_PHONE_NS "http://www.google.com/session/phone" + +/*! \brief Namespace for Google Video description */ +#define GOOGLE_VIDEO_NS "http://www.google.com/session/video" + +/*! \brief Namespace for XMPP stanzas */ +#define XMPP_STANZAS_NS "urn:ietf:params:xml:ns:xmpp-stanzas" + +/*! \brief The various transport methods supported, from highest priority to lowest priority when doing fallback */ +enum jingle_transport { + 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 */ +}; + +/*! \brief Endpoint state information */ +struct jingle_endpoint_state { + struct ao2_container *sessions; /*!< Active sessions to or from the endpoint */ +}; + +/*! \brief Endpoint which contains configuration information and active sessions */ +struct jingle_endpoint { + AST_DECLARE_STRING_FIELDS( + AST_STRING_FIELD(name); /*!< Name of the endpoint */ + AST_STRING_FIELD(context); /*!< Context to place incoming calls into */ + AST_STRING_FIELD(accountcode); /*!< Account code */ + AST_STRING_FIELD(language); /*!< Default language for prompts */ + AST_STRING_FIELD(musicclass); /*!< Configured music on hold class */ + AST_STRING_FIELD(parkinglot); /*!< Configured parking lot */ + ); + struct ast_xmpp_client *connection; /*!< Connection to use for traffic */ + iksrule *rule; /*!< Active matching rule */ + unsigned int maxicecandidates; /*!< Maximum number of ICE candidates we will offer */ + unsigned int maxpayloads; /*!< Maximum number of payloads we will offer */ + struct ast_codec_pref prefs; /*!< Codec preferences */ + struct ast_format_cap *cap; /*!< Formats to use */ + ast_group_t callgroup; /*!< Call group */ + ast_group_t pickupgroup; /*!< Pickup group */ + enum jingle_transport transport; /*!< Default transport to use on outgoing sessions */ + struct jingle_endpoint_state *state; /*!< Endpoint state information */ +}; + +/*! \brief Session which contains information about an active session */ +struct jingle_session { + AST_DECLARE_STRING_FIELDS( + AST_STRING_FIELD(sid); /*!< Session identifier */ + AST_STRING_FIELD(audio_name); /*!< Name of the audio content */ + AST_STRING_FIELD(video_name); /*!< Name of the video content */ + ); + struct jingle_endpoint_state *state; /*!< Endpoint we are associated with */ + struct ast_xmpp_client *connection; /*!< Connection to use for traffic */ + enum jingle_transport transport; /*!< Transport type to use for this session */ + unsigned int maxicecandidates; /*!< Maximum number of ICE candidates we will offer */ + unsigned int maxpayloads; /*!< Maximum number of payloads we will offer */ + char remote_original[XMPP_MAX_JIDLEN];/*!< Identifier of the original remote party (remote may have changed due to redirect) */ + char remote[XMPP_MAX_JIDLEN]; /*!< Identifier of the remote party */ + iksrule *rule; /*!< Session matching rule */ + struct ast_codec_pref prefs; /*!< Codec preferences */ + struct ast_channel *owner; /*!< Master Channel */ + struct ast_rtp_instance *rtp; /*!< RTP audio session */ + struct ast_rtp_instance *vrtp; /*!< RTP video session */ + struct ast_format_cap *cap; /*!< Local codec capabilities */ + struct ast_format_cap *jointcap; /*!< Joint codec capabilities */ + struct ast_format_cap *peercap; /*!< Peer codec capabilities */ + unsigned int outgoing:1; /*!< Whether this is an outgoing leg or not */ + unsigned int gone:1; /*!< In the eyes of Jingle this session is already gone */ +}; + +static const char desc[] = "Motif Jingle Channel"; +static const char channel_type[] = "Motif"; + +struct jingle_config { + struct ao2_container *endpoints; /*!< Configured endpoints */ +}; + +static AO2_GLOBAL_OBJ_STATIC(globals); + +static struct ast_sched_context *sched; /*!< Scheduling context for RTCP */ + +/* \brief Asterisk core interaction functions */ +static struct ast_channel *jingle_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause); +static int jingle_sendtext(struct ast_channel *ast, const char *text); +static int jingle_digit_begin(struct ast_channel *ast, char digit); +static int jingle_digit_end(struct ast_channel *ast, char digit, unsigned int duration); +static int jingle_call(struct ast_channel *ast, const char *dest, int timeout); +static int jingle_hangup(struct ast_channel *ast); +static int jingle_answer(struct ast_channel *ast); +static struct ast_frame *jingle_read(struct ast_channel *ast); +static int jingle_write(struct ast_channel *ast, struct ast_frame *f); +static int jingle_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen); +static int jingle_fixup(struct ast_channel *oldchan, struct ast_channel *newchan); +static struct jingle_session *jingle_alloc(struct jingle_endpoint *endpoint, const char *from, const char *sid); + +/*! \brief Action handlers */ +static void jingle_action_session_initiate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak); +static void jingle_action_transport_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak); +static void jingle_action_session_accept(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak); +static void jingle_action_session_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak); +static void jingle_action_session_terminate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak); + +/*! \brief PBX interface structure for channel registration */ +static struct ast_channel_tech jingle_tech = { + .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, + .bridge = ast_rtp_instance_bridge, + .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 +}; + +/*! \brief Defined handlers for different Jingle actions */ +static const struct jingle_action_handler { + const char *action; + void (*handler)(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak); +} jingle_action_handlers[] = { + /* Jingle actions */ + { "session-initiate", jingle_action_session_initiate, }, + { "transport-info", jingle_action_transport_info, }, + { "session-accept", jingle_action_session_accept, }, + { "session-info", jingle_action_session_info, }, + { "session-terminate", jingle_action_session_terminate, }, + /* Google-V1 actions */ + { "initiate", jingle_action_session_initiate, }, + { "candidates", jingle_action_transport_info, }, + { "accept", jingle_action_session_accept, }, + { "terminate", jingle_action_session_terminate, }, + { "reject", jingle_action_session_terminate, }, +}; + +/*! \brief Reason text <-> cause code mapping */ +static const struct jingle_reason_mapping { + const char *reason; + int cause; +} jingle_reason_mappings[] = { + { "busy", AST_CAUSE_BUSY, }, + { "cancel", AST_CAUSE_CALL_REJECTED, }, + { "connectivity-error", AST_CAUSE_INTERWORKING, }, + { "decline", AST_CAUSE_CALL_REJECTED, }, + { "expired", AST_CAUSE_NO_USER_RESPONSE, }, + { "failed-transport", AST_CAUSE_PROTOCOL_ERROR, }, + { "failed-application", AST_CAUSE_SWITCH_CONGESTION, }, + { "general-error", AST_CAUSE_CONGESTION, }, + { "gone", AST_CAUSE_NORMAL_CLEARING, }, + { "incompatible-parameters", AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, }, + { "media-error", AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, }, + { "security-error", AST_CAUSE_PROTOCOL_ERROR, }, + { "success", AST_CAUSE_NORMAL_CLEARING, }, + { "timeout", AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, }, + { "unsupported-applications", AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, }, + { "unsupported-transports", AST_CAUSE_FACILITY_NOT_IMPLEMENTED, }, +}; + +/*! \brief Hashing function for Jingle sessions */ +static int jingle_session_hash(const void *obj, const int flags) +{ + const struct jingle_session *session = obj; + const char *sid = obj; + + return ast_str_hash(flags & OBJ_KEY ? sid : session->sid); +} + +/*! \brief Comparator function for Jingle sessions */ +static int jingle_session_cmp(void *obj, void *arg, int flags) +{ + 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; +} + +/*! \brief Destructor for Jingle endpoint state */ +static void jingle_endpoint_state_destructor(void *obj) +{ + struct jingle_endpoint_state *state = obj; + + ao2_ref(state->sessions, -1); +} + +/*! \brief Destructor for Jingle endpoints */ +static void jingle_endpoint_destructor(void *obj) +{ + 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); + } + + ast_format_cap_destroy(endpoint->cap); + + ao2_ref(endpoint->state, -1); + + ast_string_field_free_memory(endpoint); +} + +/*! \brief Find function for Jingle endpoints */ +static void *jingle_endpoint_find(struct ao2_container *tmp_container, const char *category) +{ + return ao2_find(tmp_container, category, OBJ_KEY); +} + +/*! \brief Allocator function for Jingle endpoint state */ +static struct jingle_endpoint_state *jingle_endpoint_state_create(void) +{ + struct jingle_endpoint_state *state; + + if (!(state = ao2_alloc(sizeof(*state), jingle_endpoint_state_destructor))) { + return NULL; + } + + if (!(state->sessions = ao2_container_alloc(SESSION_BUCKETS, jingle_session_hash, jingle_session_cmp))) { + ao2_ref(state, -1); + return NULL; + } + + return state; +} + +/*! \brief State find/create function */ +static struct jingle_endpoint_state *jingle_endpoint_state_find_or_create(const char *category) +{ + 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; +} + +/*! \brief Allocator function for Jingle endpoints */ +static void *jingle_endpoint_alloc(const char *cat) +{ + 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_nolock(); + endpoint->transport = JINGLE_TRANSPORT_ICE_UDP; + + return endpoint; +} + +/*! \brief Hashing function for Jingle endpoints */ +static int jingle_endpoint_hash(const void *obj, const int flags) +{ + const struct jingle_endpoint *endpoint = obj; + const char *name = obj; + + return ast_str_hash(flags & OBJ_KEY ? name : endpoint->name); +} + +/*! \brief Comparator function for Jingle endpoints */ +static int jingle_endpoint_cmp(void *obj, void *arg, int flags) +{ + 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; +} + +static struct aco_type endpoint_option = { + .type = ACO_ITEM, + .category_match = ACO_BLACKLIST, + .category = "^general$", + .item_alloc = jingle_endpoint_alloc, + .item_find = jingle_endpoint_find, + .item_offset = offsetof(struct jingle_config, endpoints), +}; + +struct aco_type *endpoint_options[] = ACO_TYPES(&endpoint_option); + +struct aco_file jingle_conf = { + .filename = "motif.conf", + .types = ACO_TYPES(&endpoint_option), +}; + +/*! \brief Destructor for Jingle sessions */ +static void jingle_session_destructor(void *obj) +{ + 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_destroy(session->rtp); + } + + if (session->vrtp) { + ast_rtp_instance_destroy(session->vrtp); + } + + ast_format_cap_destroy(session->cap); + ast_format_cap_destroy(session->jointcap); + ast_format_cap_destroy(session->peercap); + + ast_string_field_free_memory(session); +} + +/*! \brief Destructor called when module configuration goes away */ +static void jingle_config_destructor(void *obj) +{ + struct jingle_config *cfg = obj; + ao2_cleanup(cfg->endpoints); +} + +/*! \brief Allocator called when module configuration should appear */ +static void *jingle_config_alloc(void) +{ + struct jingle_config *cfg; + + if (!(cfg = ao2_alloc(sizeof(*cfg), jingle_config_destructor))) { + return NULL; + } + + if (!(cfg->endpoints = ao2_container_alloc(ENDPOINT_BUCKETS, jingle_endpoint_hash, jingle_endpoint_cmp))) { + ao2_ref(cfg, -1); + return NULL; + } + + return cfg; +} + +CONFIG_INFO_STANDARD(cfg_info, globals, jingle_config_alloc, + .files = ACO_FILES(&jingle_conf), + ); + +/*! \brief Function called by RTP engine to get local RTP peer */ +static enum ast_rtp_glue_result jingle_get_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance) +{ + 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; +} + +/*! \brief Function called by RTP engine to get peer capabilities */ +static void jingle_get_codec(struct ast_channel *chan, struct ast_format_cap *result) +{ +} + +/*! \brief Function called by RTP engine to change where the remote party should send media */ +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) +{ + return -1; +} + +/*! \brief Local glue for interacting with the RTP engine core */ +static struct ast_rtp_glue jingle_rtp_glue = { + .type = "Motif", + .get_rtp_info = jingle_get_rtp_peer, + .get_codec = jingle_get_codec, + .update_peer = jingle_set_rtp_peer, +}; + +/*! \brief Internal helper function which enables video support on a sesson if possible */ +static void jingle_enable_video(struct jingle_session *session) +{ + 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_FORMAT_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_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_packetization_set(ast_rtp_instance_get_codecs(session->vrtp), session->vrtp, &session->prefs); + + if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2 && (ice = ast_rtp_instance_get_ice(session->vrtp))) { + ice->stop(session->vrtp); + } +} + +/*! \brief Internal helper function used to allocate Jingle session on an endpoint */ +static struct jingle_session *jingle_alloc(struct jingle_endpoint *endpoint, const char *from, const char *sid) +{ + struct jingle_session *session; + struct ast_sockaddr tmp; + + if (!(session = ao2_alloc(sizeof(*session), jingle_session_destructor))) { + return NULL; + } + + 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", ast_random(), 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_nolock()) || + !(session->jointcap = ast_format_cap_alloc_nolock()) || + !(session->peercap = ast_format_cap_alloc_nolock())) { + ao2_ref(session, -1); + return NULL; + } + + ast_format_cap_copy(session->cap, endpoint->cap); + + /* While we rely on res_jabber 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); + + memcpy(&session->prefs, &endpoint->prefs, sizeof(session->prefs)); + + session->maxicecandidates = endpoint->maxicecandidates; + session->maxpayloads = endpoint->maxpayloads; + + return session; +} + +/*! \brief Function called to create a new Jingle Asterisk channel */ +static struct ast_channel *jingle_new(struct jingle_endpoint *endpoint, struct jingle_session *session, int state, const char *title, const char *linkedid, const char *cid_name) +{ + struct ast_channel *chan; + const char *str = S_OR(title, session->remote); + struct ast_format tmpfmt; + + if (ast_format_cap_is_empty(session->cap)) { + return NULL; + } + + if (!(chan = ast_channel_alloc(1, state, S_OR(title, ""), S_OR(cid_name, ""), "", "", "", linkedid, 0, "Motif/%s-%04lx", str, ast_random() & 0xffff))) { + return NULL; + } + + ast_channel_tech_set(chan, &jingle_tech); + ast_channel_tech_pvt_set(chan, session); + session->owner = chan; + + ast_format_cap_copy(ast_channel_nativeformats(chan), session->cap); + ast_codec_choose(&session->prefs, session->cap, 1, &tmpfmt); + + 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_packetization_set(ast_rtp_instance_get_codecs(session->rtp), session->rtp, &session->prefs); + + 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); + + ast_best_codec(ast_channel_nativeformats(chan), &tmpfmt); + ast_format_copy(ast_channel_writeformat(chan), &tmpfmt); + ast_format_copy(ast_channel_rawwriteformat(chan), &tmpfmt); + ast_format_copy(ast_channel_readformat(chan), &tmpfmt); + ast_format_copy(ast_channel_rawreadformat(chan), &tmpfmt); + + 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); + ast_channel_exten_set(chan, "s"); + ast_channel_priority_set(chan, 1); + + ao2_unlock(endpoint); + + return chan; +} + +/*! \brief Internal helper function which sends a response */ +static void jingle_send_response(struct ast_xmpp_client *connection, ikspak *pak) +{ + 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); +} + +/*! \brief Internal helper function which sends an error response */ +static void jingle_send_error_response(struct ast_xmpp_client *connection, ikspak *pak, const char *type, const char *reasonstr, const char *reasonstr2) +{ + 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); +} + +/*! \brief Internal helper function which adds ICE-UDP 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) +{ + 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), "%d", 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"); + snprintf(tmp, sizeof(tmp), "%04lx", 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; +} + +/*! \brief Internal helper function which adds Google candidates to a transport node */ +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) +{ + 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; + } + + /* We only support RTP candidates */ + if (candidate->id != 1) { + continue; + } + + iks_insert_attrib(local_candidate, "name", !video ? "rtp" : "video_rtp"); + 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; +} + +/*! \brief Internal function which sends a session-terminate message */ +static void jingle_send_session_terminate(struct jingle_session *session, const char *reasontext) +{ + 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); +} + +/*! \brief Internal function which sends a session-info message */ +static void jingle_send_session_info(struct jingle_session *session, const char *info) +{ + 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); +} + +/*! \internal + * + * \brief Locks both pvt and pvt owner if owner is present. + * + * \note This function gives a ref to pvt->owner if it is present and locked. + * This reference must be decremented after pvt->owner is unlocked. + * + * \note This function will never give you up, + * \note This function will never let you down. + * \note This function will run around and desert you. + * + * \pre pvt is not locked + * \post pvt is locked + * \post pvt->owner is locked and its reference count is increased (if pvt->owner is not NULL) + * + * \returns a pointer to the locked and reffed pvt->owner channel if it exists. + */ +static struct ast_channel *jingle_session_lock_full(struct jingle_session *pvt) +{ + 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 everthing 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; +} + +/*! \brief Helper function which queues a hangup frame with cause code */ +static void jingle_queue_hangup_with_cause(struct jingle_session *session, int cause) +{ + 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); +} + +/*! \brief Internal function which sends a transport-info message */ +static void jingle_send_transport_info(struct jingle_session *session, const char *from) +{ + 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); +} + +/*! \brief Internal helper function which adds payloads to a description */ +static int jingle_add_payloads_to_description(struct jingle_session *session, struct ast_rtp_instance *rtp, iks *description, iks **payloads, enum ast_format_type type) +{ + struct ast_format format; + int i = 0, res = 0; + + ast_format_cap_iter_start(session->jointcap); + while (!(ast_format_cap_iter_next(session->jointcap, &format)) && (i < (session->maxpayloads - 2))) { + int rtp_code; + iks *payload; + char tmp[32]; + + if (AST_FORMAT_GET_TYPE(format.id) != type) { + continue; + } + + if (((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(rtp), 1, &format, 0)) == -1) || + (!(payload = iks_new("payload-type")))) { + res = -1; + goto end; + } + + 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"); + snprintf(tmp, sizeof(tmp), "%d", ast_rtp_lookup_sample_rate2(1, &format, 0)); + iks_insert_attrib(payload, "clockrate", tmp); + + iks_insert_node(description, payload); + payloads[i++] = payload; + } + /* If this is for audio and there is room for RFC2833 add it in */ + if ((type == AST_FORMAT_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; + } + } + +end: + ast_format_cap_iter_end(session->jointcap); + + return res; +} + +/*! \brief Helper function which adds content to a description */ +static int jingle_add_content(struct jingle_session *session, iks *jingle, iks *content, iks *description, iks *transport, + const char *name, enum ast_format_type type, struct ast_rtp_instance *rtp, iks **payloads) +{ + 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_FORMAT_TYPE_AUDIO) { + iks_insert_attrib(description, "media", "audio"); + } else if (type == AST_FORMAT_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; +} + +/*! \brief Internal function which sends a complete session message */ +static void jingle_send_session_action(struct jingle_session *session, const char *action) +{ + 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_FORMAT_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_FORMAT_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); +} + +/*! \brief Internal function which sends a session-inititate message */ +static void jingle_send_session_initiate(struct jingle_session *session) +{ + jingle_send_session_action(session, session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "initiate" : "session-initiate"); +} + +/*! \brief Internal function which sends a session-accept message */ +static void jingle_send_session_accept(struct jingle_session *session) +{ + jingle_send_session_action(session, session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "accept" : "session-accept"); +} + +/*! \brief Callback for when a response is received for an outgoing session-initiate message */ +static int jingle_outgoing_hook(void *data, ikspak *pak) +{ + 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; + + /* 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")); + return IKS_FILTER_EAT; + } + + /* 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); + } + + return IKS_FILTER_EAT; +} + +/*! \brief Function called by core when we should answer a Jingle session */ +static int jingle_answer(struct ast_channel *ast) +{ + 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; +} + +/*! \brief Function called by core to read any waiting frames */ +static struct ast_frame *jingle_read(struct ast_channel *ast) +{ + 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(ast_channel_nativeformats(ast), &frame->subclass.format)) { + if (!ast_format_cap_iscompatible(session->jointcap, &frame->subclass.format)) { + ast_debug(1, "Bogus frame of format '%s' received from '%s'!\n", + ast_getformatname(&frame->subclass.format), ast_channel_name(ast)); + ast_frfree(frame); + frame = &ast_null_frame; + } else { + ast_debug(1, "Oooh, format changed to %s\n", + ast_getformatname(&frame->subclass.format)); + ast_format_cap_remove_bytype(ast_channel_nativeformats(ast), AST_FORMAT_TYPE_AUDIO); + ast_format_cap_add(ast_channel_nativeformats(ast), &frame->subclass.format); + ast_set_read_format(ast, ast_channel_readformat(ast)); + ast_set_write_format(ast, ast_channel_writeformat(ast)); + } + } + + return frame; +} + +/*! \brief Function called by core to write frames */ +static int jingle_write(struct ast_channel *ast, struct ast_frame *frame) +{ + struct jingle_session *session = ast_channel_tech_pvt(ast); + int res = 0; + char buf[256]; + + switch (frame->frametype) { + case AST_FRAME_VOICE: + if (!(ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &frame->subclass.format))) { + ast_log(LOG_WARNING, + "Asked to transmit frame type %s, while native formats is %s (read/write = %s/%s)\n", + ast_getformatname(&frame->subclass.format), + ast_getformatname_multiple(buf, sizeof(buf), ast_channel_nativeformats(ast)), + ast_getformatname(ast_channel_readformat(ast)), + ast_getformatname(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 %d type frames with Jingle write\n", + frame->frametype); + return 0; + } + + return res; +} + +/*! \brief Function called by core to change the underlying owner channel */ +static int jingle_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) +{ + struct jingle_session *session = ast_channel_tech_pvt(newchan); + + ao2_lock(session); + + session->owner = newchan; + + ao2_unlock(session); + + return 0; +} + +/*! \brief Function called by core to ask the channel to indicate some sort of condition */ +static int jingle_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen) +{ + 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 -1: + res = -1; + break; + default: + ast_log(LOG_NOTICE, "Don't know how to indicate condition '%d'\n", condition); + res = -1; + } + + return res; +} + +/*! \brief Function called by core to send text to the remote party of the Jingle session */ +static int jingle_sendtext(struct ast_channel *chan, const char *text) +{ + struct jingle_session *session = ast_channel_tech_pvt(chan); + + return ast_xmpp_client_send_message(session->connection, session->remote, text); +} + +/*! \brief Function called by core to start a DTMF digit */ +static int jingle_digit_begin(struct ast_channel *chan, char digit) +{ + struct jingle_session *session = ast_channel_tech_pvt(chan); + + if (session->rtp) { + ast_rtp_instance_dtmf_begin(session->rtp, digit); + } + + return 0; +} + +/*! \brief Function called by core to stop a DTMF digit */ +static int jingle_digit_end(struct ast_channel *ast, char digit, unsigned int duration) +{ + 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; +} + +/*! \brief Function called by core to actually start calling a remote party */ +static int jingle_call(struct ast_channel *ast, const char *dest, int timeout) +{ + 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_copy(session->jointcap, session->cap); + + /* 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; +} + +/*! \brief Function called by core to hang up a Jingle session */ +static int jingle_hangup(struct ast_channel *ast) +{ + 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); + session->owner = NULL; + + ao2_unlink(session->state->sessions, session); + ao2_ref(session->state, -1); + + ao2_unlock(session); + ao2_ref(session, -1); + + return 0; +} + +/*! \brief Function called by core to create a new outgoing Jingle session */ +static struct ast_channel *jingle_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause) +{ + 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[200] = ""; + struct ast_xmpp_buddy *buddy; + struct jingle_session *session; + struct ast_channel *chan; + enum jingle_transport transport = JINGLE_TRANSPORT_NONE; + 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_FORMAT_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, requestor ? ast_channel_linkedid(requestor) : NULL, 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_FORMAT_TYPE_VIDEO)) { + jingle_enable_video(session); + } + + /* We purposely don't decrement the session here as there is a reference on the channel */ + ao2_link(endpoint->state->sessions, session); + + return chan; +} + +/*! \brief Helper function which handles content descriptions */ +static int jingle_interpret_description(struct jingle_session *session, iks *description, const char *name, struct ast_rtp_instance **rtp) +{ + 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_bytype(session->peercap, AST_FORMAT_TYPE_AUDIO); + ast_format_cap_remove_bytype(session->jointcap, AST_FORMAT_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_bytype(session->peercap, AST_FORMAT_TYPE_VIDEO); + ast_format_cap_remove_bytype(session->jointcap, AST_FORMAT_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; + } + + ast_rtp_codecs_payloads_clear(&codecs, NULL); + + /* 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"), *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(name) && (sscanf(id, "%30d", &rtp_id) == 1)) { + ast_rtp_codecs_payloads_set_m_type(&codecs, NULL, rtp_id); + + if (!ast_strlen_zero(clockrate) && (sscanf(clockrate, "%30d", &rtp_clockrate) == 1)) { + ast_rtp_codecs_payloads_set_rtpmap_type_rate(&codecs, NULL, rtp_id, media, name, 0, rtp_clockrate); + } else { + ast_rtp_codecs_payloads_set_rtpmap_type(&codecs, NULL, rtp_id, media, name, 0); + } + } + } + + ast_rtp_codecs_payload_formats(&codecs, session->peercap, &othercapability); + ast_format_cap_joint_append(session->cap, session->peercap, session->jointcap); + + if (ast_format_cap_is_empty(session->jointcap)) { + /* We have no compatible codecs, so terminate the session appropriately */ + jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL); + return -1; + } + + ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(*rtp), *rtp); + + return 0; +} + +/*! \brief Helper function which handles ICE-UDP transport information */ +static int jingle_interpret_ice_udp_transport(struct jingle_session *session, iks *transport, struct ast_rtp_instance *rtp) +{ + 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)) { + jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR); + ast_log(LOG_ERROR, "Invalid ICE-UDP transport information received on session '%s', ufrag or pwd not present\n", session->sid); + return -1; + } + + 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"), *network = iks_find_attrib(candidate, "network"); + char *port = iks_find_attrib(candidate, "port"), *priority = iks_find_attrib(candidate, "priority"); + char *protocol = iks_find_attrib(candidate, "protocol"), *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(network) || 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", &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; +} + +/*! \brief Helper function which handles Google transport information */ +static int jingle_interpret_google_transport(struct jingle_session *session, iks *transport, struct ast_rtp_instance *rtp) +{ + 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; + } + + /* 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; +} + +/*! + * \brief Helper function which locates content stanzas and interprets them + * + * \note The session *must not* be locked before calling this + */ +static int jingle_interpret_content(struct jingle_session *session, ikspak *pak) +{ + 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 = iks_find_attrib(content, "name"); + struct ast_rtp_instance *rtp = NULL; + iks *description, *transport; + + 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 assocating 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(pak->query, "description", "xmlns", 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 fmt; + + ast_format_cap_copy(ast_channel_nativeformats(chan), session->jointcap); + ast_codec_choose(&session->prefs, session->jointcap, 1, &fmt); + ast_set_read_format(chan, &fmt); + ast_set_write_format(chan, &fmt); + + ast_channel_unlock(chan); + ast_channel_unref(chan); + } + ao2_unlock(session); + + return 0; +} + +/*! \brief Handler function for the 'session-initiate' action */ +static void jingle_action_session_initiate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak) +{ + 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, 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_setstate(chan, AST_STATE_RING); + 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; + } +} + +/*! \brief Handler function for the 'transport-info' action */ +static void jingle_action_transport_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak) +{ + 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); +} + +/*! \brief Handler function for the 'session-accept' action */ +static void jingle_action_session_accept(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak) +{ + 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); +} + +/*! \brief Handler function for the 'session-info' action */ +static void jingle_action_session_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak) +{ + 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_control(chan, AST_CONTROL_HOLD); + } else if (iks_find_with_attrib(pak->query, "unhold", "xmlns", JINGLE_RTP_INFO_NS)) { + ast_queue_control(chan, AST_CONTROL_UNHOLD); + } + + ast_channel_unlock(chan); + ast_channel_unref(chan); + ao2_unlock(session); + + jingle_send_response(endpoint->connection, pak); +} + +/*! \brief Handler function for the 'session-terminate' action */ +static void jingle_action_session_terminate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak) +{ + struct ast_channel *chan; + iks *reason, *text; + int cause = AST_CAUSE_NORMAL; + + 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; + + /* 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; + } + } + } + + 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); +} + +/*! \brief Callback for when a Jingle action is received from an endpoint */ +static int jingle_action_hook(void *data, ikspak *pak) +{ + 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); + } + + /* 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) { + ao2_ref(session, -1); + } + + ao2_ref(endpoint, -1); + + return IKS_FILTER_EAT; +} + +/*! \brief Custom handler for groups */ +static int custom_group_handler(const struct aco_option *opt, struct ast_variable *var, void *obj) +{ + 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; +} + +/*! \brief Custom handler for connection */ +static int custom_connection_handler(const struct aco_option *opt, struct ast_variable *var, void *obj) +{ + 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; +} + +/*! \brief Custom handler for transport */ +static int custom_transport_handler(const struct aco_option *opt, struct ast_variable *var, void *obj) +{ + 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; +} + +/*! \brief Load module into PBX, register channel */ +static int load_module(void) +{ + if (!(jingle_tech.capabilities = ast_format_cap_alloc())) { + return AST_MODULE_LOAD_DECLINE; + } + + if (aco_info_init(&cfg_info)) { + ast_log(LOG_ERROR, "Unable to intialize 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, prefs, cap)); + aco_option_register(&cfg_info, "disallow", ACO_EXACT, endpoint_options, "all", OPT_CODEC_T, 0, FLDSET(struct jingle_endpoint, prefs, 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)); + aco_option_register(&cfg_info, "maxpayloads", ACO_EXACT, endpoint_options, DEFAULT_MAX_PAYLOADS, OPT_UINT_T, PARSE_DEFAULT, + FLDSET(struct jingle_endpoint, maxpayloads)); + + ast_format_cap_add_all_by_type(jingle_tech.capabilities, AST_FORMAT_TYPE_AUDIO); + + if (aco_process_config(&cfg_info, 0)) { + ast_log(LOG_ERROR, "Unable to read config file motif.conf. Not loading module.\n"); + goto end; + } + + 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); + + return AST_MODULE_LOAD_FAILURE; +} + +/*! \brief Reload module */ +static int reload(void) +{ + return aco_process_config(&cfg_info, 1); +} + +/*! \brief Unload the jingle channel from Asterisk */ +static int unload_module(void) +{ + ast_channel_unregister(&jingle_tech); + ast_rtp_glue_unregister(&jingle_rtp_glue); + ast_sched_context_destroy(sched); + aco_info_destroy(&cfg_info); + ao2_global_obj_release(globals); + + return 0; +} + +AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Motif Jingle Channel Driver", + .load = load_module, + .unload = unload_module, + .reload = reload, + .load_pri = AST_MODPRI_CHANNEL_DRIVER, + ); diff --git a/configs/motif.conf.sample b/configs/motif.conf.sample new file mode 100644 index 000000000..02bec3dba --- /dev/null +++ b/configs/motif.conf.sample @@ -0,0 +1,85 @@ +; Sample configuration file for chan_motif + +; Transports +; +; There are three different transports and protocol derivatives supported by chan_motif. They are in order of preference: +; Jingle using ICE-UDP, Google Jingle, and Google-V1. +; +; Jingle as defined in XEP-0166 supports the widest range of features. It is referred to as "ice-udp" in this file. This is +; the specification that Jingle clients implement. +; +; Google Jingle follows the Jingle specification for signaling but uses a custom transport for media. It is supported +; by the Google Talk Plug-in in Gmail and by some other Jingle clients. It is referred to as "google" in this file. +; +; Google-V1 is the original Google Talk signaling protocol which uses an initial preliminary version of Jingle. +; It also uses the same custom transport as Google Jingle for media. It is supported by Google Voice, some other Jingle +; clients, and the Windows Google Talk client. It is referred to as "google-v1" in this file. +; +; Incoming sessions will automatically switch to the correct transport once it has been determined. +; +; Outgoing sessions are capable of determining if the target is capable of Jingle or a Google transport if the target is +; in the roster. Unfortunately it is not possible to differentiate between a Google Jingle or Google-V1 capable resource +; until a session initiate attempt occurs. If a resource is determined to use a Google transport it will initially use +; Google Jingle but will fall back to Google-V1 if required. +; +; If an outgoing session attempt fails due to failure to support the given transport chan_motif will fall back in preference +; order listed at the beginning of this document until all transports have been exhausted. +; + +; Dialing and Resource Selection Strategy +; +; Placing a call through an endpoint can be accomplished using the following dial string: +; +; Motif/<endpoint name>/<target> +; +; When placing an outgoing call through an endpoint the requested target is searched for in the roster list. If present +; the first Jingle or Google Jingle capable resource is specifically targetted. Since the capabilities of the resource are +; known the outgoing session initation will disregard the configured transport and use the determined one. +; +; If the target is not found in the roster the target will be used as-is and a session will be initiated using the +; transport specified in this configuration file. If no transport has been specified the endpoint defaults to ice-udp. +; + +; Video Support +; +; Support for video does not need to be explicitly enabled. Configuring any video codec on your endpoint will +; automatically enable it. + +; DTMF +; +; The only supported method for DTMF is RFC2833. This is always enabled on audio streams and negotiated if possible. + +; CallerID +; +; The incoming caller id number is populated with the username of the caller and the name is populated with the full +; identity of the caller. If you would like to perform authentication or filtering of incoming calls it is recommended +; that you use these fields to do so. +; +; Outgoing caller id can *not* be set. + +; Default template for endpoints, to be included in their definition +[default](!) +disallow=all +allow=ulaw +allow=h264 +context=incoming-motif ; Default context that incoming sessions will land in + +;maxicecandidates = 10 ; Maximum number of ICE candidates we will offer +;maxpayloads = 30 ; Maximum number of payloads we will offer + +; Sample configuration entry for Jingle +[jingle-endpoint](default) +transport=ice-udp ; Change the default protocol of outgoing sessions to Jingle ICE-UDP +allow=g722 ; Add G.722 as an allowed format since the other side may support it +connection=local-jabber-account ; Connection to accept traffic on and send traffic out +accountcode=jingle ; Account code for CDR purposes + +; Sample configuration entry for Google Talk +[gtalk-endpoint](default) +transport=google ; Since this is a Google Talk endpoint we want to offer Google Jingle for outgoing sessions +connection=gtalk-account + +; Sample configuration entry for Google Voice +[gvoice](default) +transport=google-v1 ; Google Voice uses the original Google Talk protocol +connection=gvoice-account diff --git a/include/asterisk/xmpp.h b/include/asterisk/xmpp.h index ab21987bc..1bac90042 100644 --- a/include/asterisk/xmpp.h +++ b/include/asterisk/xmpp.h @@ -35,7 +35,7 @@ #endif /* HAVE_OPENSSL */ /* file is read by blocks with this size */ -#define NET_IO_BUF_SIZE 4096 +#define NET_IO_BUF_SIZE 16384 /* Return value for timeout connection expiration */ #define IKS_NET_EXPIRED 12 diff --git a/res/res_jabber.c b/res/res_jabber.c index 384b12c43..c160266b0 100644 --- a/res/res_jabber.c +++ b/res/res_jabber.c @@ -31,6 +31,7 @@ */ /*** MODULEINFO + <defaultenabled>no</defaultenabled> <depend>iksemel</depend> <use type="external">openssl</use> <support_level>extended</support_level> diff --git a/res/res_xmpp.c b/res/res_xmpp.c index c8ba09f85..8428e3d09 100644 --- a/res/res_xmpp.c +++ b/res/res_xmpp.c @@ -24,7 +24,7 @@ * * \extref Iksemel http://code.google.com/p/iksemel/ * - * A refereouce module for interfacting Asterisk directly as a client or component with + * A reference module for interfacting Asterisk directly as a client or component with * an XMPP/Jabber compliant server. * * This module is based upon the original res_jabber as done by Matt O'Gorman. @@ -32,7 +32,6 @@ */ /*** MODULEINFO - <defaultenabled>no</defaultenabled> <depend>iksemel</depend> <use type="external">openssl</use> <support_level>core</support_level> diff --git a/res/res_xmpp.exports.in b/res/res_xmpp.exports.in new file mode 100644 index 000000000..e73fc85a9 --- /dev/null +++ b/res/res_xmpp.exports.in @@ -0,0 +1,17 @@ +{ + global: + LINKER_SYMBOL_PREFIXast_xmpp_client_find; + LINKER_SYMBOL_PREFIXast_xmpp_client_disconnect; + LINKER_SYMBOL_PREFIXast_xmpp_client_unref; + LINKER_SYMBOL_PREFIXast_xmpp_client_lock; + LINKER_SYMBOL_PREFIXast_xmpp_client_unlock; + LINKER_SYMBOL_PREFIXast_xmpp_client_send; + LINKER_SYMBOL_PREFIXast_xmpp_client_send_message; + LINKER_SYMBOL_PREFIXast_xmpp_chatroom_invite; + LINKER_SYMBOL_PREFIXast_xmpp_chatroom_join; + LINKER_SYMBOL_PREFIXast_xmpp_chatroom_send; + LINKER_SYMBOL_PREFIXast_xmpp_chatroom_leave; + LINKER_SYMBOL_PREFIXast_xmpp_increment_mid; + local: + *; +}; |