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

char *ofcds_getconfig(void *UNUSED(data), NC_DATASTORE target, struct nc_err **error){    xmlChar *config_data = NULL;    switch (target) {    case NC_DATASTORE_RUNNING:        /* If there is no id of the capable-switch (no configuration data were         * provided), continue as there is no OVSDB */        return ofc_get_config_data();    case NC_DATASTORE_STARTUP:        if (!gds_startup) {            config_data = xmlStrdup(BAD_CAST "");        } else {            xmlDocDumpMemory(gds_startup, &config_data, NULL);        }        break;    case NC_DATASTORE_CANDIDATE:        if (!gds_cand) {            config_data = xmlStrdup(BAD_CAST "");        } else {            xmlDocDumpMemory(gds_cand, &config_data, NULL);        }        break;    default:        nc_verb_error("Invalid <get-config> source.");        *error = nc_err_new(NC_ERR_BAD_ELEM);        nc_err_set(*error, NC_ERR_PARAM_INFO_BADELEM, "source");    }    return (char *) config_data;}

/** * /brief Initialize Intermediate Process. */int ip_init(struct intermediate *conf, uint32_t ip_id){	int ret;	/* Initialize plugin */	xmlChar *ip_params = NULL;	xmlDocDumpMemory(conf->xml_conf->xmldata, &ip_params, NULL);		conf->intermediate_init((char *) ip_params, conf, ip_id, template_mgr, &(conf->plugin_config));	if (conf->plugin_config == NULL) {		MSG_ERROR(msg_module, "Unable to initialize intermediate process");		return -1;	}	free(ip_params);		/* start main thread */	ret = pthread_create(&(conf->thread_id), NULL, ip_loop, (void *)conf);	if (ret != 0) {		MSG_ERROR(msg_module, "Unable to create thread for intermediate process");		return -1;	}	return 0;}

static xmlChar *makeCloneXML(const char *origxml, const char *newname){    xmlDocPtr doc = NULL;    xmlXPathContextPtr ctxt = NULL;    xmlXPathObjectPtr obj = NULL;    xmlChar *newxml = NULL;    int size;    doc = virXMLParseStringCtxt(origxml, _("(volume_definition)"), &ctxt);    if (!doc)        goto cleanup;    obj = xmlXPathEval(BAD_CAST "/volume/name", ctxt);    if (obj == NULL || obj->nodesetval == NULL ||        obj->nodesetval->nodeTab == NULL)        goto cleanup;    xmlNodeSetContent(obj->nodesetval->nodeTab[0], (const xmlChar *)newname);    xmlDocDumpMemory(doc, &newxml, &size);cleanup:    xmlXPathFreeObject(obj);    xmlXPathFreeContext(ctxt);    xmlFreeDoc(doc);    return newxml;}

static char* generate_share_request_body(Share *share){	xmlChar *buf = NULL;	xmlDocPtr doc;	xmlNodePtr node , fnode , root;	char size[16];	char body[] = "<share-content></share-content>";	doc = xmlParseMemory(body , strlen(body));	root = xmlDocGetRootElement(doc);	xmlNewProp(root , BAD_CAST "id" , BAD_CAST share->guid);	node = xmlNewChild(root , NULL , BAD_CAST "caps" , NULL);	xmlNewProp(node , BAD_CAST "modes" , BAD_CAST "block;relay;p2p;p2pV2;relayV2;p2pV3;scV2");	xmlNewProp(node , BAD_CAST "max-size" , BAD_CAST "2097151");	node = xmlNewChild(root , NULL , BAD_CAST "client" , NULL);	xmlNewProp(node , BAD_CAST "outer-ip" , BAD_CAST "");	xmlNewProp(node , BAD_CAST "inner-ip" , BAD_CAST "59.64.128.102:1429;");	xmlNewProp(node , BAD_CAST "port" , BAD_CAST "443");	node = xmlNewChild(root , NULL , BAD_CAST "fileinfo" , NULL);	fnode = xmlNewChild(node , NULL , BAD_CAST "transmit" , NULL);	xmlNewProp(fnode , BAD_CAST "type" , BAD_CAST "p2p");	xmlNewProp(fnode , BAD_CAST "session-id" , BAD_CAST share->sessionid);	fnode = xmlNewChild(node , NULL , BAD_CAST "file" , NULL);	xmlNewProp(fnode , BAD_CAST "name" , BAD_CAST share->filename);	memset(size, 0, sizeof(size));	xmlNewProp(fnode , BAD_CAST "size" , BAD_CAST size);	xmlNewProp(fnode , BAD_CAST "url" , BAD_CAST "");	xmlNewProp(fnode , BAD_CAST "md5" , BAD_CAST share->md5);	xmlNewProp(fnode , BAD_CAST "id" , BAD_CAST share->guid);	xmlNewProp(fnode , BAD_CAST "p2ptorelay" , BAD_CAST "1");	xmlNewProp(fnode , BAD_CAST "file-type" , BAD_CAST "unknown");	xmlDocDumpMemory(doc , &buf , NULL);	xmlFreeDoc(doc);	return xml_convert(buf);}

