result base_to_config(instance id, xmlnode x, void *arg) { if (id == NULL) { jid j = jid_new(xmlnode_pool(x), xmlnode_get_data(x)); log_debug("base_to_config validating configuration\n"); if (j == NULL) { xmlnode_put_attrib(x, "error", "'to' tag must contain a jid to send log data to"); log_debug("Invalid Configuration for base_to"); return r_ERR; } return r_PASS; } log_debug("base_to configuring instance %s", id->id); if (id->type != p_LOG) { log_alert(NULL, "ERROR in instance %s: <to>..</to> element only allowed in log sections", id->id); return r_ERR; } register_phandler(id, o_DELIVER, base_to_deliver, (void *) xmlnode_get_data(x)); return r_DONE; }
/** * init the module, register callbacks * * builds a list of JabberIDs where presences should be blind carbon copied to. * (Enclosing each in a <bcc/> element, which are contained in one <presence/> * element in the session manager configuration.) * * registers mod_presence_session() as a callback, that gets notified on new sessions * and mod_presence_deliver() as a callback to deliver presence stanzas locally. * * @param si the session manager instance */ JSM_FUNC void mod_presence(jsmi si) { xmlnode cfg = js_config(si, "presence"); modpres_conf conf = (modpres_conf) pmalloco(si->p, sizeof(_modpres_conf)); log_debug("init"); for (cfg = xmlnode_get_firstchild(cfg); cfg != NULL; cfg = xmlnode_get_nextsibling(cfg)) { char *element_name = NULL; if (xmlnode_get_type(cfg) != NTYPE_TAG) continue; element_name = xmlnode_get_name(cfg); if (j_strcmp(element_name, "bcc") == 0) { if (conf->bcc == NULL) conf->bcc = jid_new(si->p, xmlnode_get_data(cfg)); else jid_append(conf->bcc, jid_new(si->p, xmlnode_get_data(cfg))); } else if (j_strcmp(element_name, "presence2xdb") == 0) { conf->pres_to_xdb++; } } js_mapi_register(si, e_DELIVER, mod_presence_deliver, NULL); js_mapi_register(si, e_SESSION, mod_presence_session, (void *) conf); }
static void jabber_vcard_parse_avatar(JabberStream *js, const char *from, JabberIqType type, const char *id, xmlnode *packet, gpointer blah) { JabberBuddy *jb = NULL; xmlnode *vcard, *photo, *binval, *fn, *nick; char *text; if(!from) return; jb = jabber_buddy_find(js, from, TRUE); js->pending_avatar_requests = g_slist_remove(js->pending_avatar_requests, jb); if((vcard = xmlnode_get_child(packet, "vCard")) || (vcard = xmlnode_get_child_with_namespace(packet, "query", "vcard-temp"))) { /* The logic here regarding the nickname and full name is copied from * buddy.c:jabber_vcard_parse. */ gchar *nickname = NULL; if ((fn = xmlnode_get_child(vcard, "FN"))) nickname = xmlnode_get_data(fn); if ((nick = xmlnode_get_child(vcard, "NICKNAME"))) { char *tmp = xmlnode_get_data(nick); char *bare_jid = jabber_get_bare_jid(from); if (tmp && strstr(bare_jid, tmp) == NULL) { g_free(nickname); nickname = tmp; } else if (tmp) g_free(tmp); g_free(bare_jid); } if (nickname) { serv_got_alias(js->gc, from, nickname); g_free(nickname); } if ((photo = xmlnode_get_child(vcard, "PHOTO")) && (binval = xmlnode_get_child(photo, "BINVAL")) && (text = xmlnode_get_data(binval))) { guchar *data; gsize size; data = purple_base64_decode(text, &size); if (data) { gchar *hash = jabber_calculate_data_hash(data, size, "sha1"); purple_buddy_icons_set_for_user(js->gc->account, from, data, size, hash); g_free(hash); } g_free(text); } } }
static gboolean msn_soap_handle_body(MsnSoapConnection *conn, MsnSoapMessage *response) { xmlnode *body = xmlnode_get_child(response->xml, "Body"); xmlnode *fault = xmlnode_get_child(response->xml, "Fault"); if (fault) { xmlnode *faultcode = xmlnode_get_child(fault, "faultcode"); if (faultcode != NULL) { char *faultdata = xmlnode_get_data(faultcode); if (faultdata && g_str_equal(faultdata, "psf:Redirect")) { xmlnode *url = xmlnode_get_child(fault, "redirectUrl"); if (url) { char *urldata = xmlnode_get_data(url); if (urldata) msn_soap_handle_redirect(conn, urldata); g_free(urldata); } g_free(faultdata); msn_soap_message_destroy(response); return TRUE; } else if (faultdata && g_str_equal(faultdata, "wsse:FailedAuthentication")) { xmlnode *reason = xmlnode_get_child(fault, "faultstring"); char *reasondata = NULL; if (reason) reasondata = xmlnode_get_data(reason); msn_soap_connection_sanitize(conn, TRUE); msn_session_set_error(conn->session, MSN_ERROR_AUTH, reasondata); g_free(reasondata); g_free(faultdata); msn_soap_message_destroy(response); return FALSE; } g_free(faultdata); } } if (fault || body) { if (conn->current_request) { MsnSoapRequest *request = conn->current_request; conn->current_request = NULL; request->cb(request->message, response, request->cb_data); msn_soap_request_destroy(request, FALSE); } msn_soap_message_destroy(response); } return TRUE; }
static gboolean nexus_parse_token(MsnNexus *nexus, int id, xmlnode *node) { char *token_str, *expiry_str; const char *id_str; char **elems, **cur, **tokens; xmlnode *token = xmlnode_get_child(node, "RequestedSecurityToken/BinarySecurityToken"); xmlnode *secret = xmlnode_get_child(node, "RequestedProofToken/BinarySecret"); xmlnode *expires = xmlnode_get_child(node, "LifeTime/Expires"); if (!token) return FALSE; /* Use the ID that the server sent us */ if (id == -1) { id_str = xmlnode_get_attrib(token, "Id"); if (id_str == NULL) return FALSE; id = atol(id_str + 7) - 1; /* 'Compact#' or 'PPToken#' */ if (id >= nexus->token_len) return FALSE; /* Where did this come from? */ } token_str = xmlnode_get_data(token); if (token_str == NULL) return FALSE; g_hash_table_remove_all(nexus->tokens[id].token); elems = g_strsplit(token_str, "&", 0); for (cur = elems; *cur != NULL; cur++) { tokens = g_strsplit(*cur, "=", 2); g_hash_table_insert(nexus->tokens[id].token, tokens[0], tokens[1]); /* Don't free each of the tokens, only the array. */ g_free(tokens); } g_strfreev(elems); g_free(token_str); if (secret) nexus->tokens[id].secret = xmlnode_get_data(secret); else nexus->tokens[id].secret = NULL; /* Yay for MS using ISO-8601 */ expiry_str = xmlnode_get_data(expires); nexus->tokens[id].expiry = purple_str_to_time(expiry_str, FALSE, NULL, NULL, NULL); g_free(expiry_str); purple_debug_info("msn", "Updated ticket for domain '%s', expires at %" G_GINT64_FORMAT ".\n", ticket_domains[id][SSO_VALID_TICKET_DOMAIN], (gint64)nexus->tokens[id].expiry); return TRUE; }
int main(){ xmlnode point; xmlnode conf; conf=xmlnode_file("./test.xml"); point=conf; printf("\n"); printf("Tagname is %s.\n", xmlnode_get_name(point)); printf("Data is \"%s\"\n", xmlnode_get_data(point)); printf("Type is %d.\n", xmlnode_get_type(point)); point = xmlnode_get_firstchild(point); printf("\n"); printf("Tagname is %s.\n", xmlnode_get_name(point)); printf("Data is \"%s\"\n", xmlnode_get_data(point)); printf("Type is %d.\n", xmlnode_get_type(point)); point = xmlnode_get_nextsibling(point); printf("\n"); printf("Tagname is %s.\n", xmlnode_get_name(point)); printf("Data is %s.\n", xmlnode_get_data(point)); printf("Type is %d.\n", xmlnode_get_type(point)); point = xmlnode_get_nextsibling(point); printf("\n"); printf("Tagname is %s.\n", xmlnode_get_name(point)); printf("Data is %s.\n", xmlnode_get_data(point)); printf("Type is %d.\n", xmlnode_get_type(point)); point = xmlnode_get_nextsibling(point); printf("\n"); printf("Tagname is %s.\n", xmlnode_get_name(point)); printf("Data is %s.\n", xmlnode_get_data(point)); printf("Type is %d.\n", xmlnode_get_type(point)); point = xmlnode_get_nextsibling(point); /* point = xmlnode_get_nextsibling(point); point = xmlnode_get_firstchild(point); point = xmlnode_get_nextsibling(xmlnode_get_parent(point)); */ xmlnode_free(conf); } /* END MAIN */
/* Coprocess functionality */ void dnsrv_child_process_xstream_io(int type, xmlnode x, void* args) { dns_io di = (dns_io)args; char* hostname; char* str = NULL; dns_resend_list iternode = NULL; if (type == XSTREAM_NODE) { /* Get the hostname out... */ hostname = xmlnode_get_data(x); log_debug(ZONE, "dnsrv: Recv'd lookup request for %s", hostname); if (hostname != NULL) { /* For each entry in the svclist, try and resolve using the specified service and resend it to the specified host */ iternode = di->svclist; while (iternode != NULL) { str = srv_lookup(x->p, iternode->service, hostname); if (str != NULL) { log_debug(ZONE, "Resolved %s(%s): %s\tresend to:%s", hostname, iternode->service, str, iternode->host); xmlnode_put_attrib(x, "ip", str); xmlnode_put_attrib(x, "to", iternode->host); break; } iternode = iternode->next; } str = xmlnode2str(x); write(di->out, str, strlen(str)); } } xmlnode_free(x); }
/* 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; }
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; }
/* 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); } }
result base_file_deliver(instance id, dpacket p, void* arg) { char* message = NULL; basefile bf = (basefile) arg; char date[50],buf[200]; struct tm *today; unsigned long ltime; FILE * f; time( <ime ); /* once per second */ if ((ltime > bf->last_time) || (bf->f == NULL)) { /* try to route */ bf->last_time = ltime; /* lock */ pthread_mutex_lock(&(bf->sem)); today = localtime( <ime ); /* if day changed or new raport */ if ((bf->yesterday.tm_mday != today->tm_mday) || (bf->f == NULL)) { memcpy(&(bf->yesterday),today,sizeof(struct tm)); strftime((char *)date,128,"%Y_%m_%d",today); sprintf(buf,"%s_%s.log",bf->filename,date); f = bf->f; bf->f = fopen(buf,"at"); if (f) fclose(f); } /* unlock */ pthread_mutex_unlock(&(bf->sem)); } if (bf->f == NULL) { log_debug(ZONE,"base_file_deliver error: no file available to print to.\n"); return r_ERR; } message = xmlnode_get_data(p->x); if (message == NULL) { log_debug(ZONE,"base_file_deliver error: no message available to print.\n"); return r_ERR; } if (fprintf(bf->f,"%s\n", message) == EOF) { log_debug(ZONE,"base_file_deliver error: error writing to file(%d).\n", errno); return r_ERR; } fflush(bf->f); /* Release the packet */ pool_free(p->p); return r_DONE; }
/* loop through both a and b comparing everything, attribs, cdata, children, etc */ int xmlnode_cmp(xmlnode a, xmlnode b) { int ret = 0; while(1) { if(a == NULL && b == NULL) return 0; if(a == NULL || b == NULL) return -1; if(xmlnode_get_type(a) != xmlnode_get_type(b)) return -1; switch(xmlnode_get_type(a)) { case NTYPE_ATTRIB: ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b)); if(ret != 0) return -1; ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b)); if(ret != 0) return -1; break; case NTYPE_TAG: ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b)); if(ret != 0) return -1; ret = xmlnode_cmp(xmlnode_get_firstattrib(a), xmlnode_get_firstattrib(b)); if(ret != 0) return -1; ret = xmlnode_cmp(xmlnode_get_firstchild(a), xmlnode_get_firstchild(b)); if(ret != 0) return -1; break; case NTYPE_CDATA: ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b)); if(ret != 0) return -1; } a = xmlnode_get_nextsibling(a); b = xmlnode_get_nextsibling(b); } }
void jabber_stream_error(Stream *s,xmlnode x){ char *data; data=xmlnode_get_data(x); if (data==NULL) data="-unknown-"; g_critical(L_("Stream error: %s"),data); stream_close(s); stop_it=1; }
/* return the cdata from any tag */ char *xmlnode_get_tag_data(xmlnode parent, const char *name) { xmlnode tag; tag = xmlnode_get_tag(parent, name); if(tag == NULL) return NULL; return xmlnode_get_data(tag); }
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; }
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); }
char * xmlnode_get_data_unescaped(xmlnode *node) { char *escaped = xmlnode_get_data(node); char *unescaped = escaped ? purple_unescape_html(escaped) : NULL; g_free(escaped); return unescaped; }
static JabberSaslState jabber_cyrus_handle_challenge(JabberStream *js, xmlnode *packet, xmlnode **reply, char **error) { char *enc_in = xmlnode_get_data(packet); unsigned char *dec_in; char *enc_out; const char *c_out; unsigned int clen; gsize declen; dec_in = purple_base64_decode(enc_in, &declen); js->sasl_state = sasl_client_step(js->sasl, (char*)dec_in, declen, NULL, &c_out, &clen); g_free(enc_in); g_free(dec_in); if (js->sasl_state != SASL_CONTINUE && js->sasl_state != SASL_OK) { gchar *tmp = g_strdup_printf(_("SASL error: %s"), sasl_errdetail(js->sasl)); purple_debug_error("jabber", "Error is %d : %s\n", js->sasl_state, sasl_errdetail(js->sasl)); *error = tmp; return JABBER_SASL_STATE_FAIL; } else { xmlnode *response = xmlnode_new("response"); xmlnode_set_namespace(response, NS_XMPP_SASL); if (clen > 0) { /* Cyrus SASL 2.1.22 appears to contain code to add the charset * to the response for DIGEST-MD5 but there is no possibility * it will be executed. * * My reading of the digestmd5 plugin indicates the username and * realm are always encoded in UTF-8 (they seem to be the values * we pass in), so we need to ensure charset=utf-8 is set. */ if (!purple_strequal(js->current_mech, "DIGEST-MD5") || strstr(c_out, ",charset=")) /* If we're not using DIGEST-MD5 or Cyrus SASL is fixed */ enc_out = purple_base64_encode((unsigned char*)c_out, clen); else { char *tmp = g_strdup_printf("%s,charset=utf-8", c_out); enc_out = purple_base64_encode((unsigned char*)tmp, clen + 14); g_free(tmp); } xmlnode_insert_data(response, enc_out, -1); g_free(enc_out); } *reply = response; return JABBER_SASL_STATE_CONTINUE; } }
void jabber_oob_parse(JabberStream *js, const char *from, JabberIqType type, const char *id, xmlnode *querynode) { JabberOOBXfer *jox; PurpleXfer *xfer; char *filename; char *url; xmlnode *urlnode; if(type != JABBER_IQ_SET) return; if(!from) return; if(!(urlnode = xmlnode_get_child(querynode, "url"))) return; url = xmlnode_get_data(urlnode); jox = g_new0(JabberOOBXfer, 1); if (!purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL)) { g_free(url); return; } g_free(url); jox->js = js; jox->headers = g_string_new(""); jox->iq_id = g_strdup(id); xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE, 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_cancelled); 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); } }
/* places copy of node and node's siblings in parent */ void xmlnode_insert_node(xmlnode parent, xmlnode node) { if(node == NULL || parent == NULL) return; while(node != NULL) { switch(xmlnode_get_type(node)) { case NTYPE_ATTRIB: xmlnode_put_attrib(parent, xmlnode_get_name(node), xmlnode_get_data(node)); break; case NTYPE_TAG: xmlnode_insert_tag_node(parent, node); break; case NTYPE_CDATA: xmlnode_insert_cdata(parent, xmlnode_get_data(node), xmlnode_get_datasz(node)); } node = xmlnode_get_nextsibling(node); } }
/* we should be last in the list of modules */ JSM_FUNC void mod_log(jsmi si) { xmlnode cfg = js_config(si, "archive"); jid svcs = NULL; log_debug("mod_log init"); /* look for archiving service too */ for (cfg = xmlnode_get_firstchild(cfg); cfg != NULL; cfg = xmlnode_get_nextsibling(cfg)) { if (xmlnode_get_type(cfg) != NTYPE_TAG || j_strcmp(xmlnode_get_name(cfg), "service") != 0) continue; if (svcs == NULL) svcs = jid_new(si->p, xmlnode_get_data(cfg)); else jid_append(svcs, jid_new(si->p, xmlnode_get_data(cfg))); } js_mapi_register(si, e_SESSION, mod_log_session, (void *) svcs); }
result base_file_config(instance id, xmlnode x, void *arg) { basefile bf; if(id == NULL) { log_debug(ZONE,"base_file_config validating configuration"); if (xmlnode_get_data(x) == NULL) { log_debug(ZONE,"base_file_config error: no filename provided."); xmlnode_put_attrib(x,"error","'file' tag must contain a filename to write to"); return r_ERR; } return r_PASS; } log_debug(ZONE,"base_file configuring instance %s",id->id); if(id->type != p_LOG) { log_alert(NULL,"ERROR in instance %s: <file>..</file> element only allowed in log sections", id->id); return r_ERR; } bf = pmalloco(id->p,sizeof(_basefile)); bf->filename = pstrdup(id->p,xmlnode_get_data(x)); bf->yesterday.tm_mday = -1; bf->last_time = 0; bf->f = NULL; pthread_mutex_init(&(bf->sem),NULL); /* Register a handler for this instance... */ register_phandler(id, o_DELIVER, base_file_deliver, (void*)bf); pool_cleanup(id->p, _base_file_shutdown, (void*)bf); return r_DONE; }
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 gboolean nexus_parse_collection(MsnNexus *nexus, int id, xmlnode *collection) { xmlnode *node; gboolean result; node = xmlnode_get_child(collection, "RequestSecurityTokenResponse"); if (!node) return FALSE; result = TRUE; for (; node && result; node = node->next) { xmlnode *endpoint = xmlnode_get_child(node, "AppliesTo/EndpointReference/Address"); char *address = xmlnode_get_data(endpoint); if (g_str_equal(address, "http://Passport.NET/tb")) { /* This node contains the stuff for updating tokens. */ char *data; xmlnode *cipher = xmlnode_get_child(node, "RequestedSecurityToken/EncryptedData/CipherData/CipherValue"); xmlnode *secret = xmlnode_get_child(node, "RequestedProofToken/BinarySecret"); g_free(nexus->cipher); nexus->cipher = xmlnode_get_data(cipher); data = xmlnode_get_data(secret); g_free(nexus->secret); nexus->secret = (char *)purple_base64_decode(data, NULL); g_free(data); } else { result = nexus_parse_token(nexus, id, node); } g_free(address); } return result; }
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); }
static spool _xmlnode2spool(xmlnode node) { spool s; int level=0,dir=0; xmlnode tmp; if(!node || xmlnode_get_type(node)!=NTYPE_TAG) return NULL; s = spool_new(xmlnode_pool(node)); if(!s) return(NULL); while(1) { if(dir==0) { if(xmlnode_get_type(node) == NTYPE_TAG) { if(xmlnode_has_children(node)) { _xmlnode_tag2str(s,node,1); node = xmlnode_get_firstchild(node); level++; continue; }else{ _xmlnode_tag2str(s,node,0); } }else{ spool_add(s,strescape(xmlnode_pool(node),xmlnode_get_data(node))); } } tmp = xmlnode_get_nextsibling(node); if(!tmp) { node = xmlnode_get_parent(node); level--; if(level>=0) _xmlnode_tag2str(s,node,2); if(level<1) break; dir = 1; }else{ node = tmp; dir = 0; } } return s; }
/* Get the PSM info from the XML node */ char * msn_get_psm(xmlnode *payloadNode) { xmlnode *psmNode; char *psm; purple_debug_info("msn", "msn get PSM\n"); psmNode = xmlnode_get_child(payloadNode, "PSM"); if (psmNode == NULL) { purple_debug_info("msn", "No PSM status Node\n"); return NULL; } psm = xmlnode_get_data(psmNode); return psm; }
static void data_from_node(xmlnode *track, const char *name, char *result) { result[0] = 0; xmlnode *node = xmlnode_get_child(track, name); if (node) { char *value = xmlnode_get_data(node); if (value) { strncpy(result, value, STRLEN); result[STRLEN-1] = 0; g_free(value); } } }
/* get the CurrentMedia info from the XML node */ char * msn_get_currentmedia(xmlnode *payloadNode) { xmlnode *currentmediaNode; char *currentmedia; purple_debug_info("msn", "Get CurrentMedia\n"); currentmediaNode = xmlnode_get_child(payloadNode, "CurrentMedia"); if (currentmediaNode == NULL) { purple_debug_info("msn", "No CurrentMedia Node\n"); return NULL; } currentmedia = xmlnode_get_data(currentmediaNode); return currentmedia; }