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); }