static gboolean
msn_oim_request_helper(MsnOimRequestData *data)
{
MsnSession *session = data->oim->session;
if (data->send) {
/* The Sending of OIM's uses a different token for some reason. */
xmlnode *ticket;
ticket = xmlnode_get_child(data->body, "Header/Ticket");
xmlnode_set_attrib(ticket, "passport",
msn_nexus_get_token_str(session->nexus, MSN_AUTH_LIVE_SECURE));
}
else
{
xmlnode *passport;
xmlnode *xml_t;
xmlnode *xml_p;
GHashTable *token;
const char *msn_t;
const char *msn_p;
token = msn_nexus_get_token(session->nexus, MSN_AUTH_MESSENGER_WEB);
g_return_val_if_fail(token != NULL, FALSE);
msn_t = g_hash_table_lookup(token, "t");
msn_p = g_hash_table_lookup(token, "p");
g_return_val_if_fail(msn_t != NULL, FALSE);
g_return_val_if_fail(msn_p != NULL, FALSE);
passport = xmlnode_get_child(data->body, "Header/PassportCookie");
xml_t = xmlnode_get_child(passport, "t");
xml_p = xmlnode_get_child(passport, "p");
/* frees old token text, or the 'EMPTY' text if first time */
xmlnode_free(xml_t->child);
xmlnode_free(xml_p->child);
xmlnode_insert_data(xml_t, msn_t, -1);
xmlnode_insert_data(xml_p, msn_p, -1);
}
msn_soap_message_send(session,
msn_soap_message_new(data->action, xmlnode_copy(data->body)),
data->host, data->url, FALSE,
msn_oim_request_cb, data);
return FALSE;
}
static void
shinima_message_links_foreach(gchar **message,
void(*foreach_func)(xmlnode*,
const gchar*,
gchar**,
gboolean*,
gpointer),
gboolean *_changed,
gpointer *user_data)
{
xmlnode *root, *a;
gboolean *changed =
(_changed != NULL) ? changed : g_malloc(sizeof(gboolean));
g_return_if_fail(foreach_func != NULL);
root = xmlnode_from_str(*message, -1);
for(a=xmlnode_get_child(root, "a"); a; a=xmlnode_get_next_twin(a))
{
const gchar *href = xmlnode_get_attrib(a, "href");
if(href) foreach_func(a, href, message, changed, user_data);
}
if(changed)
{
g_free(*message);
*message = xmlnode_to_str(root, NULL);
}
if(_changed == NULL) g_free(changed);
xmlnode_free(root);
}
static void jabber_iq_last_parse(JabberStream *js, xmlnode *packet)
{
JabberIq *iq;
const char *type;
const char *from;
const char *id;
xmlnode *query;
char *idle_time;
type = xmlnode_get_attrib(packet, "type");
from = xmlnode_get_attrib(packet, "from");
id = xmlnode_get_attrib(packet, "id");
if(type && !strcmp(type, "get")) {
iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, "jabber:iq:last");
jabber_iq_set_id(iq, id);
xmlnode_set_attrib(iq->node, "to", from);
query = xmlnode_get_child(iq->node, "query");
idle_time = g_strdup_printf("%ld", js->idle ? time(NULL) - js->idle : 0);
xmlnode_set_attrib(query, "seconds", idle_time);
g_free(idle_time);
jabber_iq_send(iq);
}
}
static void roster_request_cb(JabberStream *js, const char *from,
JabberIqType type, const char *id,
xmlnode *packet, gpointer data)
{
xmlnode *query;
if (type == JABBER_IQ_ERROR) {
/*
* This shouldn't happen in any real circumstances and
* likely constitutes a server-side misconfiguration (i.e.
* explicitly not loading mod_roster...)
*/
purple_debug_error("jabber", "Error retrieving roster!?\n");
jabber_stream_set_state(js, JABBER_STREAM_CONNECTED);
return;
}
query = xmlnode_get_child(packet, "query");
if (query == NULL) {
jabber_stream_set_state(js, JABBER_STREAM_CONNECTED);
return;
}
jabber_roster_parse(js, from, type, id, query);
jabber_stream_set_state(js, JABBER_STREAM_CONNECTED);
}
gboolean jabber_chat_role_user(JabberChat *chat, const char *who, const char *role)
{
char *to;
JabberIq *iq;
xmlnode *query, *item;
JabberChatMember *jcm;
jcm = g_hash_table_lookup(chat->members, who);
if (!jcm || !jcm->handle)
return FALSE;
iq = jabber_iq_new_query(chat->js, JABBER_IQ_SET,
"http://jabber.org/protocol/muc#admin");
to = g_strdup_printf("%s@%s", chat->room, chat->server);
xmlnode_set_attrib(iq->node, "to", to);
g_free(to);
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "nick", jcm->handle);
xmlnode_set_attrib(item, "role", role);
jabber_iq_send(iq);
return TRUE;
}
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;
}
void jabber_roster_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy,
PurpleGroup *group) {
GSList *buddies = purple_find_buddies(gc->account, buddy->name);
buddies = g_slist_remove(buddies, buddy);
if(buddies != NULL) {
PurpleBuddy *tmpbuddy;
PurpleGroup *tmpgroup;
GSList *groups = NULL;
while(buddies) {
tmpbuddy = buddies->data;
tmpgroup = purple_buddy_get_group(tmpbuddy);
groups = g_slist_append(groups, tmpgroup->name);
buddies = g_slist_remove(buddies, tmpbuddy);
}
jabber_roster_update(gc->proto_data, buddy->name, groups);
g_slist_free(groups);
} else {
JabberIq *iq = jabber_iq_new_query(gc->proto_data, JABBER_IQ_SET,
"jabber:iq:roster");
xmlnode *query = xmlnode_get_child(iq->node, "query");
xmlnode *item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", buddy->name);
xmlnode_set_attrib(item, "subscription", "remove");
jabber_iq_send(iq);
}
}
void
jabber_data_parse(JabberStream *js, xmlnode *packet)
{
JabberIq *result = NULL;
const char *who = xmlnode_get_attrib(packet, "from");
xmlnode *data_node = xmlnode_get_child(packet, "data");
const JabberData *data =
jabber_data_find_local_by_cid(xmlnode_get_attrib(data_node, "cid"));
if (!data) {
xmlnode *item_not_found = xmlnode_new("item-not-found");
result = jabber_iq_new(js, JABBER_IQ_ERROR);
xmlnode_set_attrib(result->node, "to", who);
xmlnode_set_attrib(result->node, "id", xmlnode_get_attrib(packet, "id"));
xmlnode_insert_child(result->node, item_not_found);
} else {
result = jabber_iq_new(js, JABBER_IQ_RESULT);
xmlnode_set_attrib(result->node, "to", who);
xmlnode_set_attrib(result->node, "id", xmlnode_get_attrib(packet, "id"));
xmlnode_insert_child(result->node,
jabber_data_get_xml_definition(data));
}
jabber_iq_send(result);
}
/* Parse the XML data,
* prepare to report the OIM to user
*/
static void
msn_oim_get_read_cb(MsnSoapMessage *request, MsnSoapMessage *response,
gpointer data)
{
MsnOimRecvData *rdata = data;
if (response != NULL) {
xmlnode *msg_node = xmlnode_get_child(response->xml,
"Body/GetMessageResponse/GetMessageResult");
if (msg_node) {
char *msg_str = xmlnode_get_data(msg_node);
msn_oim_report_to_user(rdata, msg_str);
g_free(msg_str);
} else {
char *str = xmlnode_to_str(response->xml, NULL);
purple_debug_info("msn", "Unknown OIM response: %s\n", str);
g_free(str);
msn_oim_recv_data_free(rdata);
}
} else {
purple_debug_info("msn", "Failed to get OIM\n");
msn_oim_recv_data_free(rdata);
}
}
xmlnode*
xmlnode_get_child_with_namespace(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);
names = g_strsplit(name, "/", 2);
parent_name = names[0];
child_name = names[1];
for(x = parent->child; x; x = x->next) {
const char *xmlns = NULL;
if(ns)
xmlns = xmlnode_get_attrib(x, "xmlns");
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 char*
format_message(char *sender,
char *message)
{
GString* format_message = g_string_new("");
xmlnode* message_node = xmlnode_from_str(message, -1);
/* raw */
if ( !message_node ||
!( strcmp(message_node->name, "html")==0 ||
strcmp(message_node->name, "body")==0 )) {
g_string_printf(format_message, "%s: %s", sender, message);
return g_string_free(format_message, FALSE);
}
xmlnode* body_node =
(strcmp(message_node->name, "body")) ?
xmlnode_get_child(message_node, "body") :
message_node;
char* message_content = xmlnode_get_content(body_node);
g_string_printf(format_message, "%s: %s", sender, message_content);
g_free(message_content);
xmlnode_free(message_node);
return g_string_free(format_message, FALSE);
}
gboolean jabber_chat_kick_user(JabberChat *chat, const char *who, const char *why)
{
JabberIq *iq;
JabberChatMember *jcm = g_hash_table_lookup(chat->members, who);
char *to;
xmlnode *query, *item, *reason;
if(!jcm || !jcm->jid)
return FALSE;
iq = jabber_iq_new_query(chat->js, JABBER_IQ_SET,
"http://jabber.org/protocol/muc#admin");
to = g_strdup_printf("%s@%s", chat->room, chat->server);
xmlnode_set_attrib(iq->node, "to", to);
g_free(to);
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", jcm->jid);
xmlnode_set_attrib(item, "role", "none");
if(why) {
reason = xmlnode_new_child(item, "reason");
xmlnode_insert_data(reason, why, -1);
}
jabber_iq_send(iq);
return TRUE;
}
gboolean jabber_chat_affiliate_user(JabberChat *chat, const char *who, const char *affiliation)
{
JabberChatMember *jcm;
const char *jid;
char *to;
JabberIq *iq;
xmlnode *query, *item;
jcm = g_hash_table_lookup(chat->members, who);
if (jcm && jcm->jid)
jid = jcm->jid;
else if (strchr(who, '@') != NULL)
jid = who;
else
return FALSE;
iq = jabber_iq_new_query(chat->js, JABBER_IQ_SET,
"http://jabber.org/protocol/muc#admin");
to = g_strdup_printf("%s@%s", chat->room, chat->server);
xmlnode_set_attrib(iq->node, "to", to);
g_free(to);
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", jid);
xmlnode_set_attrib(item, "affiliation", affiliation);
jabber_iq_send(iq);
return TRUE;
}
static void
nexus_got_response_cb(MsnSoapMessage *req, MsnSoapMessage *resp, gpointer data)
{
MsnNexus *nexus = data;
MsnSession *session = nexus->session;
const char *ticket;
char *response;
if (resp == NULL) {
msn_session_set_error(session, MSN_ERROR_SERVCONN, _("Windows Live ID authentication:Unable to connect"));
return;
}
if (!nexus_parse_collection(nexus, -1,
xmlnode_get_child(resp->xml,
"Body/RequestSecurityTokenResponseCollection"))) {
msn_session_set_error(session, MSN_ERROR_SERVCONN, _("Windows Live ID authentication:Invalid response"));
return;
}
ticket = msn_nexus_get_token_str(nexus, MSN_AUTH_MESSENGER);
response = msn_rps_encrypt(nexus);
msn_got_login_params(session, ticket, response);
g_free(response);
}
static void
jabber_si_bytestreams_connect_cb(gpointer data, gint source, const gchar *error_message)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx = xfer->data;
JabberIq *iq;
xmlnode *query, *su;
struct bytestreams_streamhost *streamhost = jsx->streamhosts->data;
gaim_proxy_info_destroy(jsx->gpi);
jsx->connect_data = NULL;
if(source < 0) {
jsx->streamhosts = g_list_remove(jsx->streamhosts, streamhost);
g_free(streamhost->jid);
g_free(streamhost->host);
g_free(streamhost);
jabber_si_bytestreams_attempt_connect(xfer);
return;
}
iq = jabber_iq_new_query(jsx->js, JABBER_IQ_RESULT, "http://jabber.org/protocol/bytestreams");
xmlnode_set_attrib(iq->node, "to", xfer->who);
jabber_iq_set_id(iq, jsx->iq_id);
query = xmlnode_get_child(iq->node, "query");
su = xmlnode_new_child(query, "streamhost-used");
xmlnode_set_attrib(su, "jid", streamhost->jid);
jabber_iq_send(iq);
gaim_xfer_start(xfer, source, NULL, -1);
}
void
jabber_google_session_parse(JabberStream *js, const char *from,
JabberIqType type, const char *iq_id,
xmlnode *session_node)
{
GoogleSession *session = NULL;
GoogleSessionId id;
xmlnode *desc_node;
GList *iter = NULL;
if (type != JABBER_IQ_SET)
return;
id.id = (gchar*)xmlnode_get_attrib(session_node, "id");
if (!id.id)
return;
id.initiator = (gchar*)xmlnode_get_attrib(session_node, "initiator");
if (!id.initiator)
return;
iter = purple_media_manager_get_media_by_account(
purple_media_manager_get(),
purple_connection_get_account(js->gc));
for (; iter; iter = g_list_delete_link(iter, iter)) {
GoogleSession *gsession =
purple_media_get_prpl_data(iter->data);
if (google_session_id_equal(&(gsession->id), &id)) {
session = gsession;
break;
}
}
if (iter != NULL) {
g_list_free(iter);
}
if (session) {
google_session_parse_iq(js, session, session_node, iq_id);
return;
}
/* If the session doesn't exist, this has to be an initiate message */
if (strcmp(xmlnode_get_attrib(session_node, "type"), "initiate"))
return;
desc_node = xmlnode_get_child(session_node, "description");
if (!desc_node)
return;
session = g_new0(GoogleSession, 1);
session->id.id = g_strdup(id.id);
session->id.initiator = g_strdup(id.initiator);
session->state = UNINIT;
session->js = js;
session->remote_jid = g_strdup(session->id.initiator);
session->session_data = g_new0(GoogleAVSessionData, 1);
google_session_handle_initiate(js, session, session_node, iq_id);
}
static void
msn_oim_request_cb(MsnSoapMessage *request, MsnSoapMessage *response,
gpointer req_data)
{
MsnOimRequestData *data = (MsnOimRequestData *)req_data;
xmlnode *fault = NULL;
xmlnode *faultcode = NULL;
if (response == NULL)
return;
fault = xmlnode_get_child(response->xml, "Body/Fault");
if (fault)
faultcode = xmlnode_get_child(fault, "faultcode");
if (faultcode) {
gchar *faultcode_str = xmlnode_get_data(faultcode);
gboolean need_token_update = FALSE;
if (faultcode_str) {
if (g_str_equal(faultcode_str, "q0:BadContextToken") ||
g_str_equal(faultcode_str, "AuthenticationFailed"))
need_token_update = TRUE;
else if (g_str_equal(faultcode_str, "q0:AuthenticationFailed") &&
xmlnode_get_child(fault, "detail/RequiredAuthPolicy") != NULL)
need_token_update = TRUE;
}
if (need_token_update) {
purple_debug_warning("msn", "OIM Request Error, Updating token now.\n");
msn_nexus_update_token(data->oim->session->nexus,
data->send ? MSN_AUTH_LIVE_SECURE : MSN_AUTH_MESSENGER_WEB,
(GSourceFunc)msn_oim_request_helper, data);
g_free(faultcode_str);
return;
}
g_free(faultcode_str);
}
if (data->cb)
data->cb(request, response, data->cb_data);
xmlnode_free(data->body);
g_free(data);
}
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);
}
static void
jingle_handle_transport_replace(JingleSession *session, xmlnode *jingle)
{
xmlnode *content = xmlnode_get_child(jingle, "content");
jabber_iq_send(jingle_session_create_ack(session, jingle));
for (; content; content = xmlnode_get_next_twin(content)) {
const gchar *name = xmlnode_get_attrib(content, "name");
const gchar *creator = xmlnode_get_attrib(content, "creator");
xmlnode *xmltransport = xmlnode_get_child(content, "transport");
JingleTransport *transport = jingle_transport_parse(xmltransport);
JingleContent *content = jingle_session_find_content(session, name, creator);
jingle_content_set_pending_transport(content, transport);
}
}
static void jabber_iq_version_parse(JabberStream *js, xmlnode *packet)
{
JabberIq *iq;
const char *type, *from, *id;
xmlnode *query;
type = xmlnode_get_attrib(packet, "type");
if(type && !strcmp(type, "get")) {
GHashTable *ui_info;
const char *ui_name = NULL, *ui_version = NULL;
#if 0
char *os = NULL;
if(!purple_prefs_get_bool("/plugins/prpl/jabber/hide_os")) {
struct utsname osinfo;
uname(&osinfo);
os = g_strdup_printf("%s %s %s", osinfo.sysname, osinfo.release,
osinfo.machine);
}
#endif
from = xmlnode_get_attrib(packet, "from");
id = xmlnode_get_attrib(packet, "id");
iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, "jabber:iq:version");
xmlnode_set_attrib(iq->node, "to", from);
jabber_iq_set_id(iq, id);
query = xmlnode_get_child(iq->node, "query");
ui_info = purple_core_get_ui_info();
if(NULL != ui_info) {
ui_name = g_hash_table_lookup(ui_info, "name");
ui_version = g_hash_table_lookup(ui_info, "version");
}
if(NULL != ui_name && NULL != ui_version) {
char *version_complete = g_strdup_printf("%s (libpurple " VERSION ")", ui_version);
xmlnode_insert_data(xmlnode_new_child(query, "name"), ui_name, -1);
xmlnode_insert_data(xmlnode_new_child(query, "version"), version_complete, -1);
g_free(version_complete);
} else {
xmlnode_insert_data(xmlnode_new_child(query, "name"), "libpurple", -1);
xmlnode_insert_data(xmlnode_new_child(query, "version"), VERSION, -1);
}
#if 0
if(os) {
xmlnode_insert_data(xmlnode_new_child(query, "os"), os, -1);
g_free(os);
}
#endif
jabber_iq_send(iq);
}
}
static
void
lastfm_ws_fetch(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message)
{
trace("Fetched %d bytes of data %s", len, error_message ? error_message : "");
if (url_text)
{
trace("%s", url_text);
xmlnode *response = xmlnode_from_str(url_text, -1);
if (response)
{
xmlnode *recenttracks = xmlnode_get_child(response, "recenttracks");
if (recenttracks)
{
xmlnode *track = xmlnode_get_child(recenttracks, "track");
if (track)
{
const char *nowplaying = xmlnode_get_attrib(track, "nowplaying");
data_from_node(track, "name", lastfm_ws_ti.track);
data_from_node(track, "album", lastfm_ws_ti.album);
data_from_node(track, "artist", lastfm_ws_ti.artist);
if (nowplaying)
{
lastfm_ws_ti.status = PLAYER_STATUS_PLAYING;
}
else
{
lastfm_ws_ti.status = PLAYER_STATUS_STOPPED;
}
lastfm_ws_ti.player = "Last.fm";
}
}
xmlnode_free(response);
}
else
{
trace("Last.fm response was badly formed XML");
}
}
}
static void
jabber_si_xfer_bytestreams_listen_cb(int sock, gpointer data)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx;
JabberIq *iq;
xmlnode *query, *streamhost;
char *jid, *port;
jsx = xfer->data;
jsx->listen_data = NULL;
if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL) {
gaim_xfer_unref(xfer);
return;
}
gaim_xfer_unref(xfer);
if (sock < 0) {
gaim_xfer_cancel_local(xfer);
return;
}
iq = jabber_iq_new_query(jsx->js, JABBER_IQ_SET,
"http://jabber.org/protocol/bytestreams");
xmlnode_set_attrib(iq->node, "to", xfer->who);
query = xmlnode_get_child(iq->node, "query");
xmlnode_set_attrib(query, "sid", jsx->stream_id);
streamhost = xmlnode_new_child(query, "streamhost");
jid = g_strdup_printf("%s@%s/%s", jsx->js->user->node,
jsx->js->user->domain, jsx->js->user->resource);
xmlnode_set_attrib(streamhost, "jid", jid);
g_free(jid);
/* XXX: shouldn't we use the public IP or something? here */
xmlnode_set_attrib(streamhost, "host",
gaim_network_get_my_ip(jsx->js->fd));
xfer->local_port = gaim_network_get_port_from_fd(sock);
port = g_strdup_printf("%hu", xfer->local_port);
xmlnode_set_attrib(streamhost, "port", port);
g_free(port);
xfer->watcher = gaim_input_add(sock, GAIM_INPUT_READ,
jabber_si_xfer_bytestreams_send_connected_cb, xfer);
/* XXX: insert proxies here */
/* XXX: callback to find out which streamhost they used, or see if they
* screwed it up */
jabber_iq_send(iq);
}
gboolean gfire_game_load_config_xml(gboolean p_force)
{
if(!p_force && gfire_games_config)
return TRUE;
xmlnode *node = NULL;
gchar *filename = g_build_filename(purple_user_dir(), "gfire_game_config.xml", NULL);
if(filename)
{
purple_debug(PURPLE_DEBUG_INFO, "gfire", "Loading Game Launch Data from: %s\n", filename);
g_free(filename);
}
node = purple_util_read_xml_from_file("gfire_game_config.xml", "Gfire Game Config List");
if(!node)
{
purple_debug(PURPLE_DEBUG_ERROR, "gfire", "gfire_game_load_config_xml: Couldn't load game config.\n");
return FALSE;
}
// Check for a valid game config
if(g_utf8_collate(node->name, "game_config"))
{
xmlnode_free(node);
return FALSE;
}
// Check for a valid version
if(!xmlnode_get_attrib(node, "version") || g_utf8_collate(xmlnode_get_attrib(node, "version"), "2"))
{
xmlnode_free(node);
return FALSE;
}
// Delete all old configurations
gfire_game_config_cleanup();
// Parse all games
xmlnode *game_node = xmlnode_get_child(node, "game");
while(game_node)
{
gfire_game_configuration *gconf = gfire_game_configuration_create_from_xml(game_node);
if(gconf)
gfire_games_config = g_list_append(gfire_games_config, gconf);
game_node = xmlnode_get_next_twin(game_node);
}
gfire_game_config_sort();
xmlnode_free(node);
return TRUE;
}
CoinCoinMessage* coincoin_message_new(gint64 id, xmlnode* post)
{
CoinCoinMessage* msg;
xmlnode* message = xmlnode_get_child(post, "message");
xmlnode* info = xmlnode_get_child(post, "info");
xmlnode* login = xmlnode_get_child(post, "login");
gchar *data, *ptr;
static struct tm t;
time_t tt = time(NULL);
if(!message || !info || !login)
return NULL;
/* Parse time */
if (sscanf(xmlnode_get_attrib(post, "time"), "%4d%2d%2d%2d%2d%2d", &t.tm_year,&t.tm_mon,&t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec) == 6)
{
t.tm_year -= 1900;
t.tm_mon -= 1;
tt = mktime(&t);
}
/* Skip chars before message. */
ptr = data = xmlnode_get_data(message);
while(ptr && *ptr && (*ptr == '\t' || *ptr == '\n' || *ptr == '\r'))
++ptr;
msg = g_new0(CoinCoinMessage, 1);
if(!msg)
{
return NULL;
}
msg->message = g_strdup(ptr);
msg->info = xmlnode_get_data(info);
msg->from = xmlnode_get_data(login);
msg->timestamp = tt;
msg->id = id;
msg->ref = 1;
msg->multiple = FALSE;
g_free(data);
return msg;
}
/****************************************
* OIM GetMetadata request
* **************************************/
static void
msn_oim_get_metadata_cb(MsnSoapMessage *request, MsnSoapMessage *response,
gpointer data)
{
MsnOim *oim = data;
if (response) {
msn_parse_oim_xml(oim,
xmlnode_get_child(response->xml, "Body/GetMetadataResponse/MD"));
}
}
static void do_pep_iq_request_item_callback(JabberStream *js, xmlnode *packet, gpointer data) {
const char *from = xmlnode_get_attrib(packet,"from");
xmlnode *pubsub = xmlnode_get_child_with_namespace(packet,"pubsub","http://jabber.org/protocol/pubsub");
xmlnode *items = NULL;
JabberPEPHandler *cb = data;
if(pubsub)
items = xmlnode_get_child(pubsub, "items");
cb(js, from, items);
}
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;
}
void twitter_send_request_cb(PurpleUtilFetchUrlData *url_data, gpointer user_data,
const gchar *url_text, gsize len,
const gchar *server_error_message)
{
TwitterSendRequestData *request_data = user_data;
const gchar *error_message = NULL;
gchar *error_node_text = NULL;
xmlnode *response_node = NULL;
TwitterRequestErrorType error_type = TWITTER_REQUEST_ERROR_NONE;
purple_debug_info("twitter", "Response: %s\n", url_text);
if (server_error_message)
{
error_type = TWITTER_REQUEST_ERROR_SERVER;
error_message = server_error_message;
} else {
response_node = xmlnode_from_str(url_text, len);
if (!response_node)
{
error_type = TWITTER_REQUEST_ERROR_INVALID_XML;
error_message = url_text;
} else {
xmlnode *error_node;
if ((error_node = xmlnode_get_child(response_node, "error")) != NULL)
{
error_type = TWITTER_REQUEST_ERROR_TWITTER_GENERAL;
error_node_text = xmlnode_get_data(error_node);
error_message = error_node_text;
}
}
}
if (error_type != TWITTER_REQUEST_ERROR_NONE)
{
TwitterRequestErrorData *error_data = g_new0(TwitterRequestErrorData, 1);
error_data->type = error_type;
error_data->message = error_message;
//error_data->response_node = response_node;
if (request_data->error_func)
request_data->error_func(request_data->account, error_data, request_data->user_data);
g_free(error_data);
} else {
if (request_data->success_func)
request_data->success_func(request_data->account, response_node, request_data->user_data);
}
if (response_node != NULL)
xmlnode_free(response_node);
if (error_node_text != NULL)
g_free(error_node_text);
g_free(request_data);
}
gboolean gfire_game_load_games_xml()
{
xmlnode *node = NULL;
gchar *filename = g_build_filename(purple_user_dir(), "gfire_games.xml", NULL);
if(filename)
{
purple_debug(PURPLE_DEBUG_INFO, "gfire", "Loading Game Data from: %s\n", filename);
g_free(filename);
}
node = purple_util_read_xml_from_file("gfire_games.xml", "Gfire Games List");
if(!node)
{
purple_debug(PURPLE_DEBUG_ERROR, "gfire", "gfire_game_load_games_xml: Couldn't load game list.\n");
return FALSE;
}
// Delete all old games
gfire_game_cleanup();
// Read the games version
if(g_utf8_collate(node->name, "games"))
{
xmlnode_free(node);
return FALSE;
}
if(!xmlnode_get_attrib(node, "version"))
gfire_games_version = 0;
else
sscanf(xmlnode_get_attrib(node, "version"), "%u", &gfire_games_version);
// Read all games
xmlnode *game_node = xmlnode_get_child(node, "game");
while(game_node)
{
gboolean external = FALSE;
gfire_game *game = gfire_game_create_from_xml(game_node, &external);
if(game)
{
gfire_games = g_list_append(gfire_games, game);
if(external)
gfire_games_external = g_list_append(gfire_games_external, game);
}
game_node = xmlnode_get_next_twin(game_node);
}
xmlnode_free(node);
return TRUE;
}
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;
}
}