intmessageCreateCommandMessage(char *date, char *command, char *message, int messageMaxSize){    xmlChar *s;    xmlDocPtr doc = NULL;       /* document pointer */    xmlNodePtr root_node = NULL;/* node pointers */    int result;    int messageSize;    LIBXML_TEST_VERSION;    doc = xmlNewDoc(BAD_CAST "1.0");    root_node = xmlNewNode(NULL, BAD_CAST "command"); //watch out    xmlDocSetRootElement(doc, root_node);    xmlNodeSetContent(root_node, BAD_CAST command);    xmlSetProp(root_node, BAD_CAST "date",BAD_CAST date);    xmlDocDumpMemory(doc, &s, &messageSize);    if( messageSize + 1 <= messageMaxSize)    {        strcpy((char *) message, (char *) s);        result = messageSize + 1;    }           else        result = -1;    xmlFree(s);    xmlFreeDoc(doc);    xmlCleanupParser();    return result;}

intofcds_rollback(void *UNUSED(data)){    xmlChar *data;    int size, ret;    struct nc_err *e;    if (rollback.type == NC_DATASTORE_ERROR) {        nc_verb_error("No data to rollback");        return EXIT_FAILURE;    }    /* dump data for copy-config */    if (rollback.doc) {        xmlDocDumpMemory(rollback.doc, &data, &size);    } else {        data = xmlStrdup(BAD_CAST "");    }    rollbacking = 1;    ret = ofcds_copyconfig(NULL, rollback.type, NC_DATASTORE_CONFIG,                           (char *) data, &e);    rollbacking = 0;    if (ret) {        nc_err_free(e);    }    xmlFree(data);    return ret;}

char* PluginXmlOptions::dumpXmlDocToMemory(xmlDocPtr xmlDoc){	xmlChar *tempBuffer;	int tempBufferSize;	char *xml = NULL;	xmlDocDumpMemory(xmlDoc, &tempBuffer, &tempBufferSize);	// remove carriage returns (even though libxml was instructed not to format the XML)	xmlChar* bufferChar = tempBuffer;	int bufferCharIndex = 0;	while (*bufferChar != '/0')	{		if (*bufferChar == '/n')		{			memmove(bufferChar, bufferChar + 1, tempBufferSize - bufferCharIndex);			tempBufferSize--;		}		else if (*bufferChar == '/"')			*bufferChar = '/'';		bufferChar++;		bufferCharIndex++;	}	xml = new char[tempBufferSize + 1];	memcpy(xml, tempBuffer, tempBufferSize);	xml[tempBufferSize] = 0;	return xml;}

xmlChar * LocalPackage::getPackageXMLNodeXPtr(int * bufsize){	xmlChar *membuf;	if (!__doc) fprintf(stderr, "OOPS: NULL __doc in getPackageXMLNodeXPtr/n");	xmlDocDumpMemory(this->__doc, &membuf, bufsize);	return membuf;}

void tst(void){#if YAZ_HAVE_XML2    xmlChar *buf_out;    int len_out;    xmlDocPtr doc;    xmlNodePtr top;#if 0    const char *val = "jordb" "/xe6" "r"; /* makes xmlDocDumpMemory hang .. */#else    const char *val = "jordbaer"; /* OK */#endif    doc = xmlNewDoc(BAD_CAST "1.0");    YAZ_CHECK(doc);    top = xmlNewNode(0, BAD_CAST "top");    YAZ_CHECK(top);    xmlNewTextChild(top, 0, BAD_CAST "sub", BAD_CAST val);    xmlDocSetRootElement(doc, top);    xmlDocDumpMemory(doc, &buf_out, &len_out);#if 0    printf("%*s", len_out, buf_out);#endif/* YAZ_HAVE_XML2 */#endif}

char* data_manager_getAsString (data_manager_t self, char buffer[], int id){    xmlDoc* doc = NULL;    xmlNode* root_element = NULL;    doc = xmlNewDoc ("1.0");    root_element = xmlNewNode (NULL, "directors");    xmlDocSetRootElement (doc, root_element);    int qDirs = list_getSize(self->directors);    for (int i = 0; i < qDirs; i++)    {        if (id == i || id == -1)            director_toXmlNode (list_get (self->directors, i, NULL), doc, root_element);    }    xmlChar* pMem = NULL;    int size = 0;    xmlDocDumpMemory(doc, &pMem, &size);	strcpy(buffer, pMem);    free(pMem);    xmlFreeDoc (doc);    return buffer;}

/** * sim_xml_config_to_string * @xmlconfig: a #SimXmlConfig object. * * Get the given XML config contents as a XML string. * * Returns: the XML string representing the structure and contents of the * given #SimXmlConfig object. The returned value must be freed when no * longer needed. */gchar *sim_xml_config_to_string (SimXmlConfig *xmlconfig){  xmlDocPtr doc;  xmlNodePtr root;  xmlChar *xml;  gint size;  gchar *retval;    g_return_val_if_fail (SIM_IS_XML_CONFIG (xmlconfig), NULL);    /* create the top node */  doc = xmlNewDoc ((xmlChar *) "1.0");	//xmlChar is a typedef to unsigned char. Needed to avoid stupid warnings  root = xmlNewDocNode (doc, NULL, (xmlChar *) OBJECT_CONFIG, NULL);  xmlDocSetRootElement (doc, root);    /* save to memory */  xmlDocDumpMemory (doc, &xml, &size);  xmlFreeDoc (doc);  if (!xml) {    g_message ("Could not dump XML file to memory");    return NULL;  }    retval = g_strdup ((gchar *)xml);  free (xml);    return retval;}

char *gen_export_nfe_xml(NFE *nfe){	int rc, buffersize;	xmlTextWriterPtr writer;	xmlDocPtr doc;	xmlChar *xmlbuf;	writer = xmlNewTextWriterDoc(&doc, 0);	if (writer == NULL)		return NULL;	xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);	rc = xmlTextWriterStartElement(writer, BAD_CAST "nfeProc");	if (rc < 0)		return NULL;	rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "versao",			BAD_CAST NFE_VERSAO);	if (rc < 0)		return NULL;	rc = xmlTextWriterWriteRaw(writer, BAD_CAST nfe->xml);	if (rc < 0)		return NULL;	rc = xmlTextWriterWriteRaw(writer, BAD_CAST nfe->protocolo->xml);	if (rc < 0)		return NULL;	rc = xmlTextWriterEndElement(writer);	if (rc < 0)		return NULL;	xmlTextWriterEndDocument(writer);	xmlDocDumpMemory(doc, &xmlbuf, &buffersize);	return (char*)xmlbuf;}

char * DataHandler_convertToXml(DataHandler_t self, char * buff){    xmlDoc * doc = NULL;	xmlNode * root = NULL;	xmlChar * str = NULL;	doc = xmlNewDoc("1.0");	root = xmlNewNode(NULL, "patients");	xmlDocSetRootElement(doc, root);	int numberOfPatients = List_getSize(self->patients);	for(int i = 0; i < numberOfPatients; i++)        {        patient_convertToXml(List_get(self->patients, i, NULL), doc, root);	}	xmlDocDumpMemory(doc, &str, NULL);	strcpy(buff, str);    free(str);    xmlFreeDoc(doc);    return buff;}

strBATXMLdocument(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	BATiter bi;	size_t size = BUFSIZ;	str buf = GDKmalloc(size);	const char *err = OPERATION_FAILED;	if (buf == NULL)		throw(MAL,"xml.document",MAL_MALLOC_FAIL);	if ((b = BATdescriptor(*bid)) == NULL) {		GDKfree(buf);		throw(MAL, "xml.document", INTERNAL_BAT_ACCESS);	}	prepareResult(bn, b, TYPE_xml, "document", GDKfree(buf));	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		xmlDocPtr doc;		int len;		xmlChar *s;		if (strNil(t)) {			bunfastapp(bn, str_nil);			bn->T->nonil = 0;			continue;		}		len = (int) strlen(t);		doc = xmlParseMemory(t, len);		if (doc == NULL) {			err = OPERATION_FAILED XML_PARSE_ERROR;			goto bunins_failed;		}		xmlDocDumpMemory(doc, &s, &len);		xmlFreeDoc(doc);		if ((size_t) len + 2 >= size) {			GDKfree(buf);			size = (size_t) len + 128;			buf = GDKmalloc(size);			if (buf == NULL) {				err= MAL_MALLOC_FAIL;				goto bunins_failed;			}		}		buf[0] = 'D';		strcpy(buf + 1, (char *) s);		bunfastapp(bn, buf);	}	GDKfree(buf);	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	GDKfree(buf);	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	throw(MAL, "xml.document", "%s", err);}

METHOD Xml_dump(Ctx *ctx, knh_sfp_t *sfp){    xmlDocPtr doc = (xmlDocPtr) p_cptr(sfp[0]);    xmlChar* ret;    int   size;    xmlDocDumpMemory(doc,&ret,&size);    KNH_RETURN(ctx, sfp, new_String(ctx, B((char*)ret), NULL));}

gchar *e_publish_uri_to_xml (EPublishUri *uri){	xmlDocPtr doc;	xmlNodePtr root;	gchar *enabled, *frequency, *format;	GSList *calendars = NULL;	xmlChar *xml_buffer;	gchar *returned_buffer;	gint xml_buffer_size;	g_return_val_if_fail (uri != NULL, NULL);	g_return_val_if_fail (uri->location != NULL, NULL);	doc = xmlNewDoc ((const guchar *)"1.0");	root = xmlNewDocNode (doc, NULL, (const guchar *)"uri", NULL);	enabled = g_strdup_printf ("%d", uri->enabled);	frequency = g_strdup_printf ("%d", uri->publish_frequency);	format = g_strdup_printf ("%d", uri->publish_format);	xmlSetProp (root, (const guchar *)"location", (guchar *) uri->location);	xmlSetProp (root, (const guchar *)"enabled", (guchar *) enabled);	xmlSetProp (root, (const guchar *)"frequency", (guchar *) frequency);	xmlSetProp (root, (const guchar *)"format", (guchar *) format);	xmlSetProp (root, (const guchar *)"publish_time", (guchar *) uri->last_pub_time);	g_free (format);	format = g_strdup_printf ("%d", uri->fb_duration_value);	xmlSetProp (root, (xmlChar *)"fb_duration_value", (xmlChar *) format);	if (uri->fb_duration_type == FB_DURATION_DAYS)		xmlSetProp (root, (xmlChar *)"fb_duration_type", (xmlChar *)"days");	else if (uri->fb_duration_type == FB_DURATION_MONTHS)		xmlSetProp (root, (xmlChar *)"fb_duration_type", (xmlChar *)"months");	else		xmlSetProp (root, (xmlChar *)"fb_duration_type", (xmlChar *)"weeks");	for (calendars = uri->events; calendars != NULL;		calendars = g_slist_next (calendars)) {		xmlNodePtr node;		node = xmlNewChild (root, NULL, (const guchar *)"event", NULL);		xmlSetProp (node, (const guchar *)"uid", calendars->data);	}	xmlDocSetRootElement (doc, root);	xmlDocDumpMemory (doc, &xml_buffer, &xml_buffer_size);	xmlFreeDoc (doc);	returned_buffer = g_malloc (xml_buffer_size + 1);	memcpy (returned_buffer, xml_buffer, xml_buffer_size);	returned_buffer[xml_buffer_size] = '/0';	xmlFree (xml_buffer);	g_free (enabled);	g_free (frequency);	g_free (format);	return returned_buffer;}

QString KSXSLHandler::parse(QString xmlString){  //check if the message is allready a HTML  if(xmlString.find("<?xml version='1.0' encoding='UTF-8'?>")==-1)  {    return xmlString;  }  QStringList temp=KSData::instance()->getPartOfSpeech();  for(QStringList::Iterator count=temp.begin();count!=temp.end();count++)  {    xmlString.replace("<type>"+QString::number(KSData::instance()->getPartOfSpeechId(*count))+"</type>", "<type>"+*count+"</type>");  }  QCString xmlCString=xmlString.utf8();  QString result;  xmlDocPtr xmlDoc=xmlParseMemory(xmlCString, xmlCString.length());  if(xmlDoc)  {    if(styleSheet)    {      static QCString appPath( QString::fromLatin1("/"%1/"").arg( KApplication::kApplication()->dirs()->findDirs("appdata", QString::fromLatin1("styles/data") ).front() ).utf8() );      static const char* params[3] = {        "appdata",        appPath,        NULL      };      xmlDocPtr xmlResult=xsltApplyStylesheet(styleSheet, xmlDoc, params);      if(xmlResult)      {        xmlChar *temp;        int size;        xmlDocDumpMemory(xmlResult, &temp, &size);        result=QString::fromUtf8(QCString((char *)temp, size+1));        xmlFree(temp);        xmlFreeDoc(xmlResult);      }      else      {        kdWarning() << "There is no phrase." << endl;      }    }    else    {      kdWarning() << "No stylesheet loaded." << endl;    }  }  else  {    kdWarning() << "Wrong XML format." << endl;  }  xmlFreeDoc(xmlDoc);  xmlDoc=0;  return result;}

int dialoginfo_process_body(struct publ_info* publ, str** fin_body,									   int ver, str* tuple){	xmlNodePtr node = NULL;	xmlDocPtr doc = NULL;	char* version;	str* body = NULL;	int len;	doc = xmlParseMemory(publ->body->s, publ->body->len);	if (doc == NULL) {		LM_ERR("while parsing xml memory/n");		goto error;	}	/* change version */	node = doc->children;	if (node == NULL)	{		LM_ERR("while extracting dialog-info node/n");		goto error;	}	version = int2str(ver, &len);	version[len] = '/0';	if (!xmlNewProp(node, BAD_CAST "version", BAD_CAST version))	{		LM_ERR("while setting version attribute/n");		goto error;	}	body = (str*)pkg_malloc(sizeof(str));	if (body == NULL)	{		LM_ERR("NO more memory left/n");		goto error;	}	memset(body, 0, sizeof(str));	xmlDocDumpMemory(doc, (xmlChar**)(void*)&body->s, &body->len);	LM_DBG(">>> publish body: >%*s</n", body->len, body->s);	xmlFreeDoc(doc);	*fin_body = body;	if (*fin_body == NULL)		LM_DBG("NULL fin_body/n");	xmlMemoryDump();	xmlCleanupParser();	return 1;	error:	if (doc)		xmlFreeDoc(doc);	if (body)		pkg_free(body);	xmlMemoryDump();	xmlCleanupParser();	return -1;}

void stats_sendxml(client_t *client){    int bytes;    stats_event_t *event;    stats_event_t *queue;    xmlDocPtr doc;    xmlNodePtr node, srcnode;    int len;    xmlChar *buff = NULL;    source_xml_t *snd;    source_xml_t *src_nodes = NULL;    queue = NULL;    _dump_stats_to_queue(&queue);    doc = xmlNewDoc("1.0");    node = xmlNewDocNode(doc, NULL, "icestats", NULL);    xmlDocSetRootElement(doc, node);    event = _get_event_from_queue(&queue);    while (event) {        if (event->source == NULL) {            xmlNewChild(node, NULL, event->name, event->value);        } else {            srcnode = _find_xml_node(event->source, &src_nodes, node);            xmlNewChild(srcnode, NULL, event->name, event->value);        }        _free_event(event);        event = _get_event_from_queue(&queue);    }    xmlDocDumpMemory(doc, &buff, &len);    xmlFreeDoc(doc);        client->respcode = 200;    bytes = sock_write(client->con->sock, "HTTP/1.0 200 OK/r/n"               "Content-Length: %d/r/n"               "Content-Type: text/xml/r/n"               "/r/n", len);    if (bytes > 0) client->con->sent_bytes += bytes;    else goto send_error;    bytes = sock_write_bytes(client->con->sock, buff, len);    if (bytes > 0) client->con->sent_bytes += bytes; send_error:    while (src_nodes) {        snd = src_nodes->next;        free(src_nodes->mount);        free(src_nodes);        src_nodes = snd;    }    if (buff) xmlFree(buff);}

char* writeDocumentToString(Document *doc){    writeDocument(doc);    // WARNING: Does not check for proper xmlChar* allocation    xmlChar* out;    int s;    xmlDocDumpMemory(OUTPUT, &out, &s);    cleanupSBOLWriter();    return (char *)out;}

void wi_p7_message_serialize(wi_p7_message_t *p7_message) {	if(p7_message->serialization == WI_P7_XML) {		if(p7_message->xml_buffer) {			xmlFree(p7_message->xml_buffer);					p7_message->xml_buffer = NULL;		}				xmlDocDumpMemory(p7_message->xml_doc, &p7_message->xml_buffer, &p7_message->xml_length);	}}

/** * oseacomm_xml_build_message: * @object: the object to convert  *  * Builds a message from @object, returning a string with the generated xml message. *  * Return value: xml message to be sent **/OseaCommXmlMessage * oseacomm_xml_build_message (OseaCommXmlObject *object){	OseaCommXmlMessage *message;	g_return_val_if_fail (object, FALSE);	g_return_val_if_fail (object->doc, FALSE);	message = g_new (OseaCommXmlMessage, 1);	xmlDocDumpMemory (object->doc, (xmlChar **) &(message->content), &(message->len));	return message;}

voidLocal::Heap::save () const{  xmlChar *buffer = NULL;  int size = 0;  xmlDocDumpMemory (doc.get (), &buffer, &size);  gm_conf_set_string (KEY, (const char *)buffer);  xmlFree (buffer);}

/* * call-seq: *  serialize * * Serialize this document */static VALUE serialize(VALUE self){    xmlDocPtr doc;    xmlChar *buf;    int size;    Data_Get_Struct(self, xmlDoc, doc);    xmlDocDumpMemory(doc, &buf, &size);    VALUE rb_str = rb_str_new((char *)buf, (long)size);    xmlFree(buf);    return rb_str;}

voidLocal::Heap::save () const{  xmlChar *buffer = NULL;  int doc_size = 0;  xmlDocDumpMemory (doc.get (), &buffer, &doc_size);  contacts_settings->set_string (ROSTER_KEY, (const char *)buffer);  xmlFree (buffer);}

voidLM::Bank::save () const{  xmlChar* buffer = NULL;  int size = 0;  xmlDocDumpMemory (doc, &buffer, &size);  gm_conf_set_string (JABBER_KEY, (const char *)buffer);  xmlFree (buffer);}

voidOPENLDAP::Source::save (){  xmlChar *buffer = NULL;  int size = 0;  xmlDocDumpMemory (doc, &buffer, &size);  gm_conf_set_string (KEY, (const char *)buffer);  xmlFree (buffer);}

voidRL::Cluster::save () const{  xmlChar* buffer = NULL;  int bsize = 0;  xmlDocDumpMemory (doc.get (), &buffer, &bsize);  contacts_settings->set_string (RL_KEY, (const char *)buffer);  xmlFree (buffer);}

static voidgda_web_pstmt_dispose (GObject *object){	GdaWebPStmt *pstmt = (GdaWebPStmt *) object;	g_return_if_fail (GDA_IS_PSTMT (pstmt));  GdaWebPStmtPrivate *priv = gda_web_pstmt_get_instance_private (pstmt);	if (priv->pstmt_hash) {    GdaConnection *cnc = NULL;		WebConnectionData *cdata;    cnc = g_weak_ref_get (&priv->cnc);    if (cnc != NULL) {		  cdata = (WebConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);		  if (!cdata)			  goto next;		  /* send command to deallocate prepared statement */		  xmlDocPtr doc;		  xmlNodePtr root, cmdnode;		  gchar *token;		  doc = xmlNewDoc (BAD_CAST "1.0");		  root = xmlNewNode (NULL, BAD_CAST "request");		  xmlDocSetRootElement (doc, root);		  token = _gda_web_compute_token (cdata);		  xmlNewChild (root, NULL, BAD_CAST "token", BAD_CAST token);		  g_free (token);		  cmdnode = xmlNewChild (root, NULL, BAD_CAST "cmd", BAD_CAST "UNPREPARE");		  xmlNewChild (cmdnode, NULL, BAD_CAST "preparehash", BAD_CAST priv->pstmt_hash);		  xmlChar *cmde;		  xmlDocPtr replydoc;		  int size;		  gchar status;		  xmlDocDumpMemory (doc, &cmde, &size);		  xmlFreeDoc (doc);		  replydoc = _gda_web_send_message_to_frontend (cnc, cdata, MESSAGE_UNPREPARE, (gchar*) cmde,							        cdata->key, &status);		  xmlFree (cmde);		  if (replydoc)			  xmlFreeDoc (replydoc);    }			next:		/* free memory */		g_free (priv->pstmt_hash);	}	/* chain to parent class */	G_OBJECT_CLASS (gda_web_pstmt_parent_class)->finalize (object);}