static void
jabber_google_relay_response_session_initiate_cb(GoogleSession *session,
const gchar *relay_ip, guint relay_udp, guint relay_tcp, guint relay_ssltcp,
const gchar *relay_username, const gchar *relay_password)
{
GParameter *params;
guint num_params;
JabberStream *js = session->js;
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
session_data->media = purple_media_manager_create_media(
purple_media_manager_get(),
purple_connection_get_account(js->gc),
"fsrtpconference", session->remote_jid, TRUE);
purple_media_set_prpl_data(session_data->media, session);
g_signal_connect_swapped(G_OBJECT(session_data->media),
"candidates-prepared",
G_CALLBACK(google_session_ready), session);
g_signal_connect_swapped(G_OBJECT(session_data->media), "codecs-changed",
G_CALLBACK(google_session_ready), session);
g_signal_connect(G_OBJECT(session_data->media), "state-changed",
G_CALLBACK(google_session_state_changed_cb), session);
g_signal_connect(G_OBJECT(session_data->media), "stream-info",
G_CALLBACK(google_session_stream_info_cb), session);
params =
jabber_google_session_get_params(js, relay_ip, relay_udp, relay_tcp,
relay_ssltcp, relay_username, relay_password, &num_params);
if (purple_media_add_stream(session_data->media, "google-voice",
session->remote_jid, PURPLE_MEDIA_AUDIO,
TRUE, "nice", num_params, params) == FALSE ||
(session_data->video && purple_media_add_stream(
session_data->media, "google-video",
session->remote_jid, PURPLE_MEDIA_VIDEO,
TRUE, "nice", num_params, params) == FALSE)) {
purple_media_error(session_data->media, "Error adding stream.");
purple_media_end(session_data->media, NULL, NULL);
g_free(params);
} else {
session_data->added_streams = TRUE;
}
g_free(params);
}
/*------------------------------------------------------------------------
* Initiate a voice/video session with a contact.
*
* @param account The MXit account object
* @param who The username of the contact.
* @param type The type of media session to initiate
* @return TRUE if session was initiated
*/
gboolean mxit_media_initiate(PurpleAccount *account, const char *who, PurpleMediaSessionType type)
{
gchar* transmitter = "rawudp";
PurpleMedia* media = NULL;
purple_debug_info(MXIT_PLUGIN_ID, "mxit_media_initiate: buddy '%s'\n", who);
media = purple_media_manager_create_media(
purple_media_manager_get(),
account,
"fsrtpconference",
who,
TRUE
);
if (!media) {
purple_debug_info(MXIT_PLUGIN_ID, "mxit_media_initiate: could not create media session\n");
return FALSE;
}
/* attach callbacks */
g_signal_connect(G_OBJECT(media), "candidates-prepared", G_CALLBACK(mxit_candidates_prepared_cb), NULL);
g_signal_connect(G_OBJECT(media), "stream-info", G_CALLBACK(mxit_stream_info_cb), NULL);
g_signal_connect(G_OBJECT(media), "state-changed", G_CALLBACK(mxit_state_changed_cb), NULL);
/* initiate audio session */
if ((type & PURPLE_MEDIA_AUDIO) &&
(!purple_media_add_stream(media, "audio", who, PURPLE_MEDIA_AUDIO, TRUE, transmitter, 0, NULL))) {
purple_media_end(media, NULL, NULL);
return FALSE;
}
/* initiate video session */
if ((type & PURPLE_MEDIA_VIDEO) &&
(!purple_media_add_stream(media, "video", who, PURPLE_MEDIA_VIDEO, TRUE, transmitter, 0, NULL))) {
purple_media_end(media, NULL, NULL);
return FALSE;
}
return TRUE;
}
struct sipe_backend_stream *
sipe_backend_media_add_stream(struct sipe_backend_media *media,
const gchar *id,
const gchar *participant,
SipeMediaType type,
SipeIceVersion ice_version,
gboolean initiator,
struct sipe_backend_media_relays *media_relays)
{
struct sipe_backend_stream *stream = NULL;
PurpleMediaSessionType prpl_type = sipe_media_to_purple(type);
GParameter *params = NULL;
guint params_cnt = 0;
gchar *transmitter;
if (ice_version != SIPE_ICE_NO_ICE) {
transmitter = "nice";
params_cnt = 4;
params = g_new0(GParameter, params_cnt);
params[0].name = "compatibility-mode";
g_value_init(¶ms[0].value, G_TYPE_UINT);
g_value_set_uint(¶ms[0].value,
ice_version == SIPE_ICE_DRAFT_6 ?
NICE_COMPATIBILITY_OC2007 :
NICE_COMPATIBILITY_OC2007R2);
params[1].name = "transport-protocols";
g_value_init(¶ms[1].value, G_TYPE_UINT);
#ifdef HAVE_ICE_TCP
g_value_set_uint(¶ms[1].value,
PURPLE_MEDIA_NETWORK_PROTOCOL_UDP |
PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_ACTIVE |
PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_PASSIVE);
#else
g_value_set_uint(¶ms[1].value,
PURPLE_MEDIA_NETWORK_PROTOCOL_UDP);
#endif
params[2].name = "demultiplex-func";
g_value_init(¶ms[2].value, G_TYPE_POINTER);
g_value_set_pointer(¶ms[2].value, stream_demultiplex_cb);
if (media_relays) {
params[3].name = "relay-info";
g_value_init(¶ms[3].value, G_TYPE_VALUE_ARRAY);
g_value_set_boxed(¶ms[3].value, media_relays);
} else
--params_cnt;
} else {
// TODO: session naming here, Communicator needs audio/video
transmitter = "rawudp";
//sessionid = "sipe-voice-rawudp";
/* To avoid Coverity FORWARD_NULL warning. params_cnt is
* still 0 so this is a no-op. libpurple API documentation
* doesn't specify if params can be NULL or not. */
params = g_new0(GParameter, 1);
}
ensure_codecs_conf();
if (purple_media_add_stream(media->m, id, participant, prpl_type,
initiator, transmitter, params_cnt,
params)) {
stream = g_new0(struct sipe_backend_stream, 1);
stream->sessionid = g_strdup(id);
stream->participant = g_strdup(participant);
stream->initialized_cb_was_fired = FALSE;
media->streams = g_slist_append(media->streams, stream);
if (!initiator)
++media->unconfirmed_streams;
}
static void
jabber_google_relay_response_session_handle_initiate_cb(GoogleSession *session,
const gchar *relay_ip, guint relay_udp, guint relay_tcp, guint relay_ssltcp,
const gchar *relay_username, const gchar *relay_password)
{
GParameter *params;
guint num_params;
JabberStream *js = session->js;
xmlnode *codec_element;
const gchar *xmlns;
PurpleMediaCodec *codec;
GList *video_codecs = NULL;
GList *codecs = NULL;
JabberIq *result;
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
params =
jabber_google_session_get_params(js, relay_ip, relay_udp, relay_tcp,
relay_ssltcp, relay_username, relay_password, &num_params);
if (purple_media_add_stream(session_data->media, "google-voice",
session->remote_jid, PURPLE_MEDIA_AUDIO, FALSE,
"nice", num_params, params) == FALSE ||
(session_data->video && purple_media_add_stream(
session_data->media, "google-video",
session->remote_jid, PURPLE_MEDIA_VIDEO,
FALSE, "nice", num_params, params) == FALSE)) {
purple_media_error(session_data->media, "Error adding stream.");
purple_media_stream_info(session_data->media,
PURPLE_MEDIA_INFO_REJECT, NULL, NULL, TRUE);
} else {
/* successfully added stream(s) */
session_data->added_streams = TRUE;
if (session_data->remote_audio_candidates) {
purple_media_add_remote_candidates(session_data->media,
"google-voice", session->remote_jid,
session_data->remote_audio_candidates);
purple_media_candidate_list_free(session_data->remote_audio_candidates);
session_data->remote_audio_candidates = NULL;
}
if (session_data->remote_video_candidates) {
purple_media_add_remote_candidates(session_data->media,
"google-video", session->remote_jid,
session_data->remote_video_candidates);
purple_media_candidate_list_free(session_data->remote_video_candidates);
session_data->remote_video_candidates = NULL;
}
}
g_free(params);
for (codec_element = xmlnode_get_child(session->description, "payload-type");
codec_element; codec_element = codec_element->next) {
const char *id, *encoding_name, *clock_rate,
*width, *height, *framerate;
gboolean video;
if (codec_element->name &&
strcmp(codec_element->name, "payload-type"))
continue;
xmlns = xmlnode_get_namespace(codec_element);
encoding_name = xmlnode_get_attrib(codec_element, "name");
id = xmlnode_get_attrib(codec_element, "id");
if (!session_data->video ||
(xmlns && !strcmp(xmlns, NS_GOOGLE_SESSION_PHONE))) {
clock_rate = xmlnode_get_attrib(
codec_element, "clockrate");
video = FALSE;
} else {
width = xmlnode_get_attrib(codec_element, "width");
height = xmlnode_get_attrib(codec_element, "height");
framerate = xmlnode_get_attrib(
codec_element, "framerate");
clock_rate = "90000";
video = TRUE;
}
if (id) {
codec = purple_media_codec_new(atoi(id), encoding_name,
video ? PURPLE_MEDIA_VIDEO :
PURPLE_MEDIA_AUDIO,
clock_rate ? atoi(clock_rate) : 0);
if (video)
video_codecs = g_list_append(
video_codecs, codec);
else
codecs = g_list_append(codecs, codec);
}
}
if (codecs)
purple_media_set_remote_codecs(session_data->media, "google-voice",
session->remote_jid, codecs);
if (video_codecs)
purple_media_set_remote_codecs(session_data->media, "google-video",
session->remote_jid, video_codecs);
purple_media_codec_list_free(codecs);
purple_media_codec_list_free(video_codecs);
result = jabber_iq_new(js, JABBER_IQ_RESULT);
jabber_iq_set_id(result, session->iq_id);
xmlnode_set_attrib(result->node, "to", session->remote_jid);
jabber_iq_send(result);
}
