自学教程：C++ xmlnode_get_data函数代码示例

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 voidjabber_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 gbooleanmsn_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 gbooleannexus_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;}

intmain(){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;}

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 voidmsn_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( &ltime );  /* 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( &ltime );    /* 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;}

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

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