static gfire_game_configuration *gfire_game_configuration_create_from_xml(xmlnode *p_node)
{
xmlnode *command_node = xmlnode_get_child(p_node, "command");
if(!command_node)
return NULL;
gfire_game_configuration *ret = g_malloc0(sizeof(gfire_game_configuration));
if(xmlnode_get_attrib(p_node, "id"))
sscanf(xmlnode_get_attrib(p_node, "id"), "%u", &ret->game_id);
xmlnode *cur_node = xmlnode_get_child(command_node, "detect");
if(cur_node)
ret->detect_file = xmlnode_get_data_unescaped(cur_node);
cur_node = xmlnode_get_child(command_node, "launch");
if(cur_node)
ret->launch_file = xmlnode_get_data_unescaped(cur_node);
cur_node = xmlnode_get_child(command_node, "prefix");
if(cur_node)
ret->launch_prefix = xmlnode_get_data_unescaped(cur_node);
return ret;
}
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);
}
JabberData *
jabber_data_create_from_xml(xmlnode *tag)
{
JabberData *data = g_new0(JabberData, 1);
gsize size;
gpointer raw_data = NULL;
if (data == NULL) {
purple_debug_error("jabber", "Could not allocate data object\n");
g_free(data);
return NULL;
}
/* check if this is a "data" tag */
if (strcmp(tag->name, "data") != 0) {
purple_debug_error("jabber", "Invalid data element");
g_free(data);
return NULL;
}
data->cid = g_strdup(xmlnode_get_attrib(tag, "cid"));
data->type = g_strdup(xmlnode_get_attrib(tag, "type"));
raw_data = xmlnode_get_data(tag);
data->data = purple_base64_decode(raw_data, &size);
data->size = size;
g_free(raw_data);
return data;
}
result base_to_deliver(instance id, dpacket p, void *arg)
{
char *log_data = xmlnode_get_data(p->x);
char *subject;
xmlnode message;
if (log_data == NULL)
return r_ERR;
message = xmlnode_new_tag("message");
xmlnode_insert_cdata(xmlnode_insert_tag(message, "body"), log_data,
-1);
subject =
spools(xmlnode_pool(message), "Log Packet from ",
xmlnode_get_attrib(p->x, "from"),
xmlnode_pool(message));
xmlnode_insert_cdata(xmlnode_insert_tag(message, "thread"),
shahash(subject), -1);
xmlnode_insert_cdata(xmlnode_insert_tag(message, "subject"),
subject, -1);
xmlnode_put_attrib(message, "from",
xmlnode_get_attrib(p->x, "from"));
xmlnode_put_attrib(message, "to", (char *) arg);
deliver(dpacket_new(message), id);
pool_free(p->p);
return r_DONE;
}
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);
}
}
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 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);
}
}
void jutil_tofrom(xmlnode x)
{
char *to, *from;
to = xmlnode_get_attrib(x,"to");
from = xmlnode_get_attrib(x,"from");
xmlnode_put_attrib(x,"from",to);
xmlnode_put_attrib(x,"to",from);
}
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);
}
static void roomlist_disco_result_cb(JabberStream *js, const char *from,
JabberIqType type, const char *id,
xmlnode *packet, gpointer data)
{
xmlnode *query;
xmlnode *item;
if(!js->roomlist)
return;
if (type == JABBER_IQ_ERROR) {
char *err = jabber_parse_error(js, packet, NULL);
purple_notify_error(js->gc, _("Error"),
_("Error retrieving room list"), err);
purple_roomlist_set_in_progress(js->roomlist, FALSE);
purple_roomlist_unref(js->roomlist);
js->roomlist = NULL;
g_free(err);
return;
}
if(!(query = xmlnode_get_child(packet, "query"))) {
char *err = jabber_parse_error(js, packet, NULL);
purple_notify_error(js->gc, _("Error"),
_("Error retrieving room list"), err);
purple_roomlist_set_in_progress(js->roomlist, FALSE);
purple_roomlist_unref(js->roomlist);
js->roomlist = NULL;
g_free(err);
return;
}
for(item = xmlnode_get_child(query, "item"); item;
item = xmlnode_get_next_twin(item)) {
const char *name;
PurpleRoomlistRoom *room;
JabberID *jid;
if(!(jid = jabber_id_new(xmlnode_get_attrib(item, "jid"))))
continue;
name = xmlnode_get_attrib(item, "name");
room = purple_roomlist_room_new(PURPLE_ROOMLIST_ROOMTYPE_ROOM, jid->node, NULL);
purple_roomlist_room_add_field(js->roomlist, room, jid->node);
purple_roomlist_room_add_field(js->roomlist, room, jid->domain);
purple_roomlist_room_add_field(js->roomlist, room, name ? name : "");
purple_roomlist_room_add(js->roomlist, room);
jabber_id_free(jid);
}
purple_roomlist_set_in_progress(js->roomlist, FALSE);
purple_roomlist_unref(js->roomlist);
js->roomlist = NULL;
}
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;
}
static void roomlist_disco_result_cb(JabberStream *js, xmlnode *packet, gpointer data)
{
xmlnode *query;
xmlnode *item;
const char *type;
if(!js->roomlist)
return;
if(!(type = xmlnode_get_attrib(packet, "type")) || strcmp(type, "result")) {
char *err = jabber_parse_error(js,packet);
gaim_notify_error(js->gc, _("Error"),
_("Error retrieving room list"), err);
gaim_roomlist_set_in_progress(js->roomlist, FALSE);
gaim_roomlist_unref(js->roomlist);
js->roomlist = NULL;
g_free(err);
return;
}
if(!(query = xmlnode_get_child(packet, "query"))) {
char *err = jabber_parse_error(js, packet);
gaim_notify_error(js->gc, _("Error"),
_("Error retrieving room list"), err);
gaim_roomlist_set_in_progress(js->roomlist, FALSE);
gaim_roomlist_unref(js->roomlist);
js->roomlist = NULL;
g_free(err);
return;
}
for(item = xmlnode_get_child(query, "item"); item;
item = xmlnode_get_next_twin(item)) {
const char *name;
GaimRoomlistRoom *room;
JabberID *jid;
if(!(jid = jabber_id_new(xmlnode_get_attrib(item, "jid"))))
continue;
name = xmlnode_get_attrib(item, "name");
room = gaim_roomlist_room_new(GAIM_ROOMLIST_ROOMTYPE_ROOM, jid->node, NULL);
gaim_roomlist_room_add_field(js->roomlist, room, jid->node);
gaim_roomlist_room_add_field(js->roomlist, room, jid->domain);
gaim_roomlist_room_add_field(js->roomlist, room, name ? name : "");
gaim_roomlist_room_add(js->roomlist, room);
jabber_id_free(jid);
}
gaim_roomlist_set_in_progress(js->roomlist, FALSE);
gaim_roomlist_unref(js->roomlist);
js->roomlist = NULL;
}
void
jingle_parse(JabberStream *js, const char *from, JabberIqType type,
const char *id, xmlnode *jingle)
{
const gchar *action;
const gchar *sid;
JingleActionType action_type;
JingleSession *session;
if (type != JABBER_IQ_SET) {
/* TODO: send iq error here */
return;
}
if (!(action = xmlnode_get_attrib(jingle, "action"))) {
/* TODO: send iq error here */
return;
}
action_type = jingle_get_action_type(action);
purple_debug_info("jabber", "got Jingle package action = %s\n",
action);
if (!(sid = xmlnode_get_attrib(jingle, "sid"))) {
/* send iq error here */
return;
}
if (!(session = jingle_session_find_by_sid(js, sid))
&& strcmp(action, "session-initiate")) {
purple_debug_error("jingle", "jabber_jingle_session_parse couldn't find session\n");
/* send iq error here */
return;
}
if (action_type == JINGLE_SESSION_INITIATE) {
if (session) {
/* This should only happen if you start a session with yourself */
purple_debug_error("jingle", "Jingle session with "
"id={%s} already exists\n", sid);
/* send iq error */
return;
} else {
char *own_jid = g_strdup_printf("%s@%s/%s", js->user->node,
js->user->domain, js->user->resource);
session = jingle_session_create(js, sid, own_jid, from, FALSE);
g_free(own_jid);
}
}
jingle_actions[action_type].handler(session, jingle);
}
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;
}
static void
jingle_handle_content_accept(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");
jingle_session_accept_content(session, name, creator);
/* signal here */
}
}
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);
}
}
void jabber_oob_parse(JabberStream *js, xmlnode *packet) {
JabberOOBXfer *jox;
PurpleXfer *xfer;
char *filename;
char *url;
const char *type;
xmlnode *querynode, *urlnode;
if(!(type = xmlnode_get_attrib(packet, "type")) || strcmp(type, "set"))
return;
if(!(querynode = xmlnode_get_child(packet, "query")))
return;
if(!(urlnode = xmlnode_get_child(querynode, "url")))
return;
url = xmlnode_get_data(urlnode);
jox = g_new0(JabberOOBXfer, 1);
purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL);
g_free(url);
jox->js = js;
jox->headers = g_string_new("");
jox->iq_id = g_strdup(xmlnode_get_attrib(packet, "id"));
xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE,
xmlnode_get_attrib(packet, "from"));
if (xfer)
{
xfer->data = jox;
if(!(filename = g_strdup(g_strrstr(jox->page, "/"))))
filename = g_strdup(jox->page);
purple_xfer_set_filename(xfer, filename);
g_free(filename);
purple_xfer_set_init_fnc(xfer, jabber_oob_xfer_init);
purple_xfer_set_end_fnc(xfer, jabber_oob_xfer_end);
purple_xfer_set_request_denied_fnc(xfer, jabber_oob_xfer_recv_denied);
purple_xfer_set_cancel_recv_fnc(xfer, jabber_oob_xfer_recv_canceled);
purple_xfer_set_read_fnc(xfer, jabber_oob_xfer_read);
purple_xfer_set_start_fnc(xfer, jabber_oob_xfer_start);
js->oob_file_transfers = g_list_append(js->oob_file_transfers, xfer);
purple_xfer_request(xfer);
}
}
static void
jingle_handle_transport_reject(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");
JingleContent *content = jingle_session_find_content(session, name, creator);
jingle_content_remove_pending_transport(content);
}
}
jpacket jpacket_reset(jpacket p)
{
char *val;
xmlnode x;
x = p->x;
memset(p,0,sizeof(_jpacket));
p->x = x;
p->p = xmlnode_pool(x);
if(strcmp(xmlnode_get_name(x),"message") == 0)
{
p->type = JPACKET_MESSAGE;
}else if(strcmp(xmlnode_get_name(x),"presence") == 0)
{
p->type = JPACKET_PRESENCE;
val = xmlnode_get_attrib(x, "type");
if(val == NULL)
p->subtype = JPACKET__AVAILABLE;
else if(strcmp(val,"unavailable") == 0)
p->subtype = JPACKET__UNAVAILABLE;
else if(strcmp(val,"probe") == 0)
p->subtype = JPACKET__PROBE;
else if(strcmp(val,"error") == 0)
p->subtype = JPACKET__ERROR;
else if(strcmp(val,"invisible") == 0)
p->subtype = JPACKET__INVISIBLE;
else if(*val == 's' || *val == 'u')
p->type = JPACKET_S10N;
else
p->type = JPACKET_UNKNOWN;
}else if(strcmp(xmlnode_get_name(x),"iq") == 0)
{
p->type = JPACKET_IQ;
p->iq = xmlnode_get_tag(x,"?xmlns");
p->iqns = xmlnode_get_attrib(p->iq,"xmlns");
}
/* set up the jids if any, flag packet as unknown if they are unparseable */
val = xmlnode_get_attrib(x,"to");
if(val != NULL)
if((p->to = jid_new(p->p, val)) == NULL)
p->type = JPACKET_UNKNOWN;
val = xmlnode_get_attrib(x,"from");
if(val != NULL)
if((p->from = jid_new(p->p, val)) == NULL)
p->type = JPACKET_UNKNOWN;
return p;
}
void dnsrv_process_xstream_io(int type, xmlnode x, void* arg)
{
dns_io di = (dns_io)arg;
char* hostname = NULL;
char* ipaddr = NULL;
char* resendhost = NULL;
dns_packet_list head = NULL;
dns_packet_list heado = NULL;
/* Node Format: <host ip="201.83.28.2">foo.org</host> */
if (type == XSTREAM_NODE)
{
log_debug(ZONE,"incoming resolution: %s",xmlnode2str(x));
hostname = xmlnode_get_data(x);
/* whatever the response was, let's cache it */
xmlnode_free((xmlnode)xhash_get(di->cache_table,hostname)); /* free any old cache, shouldn't ever be any */
xmlnode_put_vattrib(x,"t",(void*)time(NULL));
xhash_put(di->cache_table,hostname,(void*)x);
/* Get the hostname and look it up in the hashtable */
head = xhash_get(di->packet_table, hostname);
/* Process the packet list */
if (head != NULL)
{
ipaddr = xmlnode_get_attrib(x, "ip");
resendhost = xmlnode_get_attrib(x, "to");
/* Remove the list from the hashtable */
xhash_zap(di->packet_table, hostname);
/* Walk the list and insert IPs */
while(head != NULL)
{
heado = head;
/* Move to next.. */
head = head->next;
/* Deliver the packet */
dnsrv_resend(heado->packet->x, ipaddr, resendhost);
}
}
/* Host name was not found, something is _TERRIBLY_ wrong! */
else
log_debug(ZONE, "Resolved unknown host/ip request: %s\n", xmlnode2str(x));
return; /* we cached x above, so we don't free it below :) */
}
xmlnode_free(x);
}
void
xep_bytestreams_parse(PurpleConnection *pc, xmlnode *packet, PurpleBuddy *pb)
{
const char *type, *from, *iq_id, *sid;
xmlnode *query, *streamhost;
BonjourData *bd;
PurpleXfer *xfer;
g_return_if_fail(pc != NULL);
g_return_if_fail(packet != NULL);
g_return_if_fail(pb != NULL);
bd = (BonjourData*) pc->proto_data;
if(bd == NULL)
return;
purple_debug_info("bonjour", "xep-bytestreams-parse.\n");
type = xmlnode_get_attrib(packet, "type");
from = purple_buddy_get_name(pb);
query = xmlnode_get_child(packet,"query");
if(!type)
return;
query = xmlnode_copy(query);
if (!query)
return;
if(!purple_strequal(type, "set")) {
purple_debug_info("bonjour", "bytestream offer Message type - Unknown-%s.\n", type);
return;
}
purple_debug_info("bonjour", "bytestream offer Message type - SET.\n");
iq_id = xmlnode_get_attrib(packet, "id");
sid = xmlnode_get_attrib(query, "sid");
xfer = bonjour_si_xfer_find(bd, sid, from);
streamhost = xmlnode_get_child(query, "streamhost");
if(xfer && streamhost && __xep_bytestreams_parse(pb, xfer, streamhost, iq_id))
return; /* success */
purple_debug_error("bonjour", "Didn't find an acceptable streamhost.\n");
if (iq_id && xfer != NULL)
xep_ft_si_reject(bd, iq_id, xfer->who, "404", "cancel");
}
gboolean AddBuddy_cb(struct fetion_account_data *sip, struct sipmsg *msg, struct transaction *tc)
{
xmlnode *root,*item;
const gchar *uri, *name ,*group_id;
struct group_attr *g_attr;
gchar *buddy_name;
PurpleBuddy *b;
PurpleGroup *g = NULL;
struct fetion_buddy *bs;
if(msg->response != 522)
{
root = xmlnode_from_str(msg->body, msg->bodylen);
item = xmlnode_get_child(root,"contacts/buddies/buddy");
g_return_val_if_fail(item!=NULL,FALSE);
uri = xmlnode_get_attrib(item, "uri");
name = xmlnode_get_attrib(item, "local-name");
group_id = xmlnode_get_attrib(item, "buddy-lists");
buddy_name = g_strdup_printf("%s", uri);
g_attr = g_hash_table_lookup(sip->group,group_id);
if(g_attr==NULL)
{
g = purple_find_group("未分组");
if(!g)
g = purple_group_new("未分组");
}
else
{
g = purple_find_group(g_attr->name);
if(!g)
g = purple_group_new(g_attr->name);
}
b = purple_find_buddy(sip->account, buddy_name);
if(!b){
b = purple_buddy_new(sip->account, buddy_name, NULL);
}
g_free(buddy_name);
purple_blist_add_buddy(b, NULL, g, NULL);
if(name!=NULL && *name!='\0')
purple_blist_alias_buddy(b, name);
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
fetion_subscribe_exp(sip,bs);
}
static PidginThemeFont *
pidgin_theme_font_parse(xmlnode *node)
{
const char *font;
const char *colordesc;
GdkColor color;
font = xmlnode_get_attrib(node, "font");
if ((colordesc = xmlnode_get_attrib(node, "color")) == NULL ||
!gdk_color_parse(colordesc, &color))
gdk_color_parse(DEFAULT_TEXT_COLOR, &color);
return pidgin_theme_font_new(font, &color);
}
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);
}
/* returns the priority on a presence packet */
int jutil_priority(xmlnode x)
{
char *str;
int p;
if(x == NULL)
return -1;
if(xmlnode_get_attrib(x,"type") != NULL)
return -1;
x = xmlnode_get_tag(x,"priority");
if(x == NULL)
return 0;
str = xmlnode_get_data((x));
if(str == NULL)
return 0;
p = atoi(str);
if(p >= 0)
return p;
else
return 0;
}
mreturn mod_browse_reply(mapi m, void *arg)
{
xmlnode browse, ns, cur;
session s;
if (m->packet->type != JPACKET_IQ)
return M_IGNORE;
if (!NSCHECK(m->packet->iq, NS_BROWSE))
return M_PASS;
/* first, is this a valid request? */
switch (jpacket_subtype(m->packet)) {
case JPACKET__RESULT:
case JPACKET__ERROR:
return M_PASS;
case JPACKET__SET:
js_bounce(m->si, m->packet->x, TERROR_NOTALLOWED);
return M_HANDLED;
}
log_debug("handling query for user %s", m->user->user);
/* get this dudes browse info */
browse = mod_browse_get(m, m->packet->to);
/* insert the namespaces */
ns = xdb_get(m->si->xc, m->packet->to, NS_XDBNSLIST);
for (cur = xmlnode_get_firstchild(ns); cur != NULL;
cur = xmlnode_get_nextsibling(cur))
if (xmlnode_get_attrib(cur, "type") == NULL)
xmlnode_insert_tag_node(browse, cur); /* only include the generic <ns>foo</ns> */
xmlnode_free(ns);
/* include any connected resources if there's a s10n from them */
if (js_trust(m->user, m->packet->from)) {
SEM_LOCK(m->user->sem);
for (s = m->user->sessions; s != NULL; s = s->next) {
/* if(s->priority < 0) continue; *** include all resources I guess */
if (xmlnode_get_tag
(browse,
spools(m->packet->p, "?jid=", jid_full(s->id),
m->packet->p)) != NULL)
continue; /* already in the browse result */
cur = xmlnode_insert_tag(browse, "user");
xmlnode_put_attrib(cur, "type", "client");
xmlnode_put_attrib(cur, "jid", jid_full(s->id));
}
SEM_UNLOCK(m->user->sem);
}
/* XXX include iq:filter forwards */
jutil_iqresult(m->packet->x);
jpacket_reset(m->packet);
xmlnode_insert_tag_node(m->packet->x, browse);
js_deliver(m->si, m->packet);
xmlnode_free(browse);
return M_HANDLED;
}
static SubscriptionType get_subscribe(xmlnode node, unsigned int file_format_version){
char *tmp;
tmp=xmlnode_get_attrib(node,"subscribe");
if (tmp) {
switch (tmp[0]) {
case 'f':
return SUB_FROM;
break;
case 't':
/* version 2.2.0 has a bug which causes
* SUB_BOTH to be changed to SUB_TO
* this will force resynchronisation with
* user's roster. User will be asked for
* subscription authorisation if the
* subscription was really "to"
*/
if (file_format_version<=0x02020000) return SUB_UNDEFINED;
else return SUB_TO;
break;
case 'b':
return SUB_BOTH;
break;
default:
return SUB_NONE;
break;
}
}
return SUB_UNDEFINED;
}
/**
* Convert the msim markup <b> tag (background color) into HTML.
*/
static void
msim_markup_b_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
{
const gchar *color;
gchar *purple_color;
color = xmlnode_get_attrib(root, "v");
if (!color) {
*begin = g_strdup("");
*end = g_strdup("");
purple_debug_info("msim", "msim_markup_b_to_html: <b> w/o v attr\n");
/* TODO: log as unrecognized. */
return;
}
purple_color = msim_color_to_purple(color);
#ifdef USE_CSS_FORMATTING
*begin = g_strdup_printf("<span style='background-color: %s'>", purple_color);
*end = g_strdup("</span>");
#else
*begin = g_strdup_printf("<body bgcolor='%s'>", purple_color);
*end = g_strdup("</body>");
#endif
g_free(purple_color);
}
/** Convert the msim markup <i> tag (emoticon image) into HTML. */
static void
msim_markup_i_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
{
const gchar *name;
guint i;
struct MSIM_EMOTICON *emote;
name = xmlnode_get_attrib(root, "n");
if (!name) {
purple_debug_info("msim", "msim_markup_i_to_html: <i> w/o n\n");
*begin = g_strdup("");
*end = g_strdup("");
/* TODO: log as unrecognized */
return;
}
/* Find and use canonical form of smiley symbol. */
for (i = 0; (emote = &msim_emoticons[i]) && emote->name != NULL; ++i) {
if (g_str_equal(name, emote->name)) {
*begin = g_strdup(emote->symbol);
*end = g_strdup("");
return;
}
}
/* Couldn't find it, sorry. Try to degrade gracefully. */
*begin = g_strdup_printf("**%s**", name);
*end = g_strdup("");
}
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;
}
