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