/* wrapper for stats_event, this takes a charset to convert from */
void stats_event_conv(const char *mount, const char *name, const char *value, const char *charset)
{
const char *metadata = value;
xmlBufferPtr conv = xmlBufferCreate ();
if (charset && value)
{
xmlCharEncodingHandlerPtr handle = xmlFindCharEncodingHandler (charset);
if (handle)
{
xmlBufferPtr raw = xmlBufferCreate ();
xmlBufferAdd (raw, (const xmlChar *)value, strlen (value));
if (xmlCharEncInFunc (handle, conv, raw) > 0)
metadata = (char *)xmlBufferContent (conv);
xmlBufferFree (raw);
xmlCharEncCloseFunc (handle);
}
else
WARN1 ("No charset found for \"%s\"", charset);
}
stats_event (mount, name, metadata);
xmlBufferFree (conv);
}
int
srd_printElementSet (xmlDocPtr doc, xmlNodeSet *nodeSet, char **printBuffPtr, int printBuffSize)
{
xmlNode *cur_node = NULL;
int n, i;
xmlChar *value;
int offset = 0;
xmlBuffer *buff;
int size = printBuffSize;
char *newSpace;
for (i=0; i < nodeSet->nodeNr; i++) {
cur_node = nodeSet->nodeTab[i];
if (cur_node->type == XML_ELEMENT_NODE) {
buff = xmlBufferCreate ();
xmlNodeDump (buff, doc,cur_node, 0, 1 );
if (size < (offset + strlen((char *)buff->content) + 1)){
size = offset + strlen((char *)buff->content) + 1;
newSpace = (char *)realloc (*printBuffPtr, size);
if (newSpace){
*printBuffPtr = newSpace;
} else {
// unable to allocate space
xmlBufferFree (buff);
return -1;
}
}
n = sprintf (*printBuffPtr+offset, "%s", buff->content);
offset = offset + n;
xmlBufferFree (buff);
}
}
return (offset);
}
char *
epp_getSubtree(void *pool,
epp_command_data *cdata,
const char *xpath_expr,
int position)
{
char *subtree;
xmlBufferPtr buf;
xmlDocPtr doc;
xmlNodePtr node;
xmlXPathObjectPtr xpath_obj;
xmlXPathContextPtr xpath_ctx;
doc = (xmlDocPtr) cdata->parsed_doc;
xpath_ctx = (xmlXPathContextPtr) cdata->xpath_ctx;
xpath_obj = xmlXPathEvalExpression(BAD_CAST xpath_expr, xpath_ctx);
if (xpath_obj == NULL)
return NULL;
/* correct position for non-list elements */
if (position == 0) position++;
if (xmlXPathNodeSetGetLength(xpath_obj->nodesetval) < position) {
xmlXPathFreeObject(xpath_obj);
/* return empty string if the node is not there */
return epp_strdup(pool, "");
}
/*
* Get content of problematic tag. It's not so easy task. We have
* to declare namespaces defined higher in the tree which are relevant
* to the part of document being dumped. Fortunatelly there is a
* function from libxml library doing exactly that (xmlreconsiliatens).
*/
buf = xmlBufferCreate();
if (buf == NULL)
return NULL;
node = xmlXPathNodeSetItem(xpath_obj->nodesetval, position - 1);
if (node->ns != NULL) {
xmlNsPtr nsdef;
nsdef = xmlSearchNs(doc, node, node->ns->prefix);
if (nsdef != NULL)
xmlNewNs(node, nsdef->href, nsdef->prefix);
}
if (xmlNodeDump(buf, doc, node, 0, 0) < 0)
{
xmlXPathFreeObject(xpath_obj);
xmlBufferFree(buf);
return NULL;
}
subtree = epp_strdup(pool, (char *) buf->content);
xmlXPathFreeObject(xpath_obj);
xmlBufferFree(buf);
return subtree;
}
static int
xsltNumberFormatGetValue(xmlXPathContextPtr context,
xmlNodePtr node,
xmlChar *value,
double *number)
{
int amount = 0;
xmlBufferPtr pattern;
xmlXPathObjectPtr obj;
pattern = xmlBufferCreate();
if (pattern != NULL) {
xmlBufferCCat(pattern, "number(");
xmlBufferCat(pattern, value);
xmlBufferCCat(pattern, ")");
context->node = node;
obj = xmlXPathEvalExpression(xmlBufferContent(pattern),
context);
if (obj != NULL) {
*number = obj->floatval;
amount++;
xmlXPathFreeObject(obj);
}
xmlBufferFree(pattern);
}
return amount;
}
bool
Xml::saveToBuffer(XmlNode *curNode, std::string *buf) const
{
if (NULL == curNode) {
fprintf(stderr, "[ERROR] In Xml::saveToBuffer, curNode == NULL\n");
return false;
}
if (NULL == buf) {
fprintf(stderr, "[ERROR] In Xml::saveToBuffer, buf == NULL\n");
return false;
}
xmlBuffer *xmlBuf = xmlBufferCreate();
if (NULL == xmlBuf) {
fprintf(stderr, "[ERROR] In Xml::saveToBuffer, "
"xmlBufferCreate() error\n");
return false;
}
int bytes = xmlNodeDump(xmlBuf, _doc, curNode,
XML_INDENT_LEVEL, XML_FORMAT_ALLOWED);
if (bytes < 0) {
fprintf(stderr, "[ERROR] In Xml::saveToBuffer, xmlNodeDump() error\n");
return false;
}
*buf = (const char *)(xmlBuf->content);
xmlBufferFree(xmlBuf);
xmlBuf = NULL;
return true;
}
/***********************************************
* 生成XML的字符串 *
* 成功返回XML的字符串 *
* 失败则返回NULL *
* doc用完已自动清空 *
***********************************************/
byte * generateXmlBuffer(xmlDocPtr doc)
{
static byte szBuf[2048];
byte * buffer;
xmlBufferPtr buf = NULL;
xmlSaveCtxtPtr ctxt = NULL;
LIBXML_TEST_VERSION;
if(doc == NULL) {
ErrorLog(ERROR, "doc is null");
printf("doc is null");
return NULL;
}
buf = xmlBufferCreate();
ctxt = xmlSaveToBuffer(buf, "UTF-8", 1);
xmlSaveDoc(ctxt, doc);
xmlSaveClose(ctxt);
memset(szBuf, 0x00, sizeof(szBuf));
buffer = u2g(buf->content);
sprintf(szBuf, "%s",buffer );
buf->content = NULL;
xmlBufferFree(buf);
xmlFreeDoc(doc);
xmlCleanupParser();
free(buffer);
return szBuf;
}
string as_string(xmlNodePtr node) {
xmlBufferPtr buf = xmlBufferCreate();
xmlNodeDump(buf,node->doc,node,0,1);
string result((char*)buf->content);
xmlBufferFree(buf);
return result;
}
bool XMLWrapper::nodeDump(xmlNodePtr node, std::string &content, bool trim)
{
content.clear();
if (!mDocument) {
return false;
}
if (!node) {
return false;
}
bool result = false;
xmlBufferPtr buffer = xmlBufferCreate();
if (buffer) {
xmlOutputBufferPtr outputBuffer = xmlOutputBufferCreateBuffer(buffer, NULL);
if (outputBuffer) {
xmlNodeDumpOutput(outputBuffer, mDocument, node, 0, 0, "UTF8");
xmlOutputBufferClose(outputBuffer);
outputBuffer = NULL;
result = convertToString(buffer->content, content);
if (result && trim) {
trimString(content);
}
}
xmlBufferFree(buffer);
buffer = NULL;
}
return result;
}
char* fileinfo_get(char* path) {
FILE* file;
xmlBufferPtr buf;
xmlTextWriterPtr writer;
char* ret;
int wordCount;
file = fopen(path, "r");
wordCount = countWords(file);
fclose(file);
buf = xmlBufferCreate();
writer = xmlNewTextWriterMemory(buf, 0);
xmlTextWriterStartDocument(writer, NULL, XML_E, NULL);
xmlTextWriterStartElement(writer, BAD_CAST "fileInfo");
xmlTextWriterWriteFormatElement(writer, BAD_CAST "wordCount", "%d", wordCount);
xmlTextWriterEndElement(writer);
xmlTextWriterEndDocument(writer);
ret = malloc(buf->size);
strcpy(ret,(char*)buf->content);
xmlBufferFree(buf);
return ret;
}
char * list_to_xml1(list_t list) {
xmlDoc * doc = NULL;
xmlNode * rootNode = NULL;
xmlNode * studentNode = NULL;
xmlNode * groupNode = NULL;
char strBuf[100];
char * text = malloc(sizeof (char) * 10000);
doc = xmlNewDoc("1.0");
rootNode = xmlNewNode(NULL, "directors");
for (int i = 0;i < list_size(list); i++)
{
if (list_get(list, i) == NULL)
continue;
puts(((struct admin_s *)list_get(list, i))->name);
xmlDocSetRootElement(doc, rootNode);
studentNode = xmlNewChild(rootNode, NULL, "director", NULL);
xmlNewChild(studentNode, NULL, "name", ((struct admin_s *)list_get(list, i))->name);
xmlNewChild(studentNode, NULL, "surname", ((struct admin_s *)list_get(list, i))->surname);
sprintf(strBuf, "%i", ((struct admin_s *)list_get(list, i))->buget);
xmlNewChild(studentNode, NULL, "buget", strBuf);
sprintf(strBuf, "%llf", ((struct admin_s *)list_get(list, i))->years);
xmlNewChild(studentNode, NULL, "years", strBuf);
xmlNewChild(studentNode, NULL, "birthdate", ((struct admin_s *)list_get(list, i))->birthdate);
}
xmlBuffer * bufferPtr = xmlBufferCreate();
xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1);
printf("%s", (const char *)bufferPtr->content);
strcpy(text, (const char *)bufferPtr->content);
xmlBufferFree(bufferPtr);
xmlFreeDoc(doc);
xmlCleanupParser();
return text;
}
std::string XMLSchema::xml() const
{
xmlBuffer *b = xmlBufferCreate();
xmlTextWriterPtr w = xmlNewTextWriterMemory(b, 0);
xmlTextWriterSetIndent(w, 1);
xmlTextWriterStartDocument(w, NULL, "utf-8", NULL);
xmlTextWriterStartElementNS(w, (const xmlChar*)"pc",
(const xmlChar*)"PointCloudSchema", NULL);
xmlTextWriterWriteAttributeNS(w, (const xmlChar*) "xmlns",
(const xmlChar*)"pc", NULL,
(const xmlChar*)"http://pointcloud.org/schemas/PC/");
xmlTextWriterWriteAttributeNS(w, (const xmlChar*)"xmlns",
(const xmlChar*)"xsi", NULL,
(const xmlChar*)"http://www.w3.org/2001/XMLSchema-instance");
writeXml(w);
xmlTextWriterEndElement(w);
xmlTextWriterEndDocument(w);
std::string output((const char *)b->content, b->use);
xmlFreeTextWriter(w);
xmlBufferFree(b);
return output;
}
/**
* Serialises an xmlNode to a string
*
* @param log Log context
* @param node Input XML node to be serialised
*
* @return Returns a pointer to a new buffer containing the serialised data. This buffer must be freed
* after usage
*/
char *xmlNodeToString(LogContext *log, xmlNode *node) {
xmlBuffer *buf = NULL;
xmlSaveCtxt *serctx = NULL;
char *ret = NULL;
if( node == NULL ) {
writelog(log, LOG_ALERT, "xmlNodeToString: Input data is NULL");
return NULL;
}
buf = xmlBufferCreate();
assert( buf != NULL );
serctx = xmlSaveToBuffer(buf, "UTF-8", XML_SAVE_NO_EMPTY|XML_SAVE_NO_DECL);
assert( serctx != NULL );
if( xmlSaveTree(serctx, node) < 0 ) {
writelog(log, LOG_ALERT, "xmlNodeToString: Failed to serialise xmlNode");
return NULL;
}
xmlSaveClose(serctx);
ret = strdup_nullsafe((char *) xmlBufferContent(buf));
xmlBufferFree(buf);
return ret;
}
VALUE search(VALUE self, VALUE xpathExpr)
{
VALUE results = rb_ary_new();
xmlDocPtr doc;
xmlXPathObjectPtr xpathObj;
xmlNodeSetPtr nodes;
xmlNodePtr cur;
xmlBufferPtr nodeBuffer;
int size, i;
Data_Get_Struct(self, xmlDoc, doc);
xpathObj = eval_and_search(doc, StringValueCStr(xpathExpr));
if (xpathObj == NULL) { return Qnil; }
nodes = xpathObj->nodesetval;
size = (nodes) ? nodes->nodeNr : 0;
for (i = 0; i < size; ++i) {
nodeBuffer = xmlBufferCreate();
xmlNodeDump(nodeBuffer, doc, nodes->nodeTab[i], 0, 1);
rb_ary_push(results, rb_str_new2(nodeBuffer->content));
xmlBufferFree(nodeBuffer);
}
xmlXPathFreeObject(xpathObj);
return results;
}
void
closeFile()
{
mXPath.clear();
// This section writes to file
std::ofstream fileStream;
if(!mStream) {
fileStream.open(mXMLFilePath.c_str());
mStream = &fileStream;
}
xmlBufferPtr buffer = xmlBufferCreate();
xmlOutputBuffer * outputBuffer = xmlOutputBufferCreateBuffer(buffer,
NULL);
xmlSaveFormatFileTo(outputBuffer,
mXMLDocument,
"utf-8",
1);
*mStream << buffer->content;
xmlBufferFree(buffer);
if(fileStream.is_open()) {
fileStream.close();
mStream = NULL;
}
xmlFreeDoc(mXMLDocument);
xmlCleanupParser();
if(mHeavyDataWriter->getMode() == XdmfHeavyDataWriter::Default) {
mHeavyDataWriter->closeFile();
}
};
/**
Writes the report footer to Xml file..
Write the xml end doc info..
Release the writer pointer from the buffer.
Writes the buffer content to xml file.
Frees the xml buffer.
@internalComponent
@released
*/
void XmlWriter::EndReport(void)
{
xmlTextWriterEndElement(iXmlTextWriter);
xmlTextWriterEndElement(iXmlTextWriter);
xmlTextWriterEndDocument(iXmlTextWriter);
xmlFreeTextWriter(iXmlTextWriter);
iXmlFile.clear();
iXmlFile.write((const char *)iXmlBufPtr->content,iXmlBufPtr->use);
if(iXmlFile.fail()){
xmlBufferFree(iXmlBufPtr);
throw ExceptionReporter(NODISKSPACE, (char*)iXmlFileName.c_str());
}
xmlBufferFree(iXmlBufPtr);
}
char *teacher_to_message(teacher_t *self, int id){
if(!self)
return NULL;
char buff[MSG_LENGTH];
xmlDoc * doc = NULL;
xmlNode * rootNode = NULL;
xmlNode * teacherNode = NULL;
xmlNode * cathedraNode = NULL;
doc = xmlNewDoc("1.0");
rootNode = xmlNewNode(NULL, "teachers");
xmlDocSetRootElement(doc, rootNode);
char strBuf[100];
teacherNode = xmlNewChild(rootNode, NULL, "teacher", NULL);
sprintf(strBuf, "%i", id);
xmlNewChild(teacherNode, NULL, "id", strBuf);
xmlNewChild(teacherNode, NULL, "firstName", self->name);
xmlNewChild(teacherNode, NULL, "lastName", self->surname);
xmlNewChild(teacherNode, NULL, "pensionDate", self->date);
sprintf(strBuf, "%i", self->hours);
xmlNewChild(teacherNode, NULL, "hours", strBuf);
sprintf(strBuf, "%f", self->rating);
xmlNewChild(teacherNode, NULL, "rating", strBuf);
cathedraNode = xmlNewChild(teacherNode, NULL, "cathedra", NULL);
xmlNewProp(cathedraNode, "name", self->cathedra->name);
xmlNewChild(cathedraNode, NULL, "speciality", self->cathedra->speciality);
xmlNewChild(cathedraNode, NULL, "group", self->cathedra->groups[0]);
xmlNewChild(cathedraNode, NULL, "group", self->cathedra->groups[1]);
xmlBuffer * bufferPtr = xmlBufferCreate();
xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1);
sprintf(buff, "%s", (const char*)bufferPtr->content);
xmlFreeDoc(doc);
xmlCleanupParser();
xmlBufferFree(bufferPtr);
return buff;
}
char * info_to_xml(char * name, char * group, char * var)
{
xmlDoc * doc = NULL;
xmlNode * rootNode = NULL;
doc = xmlNewDoc("1.0");
rootNode = xmlNewNode(NULL, "persons");
//FILE * file = fopen("newBase.xml", "w");
char * text = malloc(sizeof(char) * 1000);
for (int i = 0; i < 1000; i++)
{
text[i] = '\0';
}
xmlDocSetRootElement(doc, rootNode);
xmlNewChild(rootNode, NULL, "student", name);
xmlNewChild(rootNode, NULL, "group", group);
xmlNewChild(rootNode, NULL, "variant", var);
xmlBuffer * bufferPtr = xmlBufferCreate();
xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1);
strcat(text, bufferPtr->content);
xmlBufferFree(bufferPtr);
xmlFreeDoc(doc);
xmlCleanupParser();
puts(text);
return text;
}
int lpc2xml_convert_string(lpc2xml_context* context, char **content) {
int ret = -1;
xmlBufferPtr buffer = xmlBufferCreate();
xmlSaveCtxtPtr save_ctx;
lpc2xml_context_clear_logs(context);
xmlSetGenericErrorFunc(context, lpc2xml_genericxml_error);
save_ctx = xmlSaveToBuffer(buffer, "UTF-8", XML_SAVE_FORMAT);
if(save_ctx != NULL) {
ret = internal_convert_lpc2xml(context);
if(ret == 0) {
ret = xmlSaveDoc(save_ctx, context->doc);
if(ret != 0) {
lpc2xml_log(context, LPC2XML_ERROR, "Can't save document");
lpc2xml_log(context, LPC2XML_ERROR, "%s", context->errorBuffer);
}
}
xmlSaveClose(save_ctx);
} else {
lpc2xml_log(context, LPC2XML_ERROR, "Can't initialize internal buffer");
lpc2xml_log(context, LPC2XML_ERROR, "%s", context->errorBuffer);
}
if(ret == 0) {
#if LIBXML_VERSION >= 20800
*content = (char *)xmlBufferDetach(buffer);
#else
*content = strdup((const char *)xmlBufferContent(buffer));
#endif
}
xmlBufferFree(buffer);
return ret;
}
bool XMLWrapper::convertFromString(const char *text, xmlChar *&xmlText)
{
bool result = false;
xmlBufferPtr in = xmlBufferCreateStatic((void*) text, strlen(text));
xmlBufferPtr out = xmlBufferCreate();
int ret = xmlCharEncInFunc(mCharEncodingHandler, out, in);
if (ret >= 0) {
result = true;
xmlText = xmlBufferDetach(out);
}
xmlBufferFree(in);
xmlBufferFree(out);
return result;
}
bool XMLWrapper::convertToString(const xmlChar *xmlText, std::string &text)
{
bool result = false;
xmlBufferPtr in = xmlBufferCreateStatic((void*) xmlText, xmlStrlen(xmlText));
xmlBufferPtr out = xmlBufferCreate();
int ret = xmlCharEncOutFunc(mCharEncodingHandler, out, in);
if (ret >= 0) {
result = true;
text = (char*) xmlBufferContent(out);
}
xmlBufferFree(in);
xmlBufferFree(out);
return result;
}
const std::string queryResult::to_xml()
{
xmlDocPtr doc;
xmlNodePtr root;
int rc;
std::string returnValue;
doc = xmlNewDoc(BAD_CAST "1.0");
root = xmlNewNode(NULL, BAD_CAST "result");
std::stringstream temp;
temp << size();
xmlNewProp(root, BAD_CAST "count", BAD_CAST temp.str().c_str());
if(__code != 0) {
temp.str("");
temp << __code;
xmlNewProp(root, BAD_CAST "ocicode", BAD_CAST temp.str().c_str());
}
if(__info.length()) {
xmlNewProp(root, BAD_CAST "ociinfo", BAD_CAST __info.c_str());
}
xmlDocSetRootElement(doc, root);
for(int i=0; i<size(); ++i) {
xmlNodePtr branch = xmlNewChild(root, NULL, BAD_CAST "branch", NULL);
std::multimap<std::string, std::string>::iterator it, iend = at(i).end();
for(it=at(i).begin(); it!=iend; ++it) {
xmlNodePtr child = xmlNewChild(branch, NULL, BAD_CAST it->first.c_str(), BAD_CAST it->second.c_str());
}
}
xmlNodePtr bind = xmlNewChild(root, NULL, BAD_CAST "bind", NULL);
std::map<std::string, std::pair<std::string, bool> >::iterator j, jend = __bindouts.end();
for(j = __bindouts.begin(); j != jend; ++j) {
if(j->second.second == true)
continue;
xmlNodePtr child = xmlNewChild(bind, NULL, BAD_CAST j->first.c_str(), BAD_CAST j->second.first.c_str());
}
xmlBufferPtr buf = xmlBufferCreate();
xmlSaveCtxtPtr sav = xmlSaveToBuffer(buf, "UTF-8", XML_SAVE_FORMAT | XML_SAVE_NO_EMPTY);
xmlSaveDoc(sav, doc);
xmlSaveClose(sav);
returnValue = (char*)buf->content;
xmlBufferFree(buf);
xmlFreeDoc(doc);
return returnValue;
}
bool CXmlTree::WriteXmlFileToString(cvs::string& string) const
{
xmlBufferPtr buffer = xmlBufferCreate();
if(!buffer)
return false;
xmlSaveCtxtPtr save = xmlSaveToBuffer(buffer, NULL, 0);
if(!save)
{
xmlBufferFree(buffer);
return false;
}
xmlSaveDoc(save, m_doc);
xmlSaveFlush(save);
xmlSaveClose(save);
string = (const char*)xmlBufferContent(buffer);
xmlBufferFree(buffer);
return true;
}
const std::string XMLElement::dump(bool indent) const
{
xmlBufferPtr buffer = xmlBufferCreate();
xmlNodeDump(buffer, doc.getRealDocument(), node, 0, indent ? 1 : 0);
std::string str = std::string((const char *)buffer->content);
xmlBufferFree(buffer);
return str;
}
/*}}}*/
};
static int psize = sizeof (parseable) / sizeof (parseable[0]);
tag_t *
tag_alloc (void) /*{{{*/
{
tag_t *t;
if (t = (tag_t *) malloc (sizeof (tag_t))) {
t -> name = xmlBufferCreate ();
t -> cname = NULL;
t -> hash = 0;
t -> type = NULL;
t -> topt = NULL;
t -> value = xmlBufferCreate ();
t -> parm = NULL;
t -> used = false;
t -> next = NULL;
if ((! t -> name) || (! t -> value))
t = tag_free (t);
}
return t;
}/*}}}*/
tag_t *
tag_free (tag_t *t) /*{{{*/
{
if (t) {
if (t -> name)
xmlBufferFree (t -> name);
if (t -> cname)
free (t -> cname);
if (t -> type)
free (t -> type);
if (t -> value)
xmlBufferFree (t -> value);
if (t -> parm)
var_free_all (t -> parm);
free (t);
}
return NULL;
}/*}}}*/
xmlChar*
PmmFastEncodeString( int charset,
const xmlChar *string,
const xmlChar *encoding )
{
xmlCharEncodingHandlerPtr coder = NULL;
xmlChar *retval = NULL;
xmlBufferPtr in = NULL, out = NULL;
if ( charset == XML_CHAR_ENCODING_UTF8 ) {
/* warn("use UTF8 for encoding ... %s ", string); */
return xmlStrdup( string );
}
else if ( charset == XML_CHAR_ENCODING_ERROR ) {
/* warn("no standard encoding %s\n", encoding); */
coder =xmlFindCharEncodingHandler( (const char *)encoding );
}
else if ( charset == XML_CHAR_ENCODING_NONE ) {
xs_warn("PmmFastEncodeString: no encoding found\n");
}
else {
/* warn( "use document encoding %s (%d)", encoding, charset ); */
coder= xmlGetCharEncodingHandler( charset );
}
if ( coder != NULL ) {
xs_warn("PmmFastEncodeString: coding machine found \n");
in = xmlBufferCreate();
out = xmlBufferCreate();
xmlBufferCCat( in, (const char *) string );
if ( xmlCharEncInFunc( coder, out, in ) >= 0 ) {
retval = xmlStrdup( out->content );
/* warn( "encoded string is %s" , retval); */
}
else {
/* warn( "b0rked encoiding!\n"); */
}
xmlBufferFree( in );
xmlBufferFree( out );
xmlCharEncCloseFunc( coder );
}
return retval;
}
//!
//! Places raw XML result of an xpath query into buf. The query must return
//! only one element.
//!
//! @param[in] xml_path a string containing the path to the XML file to parse
//! @param[in] xpath a string contianing the XPATH expression to evaluate
//! @param[out] buf for the XML string
//! @param[in] buf_len size of the buf
//!
//! @return EUCA_OK or EUCA_ERROR
//!
int get_xpath_xml(const char *xml_path, const char *xpath, char *buf, int buf_len)
{
int ret = EUCA_ERROR;
xmlDocPtr doc = NULL;
xmlXPathContextPtr context = NULL;
xmlXPathObjectPtr result = NULL;
xmlNodeSetPtr nodeset = NULL;
INIT();
pthread_mutex_lock(&xml_mutex);
{
if ((doc = xmlParseFile(xml_path)) != NULL) {
if ((context = xmlXPathNewContext(doc)) != NULL) {
if ((result = xmlXPathEvalExpression(((const xmlChar *)xpath), context)) != NULL) {
if (!xmlXPathNodeSetIsEmpty(result->nodesetval)) {
nodeset = result->nodesetval;
if (nodeset->nodeNr > 1) {
fprintf(stderr, "multiple matches for '%s' in '%s'\n", xpath, xml_path);
} else {
xmlNodePtr node = nodeset->nodeTab[0]->xmlChildrenNode;
xmlBufferPtr xbuf = xmlBufferCreate();
if (xbuf) {
int len = xmlNodeDump(xbuf, doc, node, 0, 1);
if (len < 0) {
fprintf(stderr, "failed to extract XML from %s\n", xpath);
} else if (len > buf_len) {
fprintf(stderr, "insufficient buffer for %s\n", xpath);
} else {
char *str = (char *)xmlBufferContent(xbuf);
euca_strncpy(buf, str, buf_len);
ret = EUCA_OK;
}
xmlBufferFree(xbuf);
} else {
fprintf(stderr, "failed to allocate XML buffer\n");
}
}
}
xmlXPathFreeObject(result);
} else {
fprintf(stderr, "no results for '%s' in '%s'\n", xpath, xml_path);
}
xmlXPathFreeContext(context);
} else {
fprintf(stderr, "failed to set xpath '%s' context for '%s'\n", xpath, xml_path);
}
xmlFreeDoc(doc);
} else {
fprintf(stderr, "failed to parse XML in '%s'\n", xml_path);
}
}
pthread_mutex_unlock(&xml_mutex);
return ret;
}
std::string XMLConfObj::toString()
{
xmlIndentTreeOutput = 1;
xmlKeepBlanksDefault(0);
xmlBufferPtr xmlBufPtr = xmlBufferCreate();
xmlNodeDump(xmlBufPtr, documentTree, currentLevel, 0, 1);
std::string ret = std::string((char *)xmlBufPtr->content, xmlBufPtr->use);
xmlBufferFree(xmlBufPtr);
return ret;
}
void Free_Writer(CXMLWRITER *test)
{
if (test->writer)
{
xmlTextWriterEndDocument(test->writer);
xmlFreeTextWriter(test->writer);
test->writer=NULL;
}
if (test->buffer) xmlBufferFree(test->buffer);
test->buffer=NULL;
}
c_XMLWriter::~c_XMLWriter() {
if (m_ptr) {
xmlFreeTextWriter(m_ptr);
}
if (m_output) {
xmlBufferFree(m_output);
}
if (m_uri_output) {
xmlOutputBufferClose(m_uri_output);
}
}
static void
biji_lazy_serializer_finalize (GObject *object)
{
BijiLazySerializer *self = BIJI_LAZY_SERIALIZER (object);
BijiLazySerializerPrivate *priv = self->priv;
xmlBufferFree (priv->buf);
xmlFreeTextReader (priv->inner);
G_OBJECT_CLASS (biji_lazy_serializer_parent_class)->finalize (object);
}
