static void
google_session_destroy(GoogleSession *session)
{
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
g_free(session->id.id);
g_free(session->id.initiator);
g_free(session->remote_jid);
if (session_data->remote_audio_candidates)
purple_media_candidate_list_free(session_data->remote_audio_candidates);
if (session_data->remote_video_candidates)
purple_media_candidate_list_free(session_data->remote_video_candidates);
if (session->description)
xmlnode_free(session->description);
g_free(session->session_data);
g_free(session);
}
static void
purple_media_stream_free(PurpleMediaStream *stream)
{
if (stream == NULL)
return;
g_free(stream->participant);
if (stream->local_candidates)
purple_media_candidate_list_free(stream->local_candidates);
if (stream->remote_candidates)
purple_media_candidate_list_free(stream->remote_candidates);
if (stream->active_local_candidates)
purple_media_candidate_list_free(
stream->active_local_candidates);
if (stream->active_remote_candidates)
purple_media_candidate_list_free(
stream->active_remote_candidates);
g_free(stream);
}
static void
google_session_send_candidates(PurpleMedia *media, gchar *session_id,
gchar *participant, GoogleSession *session)
{
PurpleMedia *session_media =
((GoogleAVSessionData *) session->session_data)->media;
GList *candidates =
purple_media_get_local_candidates(session_media, session_id,
session->remote_jid);
GList *iter;
PurpleMediaCandidate *transport;
gboolean video = FALSE;
if (!strcmp(session_id, "google-video"))
video = TRUE;
for (iter = candidates; iter; iter = iter->next) {
JabberIq *iq;
gchar *ip, *port, *username, *password;
gchar pref[16];
PurpleMediaCandidateType type;
xmlnode *sess;
xmlnode *candidate;
guint component_id;
transport = PURPLE_MEDIA_CANDIDATE(iter->data);
component_id = purple_media_candidate_get_component_id(
transport);
iq = jabber_iq_new(session->js, JABBER_IQ_SET);
sess = google_session_create_xmlnode(session, "candidates");
xmlnode_insert_child(iq->node, sess);
xmlnode_set_attrib(iq->node, "to", session->remote_jid);
candidate = xmlnode_new("candidate");
ip = purple_media_candidate_get_ip(transport);
port = g_strdup_printf("%d",
purple_media_candidate_get_port(transport));
g_ascii_dtostr(pref, 16,
purple_media_candidate_get_priority(transport) / 1000.0);
username = purple_media_candidate_get_username(transport);
password = purple_media_candidate_get_password(transport);
type = purple_media_candidate_get_candidate_type(transport);
xmlnode_set_attrib(candidate, "address", ip);
xmlnode_set_attrib(candidate, "port", port);
xmlnode_set_attrib(candidate, "name",
component_id == PURPLE_MEDIA_COMPONENT_RTP ?
video ? "video_rtp" : "rtp" :
component_id == PURPLE_MEDIA_COMPONENT_RTCP ?
video ? "video_rtcp" : "rtcp" : "none");
xmlnode_set_attrib(candidate, "username", username);
/*
* As of this writing, Farsight 2 in Google compatibility
* mode doesn't provide a password. The Gmail client
* requires this to be set.
*/
xmlnode_set_attrib(candidate, "password",
password != NULL ? password : "");
xmlnode_set_attrib(candidate, "preference", pref);
xmlnode_set_attrib(candidate, "protocol",
purple_media_candidate_get_protocol(transport)
== PURPLE_MEDIA_NETWORK_PROTOCOL_UDP ?
"udp" : "tcp");
xmlnode_set_attrib(candidate, "type", type ==
PURPLE_MEDIA_CANDIDATE_TYPE_HOST ? "local" :
type ==
PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX ? "stun" :
type ==
PURPLE_MEDIA_CANDIDATE_TYPE_RELAY ? "relay" :
NULL);
xmlnode_set_attrib(candidate, "generation", "0");
xmlnode_set_attrib(candidate, "network", "0");
xmlnode_insert_child(sess, candidate);
g_free(ip);
g_free(port);
g_free(username);
g_free(password);
jabber_iq_send(iq);
}
purple_media_candidate_list_free(candidates);
}
static void
google_session_handle_candidates(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
{
JabberIq *result;
GList *list = NULL, *video_list = NULL;
xmlnode *cand;
static int name = 0;
char n[4];
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
for (cand = xmlnode_get_child(sess, "candidate"); cand;
cand = xmlnode_get_next_twin(cand)) {
PurpleMediaCandidate *info;
const gchar *cname = xmlnode_get_attrib(cand, "name");
const gchar *type = xmlnode_get_attrib(cand, "type");
const gchar *protocol = xmlnode_get_attrib(cand, "protocol");
const gchar *address = xmlnode_get_attrib(cand, "address");
const gchar *port = xmlnode_get_attrib(cand, "port");
const gchar *preference = xmlnode_get_attrib(cand, "preference");
guint component_id;
if (cname && type && address && port) {
PurpleMediaCandidateType candidate_type;
guint prio = preference ? g_ascii_strtod(preference, NULL) * 1000 : 0;
g_snprintf(n, sizeof(n), "S%d", name++);
if (g_str_equal(type, "local"))
candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
else if (g_str_equal(type, "stun"))
candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX;
else if (g_str_equal(type, "relay"))
candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_RELAY;
else
candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
if (purple_strequal(cname, "rtcp") ||
purple_strequal(cname, "video_rtcp"))
component_id = PURPLE_MEDIA_COMPONENT_RTCP;
else
component_id = PURPLE_MEDIA_COMPONENT_RTP;
info = purple_media_candidate_new(n, component_id,
candidate_type,
purple_strequal(protocol, "udp") ?
PURPLE_MEDIA_NETWORK_PROTOCOL_UDP :
PURPLE_MEDIA_NETWORK_PROTOCOL_TCP,
address,
atoi(port));
g_object_set(info, "username", xmlnode_get_attrib(cand, "username"),
"password", xmlnode_get_attrib(cand, "password"),
"priority", prio, NULL);
if (!strncmp(cname, "video_", 6)) {
if (session_data->added_streams) {
video_list = g_list_append(video_list, info);
} else {
session_data->remote_video_candidates =
g_list_append(session_data->remote_video_candidates,
info);
}
} else {
if (session_data->added_streams) {
list = g_list_append(list, info);
} else {
session_data->remote_audio_candidates =
g_list_append(session_data->remote_audio_candidates,
info);
}
}
}
}
if (list) {
purple_media_add_remote_candidates(session_data->media, "google-voice",
session->remote_jid, list);
purple_media_candidate_list_free(list);
}
if (video_list) {
purple_media_add_remote_candidates(session_data->media, "google-video",
session->remote_jid, video_list);
purple_media_candidate_list_free(video_list);
}
result = jabber_iq_new(js, JABBER_IQ_RESULT);
jabber_iq_set_id(result, iq_id);
xmlnode_set_attrib(result->node, "to", session->remote_jid);
jabber_iq_send(result);
}
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);
}
