xmlnode *
xmlnode_get_child_with_namespace(const xmlnode *parent, const char *name, const char *ns)
{
xmlnode *x, *ret = NULL;
char **names;
char *parent_name, *child_name;
g_return_val_if_fail(parent != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
names = g_strsplit(name, "/", 2);
parent_name = names[0];
child_name = names[1];
for(x = parent->child; x; x = x->next) {
/* XXX: Is it correct to ignore the namespace for the match if none was specified? */
const char *xmlns = NULL;
if(ns)
xmlns = xmlnode_get_namespace(x);
if(x->type == XMLNODE_TYPE_TAG && name && !strcmp(parent_name, x->name)
&& (!ns || (xmlns && !strcmp(ns, xmlns)))) {
ret = x;
break;
}
}
if(child_name && ret)
ret = xmlnode_get_child(ret, child_name);
g_strfreev(names);
return ret;
}
static void jabber_bosh_connection_received(PurpleBOSHConnection *conn, xmlnode *node) {
xmlnode *child;
JabberStream *js = conn->js;
g_return_if_fail(node != NULL);
if (jabber_bosh_connection_error_check(conn, node))
return;
child = node->child;
while (child != NULL) {
/* jabber_process_packet might free child */
xmlnode *next = child->next;
if (child->type == XMLNODE_TYPE_TAG) {
const char *xmlns = xmlnode_get_namespace(child);
/*
* Workaround for non-compliant servers that don't stamp
* the right xmlns on these packets. See #11315.
*/
if ((xmlns == NULL /* shouldn't happen, but is equally wrong */ ||
g_str_equal(xmlns, NS_BOSH)) &&
(g_str_equal(child->name, "iq") ||
g_str_equal(child->name, "message") ||
g_str_equal(child->name, "presence"))) {
xmlnode_set_namespace(child, NS_XMPP_CLIENT);
}
jabber_process_packet(js, &child);
}
child = next;
}
}
static void jabber_chat_room_configure_cb(JabberStream *js, xmlnode *packet, gpointer data)
{
xmlnode *query, *x;
const char *type = xmlnode_get_attrib(packet, "type");
const char *from = xmlnode_get_attrib(packet, "from");
char *msg;
JabberChat *chat;
JabberID *jid;
if(!type || !from)
return;
if(!strcmp(type, "result")) {
jid = jabber_id_new(from);
if(!jid)
return;
chat = jabber_chat_find(js, jid->node, jid->domain);
jabber_id_free(jid);
if(!chat)
return;
if(!(query = xmlnode_get_child(packet, "query")))
return;
for(x = xmlnode_get_child(query, "x"); x; x = xmlnode_get_next_twin(x)) {
const char *xmlns;
if(!(xmlns = xmlnode_get_namespace(x)))
continue;
if(!strcmp(xmlns, "jabber:x:data")) {
chat->config_dialog_type = PURPLE_REQUEST_FIELDS;
chat->config_dialog_handle = jabber_x_data_request(js, x, jabber_chat_room_configure_x_data_cb, chat);
return;
}
}
} else if(!strcmp(type, "error")) {
char *msg = jabber_parse_error(js, packet);
purple_notify_error(js->gc, _("Configuration error"), _("Configuration error"), msg);
if(msg)
g_free(msg);
return;
}
msg = g_strdup_printf("Unable to configure room %s", from);
purple_notify_info(js->gc, _("Unable to configure"), _("Unable to configure"), msg);
g_free(msg);
}
JingleTransport *
jingle_transport_parse(xmlnode *transport)
{
const gchar *type_name = xmlnode_get_namespace(transport);
GType type = jingle_get_type(type_name);
if (type == G_TYPE_NONE)
return NULL;
return JINGLE_TRANSPORT_CLASS(g_type_class_ref(type))->parse(transport);
}
/**
* Process the iq set request.
*/
static void
xmpp_stream_process_iq_set(XmppStream *stream, xmlnode *root)
{
gchar *id;
gchar *value;
xmlnode *node;
gint count = 0;
g_return_if_fail(stream != NULL);
g_return_if_fail(root != NULL);
node = xmlnode_child(root);
for (; node; node = node->next, count ++);
/*
* An IQ stanza of type "get" or "set" MUST contain exactly one
* child element, which specifies the semantics of the particular
* request.
*/
if (count != 1) {
/* TODO send error stanza. */
return;
}
node = xmlnode_child(root);
if (g_strcmp0(node->name, "query") == 0) {
value = xmlnode_get_namespace(node);
if (g_strcmp0(value, NS_IQ_ROSTER) == 0) {
xmpp_stream_process_set_roster(stream, node);
}
g_free(value);
}
/* send a result response. */
IqRequest *iq;
iq = iq_request_create(stream, IQ_TYPE_RESULT);
xmlnode_new_prop(iq->node, "from", stream->jid);
if (xmlnode_has_prop(root, "id")) {
id = xmlnode_prop(root, "id");
xmlnode_set_prop(iq->node, "id", id);
g_free(id);
}
iq_request_send(iq);
iq_request_destroy(iq);
}
static gboolean
google_session_handle_initiate(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
{
const gchar *xmlns;
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
if (session->state != UNINIT) {
purple_debug_error("jabber", "Received initiate for active session.\n");
return FALSE;
}
session->description = xmlnode_copy(xmlnode_get_child(sess, "description"));
xmlns = xmlnode_get_namespace(session->description);
if (purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE))
session_data->video = FALSE;
else if (purple_strequal(xmlns, NS_GOOGLE_SESSION_VIDEO))
session_data->video = TRUE;
else {
purple_debug_error("jabber", "Received initiate with "
"invalid namespace %s.\n", xmlns);
return FALSE;
}
session_data->media = purple_media_manager_create_media(
purple_media_manager_get(),
purple_connection_get_account(js->gc),
"fsrtpconference", session->remote_jid, FALSE);
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);
session->iq_id = g_strdup(iq_id);
if (js->google_relay_host && js->google_relay_token) {
jabber_google_do_relay_request(js, session,
jabber_google_relay_response_session_handle_initiate_cb);
} else {
jabber_google_relay_response_session_handle_initiate_cb(session, NULL,
0, 0, 0, NULL, NULL);
}
return TRUE;
}
static void jabber_chat_register_cb(JabberStream *js, const char *from,
JabberIqType type, const char *id,
xmlnode *packet, gpointer data)
{
xmlnode *query, *x;
char *msg;
JabberChat *chat;
JabberID *jid;
if (!from)
return;
if (type == JABBER_IQ_RESULT) {
jid = jabber_id_new(from);
if(!jid)
return;
chat = jabber_chat_find(js, jid->node, jid->domain);
jabber_id_free(jid);
if(!chat)
return;
if(!(query = xmlnode_get_child(packet, "query")))
return;
for(x = xmlnode_get_child(query, "x"); x; x = xmlnode_get_next_twin(x)) {
const char *xmlns;
if(!(xmlns = xmlnode_get_namespace(x)))
continue;
if(!strcmp(xmlns, "jabber:x:data")) {
jabber_x_data_request(js, x, jabber_chat_register_x_data_cb, chat);
return;
}
}
} else if (type == JABBER_IQ_ERROR) {
char *msg = jabber_parse_error(js, packet, NULL);
purple_notify_error(js->gc, _("Registration error"), _("Registration error"), msg);
if(msg)
g_free(msg);
return;
}
msg = g_strdup_printf("Unable to configure room %s", from);
purple_notify_info(js->gc, _("Unable to configure"), _("Unable to configure"), msg);
g_free(msg);
}
JingleContent *
jingle_content_parse(xmlnode *content)
{
const gchar *type = xmlnode_get_namespace(xmlnode_get_child(content, "description"));
GType jingle_type = jingle_get_type(type);
if (jingle_type != G_TYPE_NONE) {
return JINGLE_CONTENT_CLASS(g_type_class_ref(jingle_type))->parse(content);
} else {
return NULL;
}
}
xmlnode *
xmlnode_get_next_twin(xmlnode *node)
{
xmlnode *sibling;
const char *ns = xmlnode_get_namespace(node);
g_return_val_if_fail(node != NULL, NULL);
g_return_val_if_fail(node->type == XMLNODE_TYPE_TAG, NULL);
for(sibling = node->next; sibling; sibling = sibling->next) {
/* XXX: Is it correct to ignore the namespace for the match if none was specified? */
const char *xmlns = NULL;
if(ns)
xmlns = xmlnode_get_namespace(sibling);
if(sibling->type == XMLNODE_TYPE_TAG && !strcmp(node->name, sibling->name) &&
(!ns || (xmlns && !strcmp(ns, xmlns))))
return sibling;
}
return NULL;
}
static void jabber_iq_time_parse(JabberStream *js, xmlnode *packet)
{
const char *type, *from, *id, *xmlns;
JabberIq *iq;
xmlnode *query;
time_t now_t;
struct tm *now;
time(&now_t);
now = localtime(&now_t);
type = xmlnode_get_attrib(packet, "type");
from = xmlnode_get_attrib(packet, "from");
id = xmlnode_get_attrib(packet, "id");
/* we're gonna throw this away in a moment, but we need it
* to get the xmlns, so we can figure out if this is
* jabber:iq:time or urn:xmpp:time */
query = xmlnode_get_child(packet, "query");
xmlns = xmlnode_get_namespace(query);
if(type && !strcmp(type, "get")) {
xmlnode *utc;
const char *date;
iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, xmlns);
jabber_iq_set_id(iq, id);
xmlnode_set_attrib(iq->node, "to", from);
query = xmlnode_get_child(iq->node, "query");
date = purple_utf8_strftime("%Y%m%dT%T", now);
utc = xmlnode_new_child(query, "utc");
xmlnode_insert_data(utc, date, -1);
if(!strcmp("urn:xmpp:time", xmlns)) {
xmlnode_insert_data(utc, "Z", 1); /* of COURSE the thing that is the same is different */
date = purple_get_tzoff_str(now, TRUE);
xmlnode_insert_data(xmlnode_new_child(query, "tzo"), date, -1);
} else { /* jabber:iq:time */
date = purple_utf8_strftime("%Z", now);
xmlnode_insert_data(xmlnode_new_child(query, "tz"), date, -1);
date = purple_utf8_strftime("%d %b %Y %T", now);
xmlnode_insert_data(xmlnode_new_child(query, "display"), date, -1);
}
jabber_iq_send(iq);
}
}
static JingleContent *
jingle_content_parse_internal(xmlnode *content)
{
xmlnode *description = xmlnode_get_child(content, "description");
const gchar *type = xmlnode_get_namespace(description);
const gchar *creator = xmlnode_get_attrib(content, "creator");
const gchar *disposition = xmlnode_get_attrib(content, "disposition");
const gchar *senders = xmlnode_get_attrib(content, "senders");
const gchar *name = xmlnode_get_attrib(content, "name");
JingleTransport *transport =
jingle_transport_parse(xmlnode_get_child(content, "transport"));
if (senders == NULL)
senders = "both";
return jingle_content_create(type, creator, disposition, name, senders, transport);
}
void jabber_iq_parse(JabberStream *js, xmlnode *packet)
{
JabberCallbackData *jcd;
xmlnode *query, *error, *x;
const char *xmlns;
const char *type, *id, *from;
JabberIqHandler *jih;
query = xmlnode_get_child(packet, "query");
type = xmlnode_get_attrib(packet, "type");
from = xmlnode_get_attrib(packet, "from");
id = xmlnode_get_attrib(packet, "id");
if(type == NULL || !(!strcmp(type, "get") || !strcmp(type, "set")
|| !strcmp(type, "result") || !strcmp(type, "error"))) {
purple_debug_error("jabber", "IQ with invalid type ('%s') - ignoring.\n",
type ? type : "(null)");
return;
}
/* All IQs must have an ID, so send an error for a set/get that doesn't */
if(!id || !*id) {
if(!strcmp(type, "set") || !strcmp(type, "get")) {
JabberIq *iq = jabber_iq_new(js, JABBER_IQ_ERROR);
xmlnode_free(iq->node);
iq->node = xmlnode_copy(packet);
xmlnode_set_attrib(iq->node, "to", from);
xmlnode_remove_attrib(iq->node, "from");
xmlnode_set_attrib(iq->node, "type", "error");
/* This id is clearly not useful, but we must put something there for a valid stanza */
iq->id = jabber_get_next_id(js);
xmlnode_set_attrib(iq->node, "id", iq->id);
error = xmlnode_new_child(iq->node, "error");
xmlnode_set_attrib(error, "type", "modify");
x = xmlnode_new_child(error, "bad-request");
xmlnode_set_namespace(x, "urn:ietf:params:xml:ns:xmpp-stanzas");
jabber_iq_send(iq);
} else
purple_debug_error("jabber", "IQ of type '%s' missing id - ignoring.\n", type);
return;
}
/* First, lets see if a special callback got registered */
if(!strcmp(type, "result") || !strcmp(type, "error")) {
if(id && *id && (jcd = g_hash_table_lookup(js->iq_callbacks, id))) {
jcd->callback(js, packet, jcd->data);
jabber_iq_remove_callback_by_id(js, id);
return;
}
}
/* Apparently not, so lets see if we have a pre-defined handler */
if(query && (xmlns = xmlnode_get_namespace(query))) {
if((jih = g_hash_table_lookup(iq_handlers, xmlns))) {
jih(js, packet);
return;
}
}
if(xmlnode_get_child_with_namespace(packet, "si", "http://jabber.org/protocol/si")) {
jabber_si_parse(js, packet);
return;
}
if(xmlnode_get_child_with_namespace(packet, "new-mail", "google:mail:notify")) {
jabber_gmail_poke(js, packet);
return;
}
purple_debug_info("jabber", "jabber_iq_parse\n");
if(xmlnode_get_child_with_namespace(packet, "ping", "urn:xmpp:ping")) {
jabber_ping_parse(js, packet);
return;
}
if (xmlnode_get_child_with_namespace(packet, "data", XEP_0231_NAMESPACE)) {
jabber_data_parse(js, packet);
return;
}
/* If we get here, send the default error reply mandated by XMPP-CORE */
if(!strcmp(type, "set") || !strcmp(type, "get")) {
JabberIq *iq = jabber_iq_new(js, JABBER_IQ_ERROR);
xmlnode_free(iq->node);
iq->node = xmlnode_copy(packet);
xmlnode_set_attrib(iq->node, "to", from);
xmlnode_remove_attrib(iq->node, "from");
xmlnode_set_attrib(iq->node, "type", "error");
error = xmlnode_new_child(iq->node, "error");
xmlnode_set_attrib(error, "type", "cancel");
xmlnode_set_attrib(error, "code", "501");
x = xmlnode_new_child(error, "feature-not-implemented");
xmlnode_set_namespace(x, "urn:ietf:params:xml:ns:xmpp-stanzas");
jabber_iq_send(iq);
}
}
static void
google_session_handle_accept(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
{
xmlnode *desc_element = xmlnode_get_child(sess, "description");
xmlnode *codec_element = xmlnode_get_child(
desc_element, "payload-type");
GList *codecs = NULL, *video_codecs = NULL;
JabberIq *result = NULL;
const gchar *xmlns = xmlnode_get_namespace(desc_element);
gboolean video = (xmlns && !strcmp(xmlns, NS_GOOGLE_SESSION_VIDEO));
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
for (; codec_element; codec_element = codec_element->next) {
const gchar *xmlns, *encoding_name, *id,
*clock_rate, *width, *height, *framerate;
gboolean video_codec = FALSE;
if (!purple_strequal(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 (!video || purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE))
clock_rate = xmlnode_get_attrib(
codec_element, "clockrate");
else {
clock_rate = "90000";
width = xmlnode_get_attrib(codec_element, "width");
height = xmlnode_get_attrib(codec_element, "height");
framerate = xmlnode_get_attrib(
codec_element, "framerate");
video_codec = TRUE;
}
if (id && encoding_name) {
PurpleMediaCodec *codec = purple_media_codec_new(
atoi(id), encoding_name,
video_codec ? PURPLE_MEDIA_VIDEO :
PURPLE_MEDIA_AUDIO,
clock_rate ? atoi(clock_rate) : 0);
if (video_codec)
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_stream_info(session_data->media, PURPLE_MEDIA_INFO_ACCEPT,
NULL, NULL, FALSE);
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);
}
/**
* \fn xmlnode_received_cb
* \brief Reacts to requests and receipts
*/
static void
xmlnode_received_cb(PurpleConnection *gc, xmlnode **packet, gpointer null)
{
if(*packet != NULL)
{
if(strcmp((*packet)->name, "message") == 0)
{
#ifdef DEBUG
printf("got message\n");
#endif
xmlnode* nodeRequest = xmlnode_get_child (*packet, "request");
const char* strFrom = xmlnode_get_attrib(*packet , "from");
//Answer to an request and verify namespace
if(nodeRequest)
{
#ifdef DEBUG
printf("got request\n");
#endif
const char* strId = xmlnode_get_attrib(*packet , "id");
const char* strNS = xmlnode_get_namespace(nodeRequest);
if(strcmp(strNS, "urn:xmpp:receipts") == 0)
{
xmlnode *message = xmlnode_new("message");
xmlnode_set_attrib(message, "to", strFrom);
xmlnode *received = xmlnode_new_child(message, "received");
xmlnode_set_namespace(received, "urn:xmpp:receipts");
xmlnode_set_attrib(received, "id", strId);
purple_signal_emit(purple_connection_get_prpl(gc), "jabber-sending-xmlnode", gc, &message);
if (message != NULL)
xmlnode_free(message);
}
}
//Find incoming receipt and call the display-function
xmlnode* nodeReceived = xmlnode_get_child (*packet, "received");
if(nodeReceived)
{
#ifdef DEBUG
printf("got received\n");
#endif
const char* strNS = xmlnode_get_namespace(nodeReceived);
const char* strId = xmlnode_get_attrib(nodeReceived , "id");
if (strcmp(strNS, "urn:xmpp:receipts") == 0)
{
display_message_receipt(strId);
}
}
}
}
}
JingleTransport *
jingle_transport_parse(xmlnode *transport)
{
const gchar *type = xmlnode_get_namespace(transport);
return JINGLE_TRANSPORT_CLASS(g_type_class_ref(jingle_get_type(type)))->parse(transport);
}
JingleTransport *
jingle_transport_parse_internal(xmlnode *transport)
{
const gchar *type = xmlnode_get_namespace(transport);
return jingle_transport_create(type);
}