int irislwz_Validate(IRISLWZ_HANDLE *handle, const char *xml, char **beautified)
/*!\brief Do an XML validation against a text
*
* This function takes the given \p xml test an tries to validate it with the XML
* library (xmlReadMemory). If the XML is valid, a \p beautified version, which can
* be better read by humans, can be stored optionally.
*
* \param[in] handle pointer to an IRISLWZ_HANDLE object
* \param[in] xml pointer to the text which should be validated
* \param[out] beautified optional pointer to which a beautified version of the xml
* is written. The Memory for this is allocated by the library, but must be freed by the
* client using \p free.
*
* \returns If the XML is valid, the function returns 1, otherwise 0.
*
* \example
\code
const char *xml="<iris1:request xmlns:iris1=\"urn:ietf:params:xml:ns:iris1\">"
"<iris1:searchSet><iris1:lookupEntity registryType=\"dchk1\" "
"entityClass=\"domain-name\" entityName=\"denic.de\"/>"
"</iris1:searchSet></iris1:request>";
char *beautified=NULL;
if (irislwz_Validate(handle,xml,&beautified)) {
printf ("Original XML code:\n");
printf ("%s\n",xml);
printf ("Beautified version:\n");
printf ("%s\n",beautified);
}
if (beautified) free(beautified);
\endcode
*
* \ingroup DCHK_API_IRISLWZ
*/
{
xmlSetGenericErrorFunc(handle,irislwz_xmlGenericErrorFunc);
xmlDoc *doc = NULL;
//xmlNode *root_element = NULL;
int size=(int)strlen(xml);
//printf ("Query: >>%s<<\n",xml);
//printf ("Size: %i Bytes\n",size);
doc = xmlReadMemory (xml, size,
NULL,
"UTF-8",
XML_PARSE_NONET);
if (doc == NULL) {
irislwz_SetError(handle,74044,NULL);
return 0;
}
if (beautified) {
xmlChar *mem;
int size;
xmlKeepBlanksDefault(0);
xmlDocDumpFormatMemoryEnc(doc, &mem, &size, handle->localcharset,1);
*beautified=strdup((char*)mem);
xmlFree(mem);
}
xmlFreeDoc(doc);
return 1;
}
gchar *midgard_core_object_to_xml(GObject *object)
{
g_assert(object);
xmlDocPtr doc = NULL;
xmlNodePtr root_node = NULL;
LIBXML_TEST_VERSION;
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL,
BAD_CAST "midgard_object");
xmlNewNs(root_node,
BAD_CAST MIDGARD_OBJECT_HREF,
NULL);
xmlNodePtr object_node =
xmlNewNode(NULL, BAD_CAST G_OBJECT_TYPE_NAME(G_OBJECT(object)));
/* Add purged info */
/* We could add this attribute in _write_nodes function
* but this could corrupt xsd compatibility for midgard_metadata nodes.
* So it's added here and for every multilingual content */
xmlNewProp(object_node, BAD_CAST "purge", BAD_CAST "no");
xmlAddChild(root_node, object_node);
xmlDocSetRootElement(doc, root_node);
_write_nodes(G_OBJECT(object), object_node);
xmlChar *buf;
gint size;
xmlDocDumpFormatMemoryEnc(doc, &buf, &size, "UTF-8", 1);
xmlFreeDoc(doc);
xmlCleanupParser();
return (gchar*) buf;
}
wi_string_t * wi_plist_string_for_instance(wi_runtime_instance_t *instance) {
wi_string_t *string = NULL;
xmlDocPtr doc;
xmlDtdPtr dtd;
xmlNodePtr root_node;
xmlChar *buffer;
int length;
doc = xmlNewDoc((xmlChar *) "1.0");
dtd = xmlNewDtd(doc, (xmlChar *) "plist", (xmlChar *) "-//Apple//DTD PLIST 1.0//EN", (xmlChar *) "http://www.apple.com/DTDs/PropertyList-1.0.dtd");
xmlAddChild((xmlNodePtr) doc, (xmlNodePtr) dtd);
root_node = xmlNewNode(NULL, (xmlChar *) "plist");
xmlSetProp(root_node, (xmlChar *) "version", (xmlChar *) "1.0");
xmlDocSetRootElement(doc, root_node);
if(_wi_plist_write_instance_to_node(instance, root_node)) {
xmlDocDumpFormatMemoryEnc(doc, &buffer, &length, "UTF-8", 1);
string = wi_string_with_bytes(buffer, length);
xmlFree(buffer);
}
xmlFreeDoc(doc);
return string;
}
static gchar*
feeds_xbel_group_handler_dump (GrssFeedsGroupHandler *self, GList *channels, GError **error)
{
int size;
xmlChar *ret;
xmlDocPtr doc;
xmlNodePtr xbelNode;
xmlNodePtr childNode;
GList *iter;
GrssFeedChannel *channel;
doc = xmlNewDoc (BAD_CAST"1.0");
xbelNode = xmlNewDocNode (doc, NULL, BAD_CAST"xbel", NULL);
xmlNewProp (xbelNode, BAD_CAST"version", BAD_CAST"1.0");
for (iter = channels; iter; iter = g_list_next (iter)) {
channel = (GrssFeedChannel*) iter->data;
childNode = xmlNewChild (xbelNode, NULL, BAD_CAST"bookmark", NULL);
xmlNewProp (childNode, BAD_CAST"href", BAD_CAST grss_feed_channel_get_source (channel));
xmlNewTextChild (childNode, NULL, BAD_CAST"title", BAD_CAST grss_feed_channel_get_title (channel));
}
xmlDocSetRootElement (doc, xbelNode);
xmlDocDumpFormatMemoryEnc (doc, &ret, &size, "utf-8", 1);
xmlFreeDoc (doc);
return (gchar*) ret;
}
static int32_t ftp_buffer_config(char *send_buf, char *usrname, char *password)
{
xmlChar *temp_xml_buf;
int size = 0;
xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST"RequestMsg");
xmlDocSetRootElement(doc, root_node);
xmlNodePtr head_node = NULL;
xmlNodePtr body_node = NULL;
xmlNodePtr temp = NULL;
head_node = xmlNewNode(NULL, BAD_CAST "MsgHead");
xmlAddChild(root_node, head_node);
package_add_xml_leaf(body_node, root_node, "MsgBody", "");
package_add_xml_leaf(temp, head_node, "usrname", usrname);
package_add_xml_leaf(temp, head_node, "password", password);
xmlDocDumpFormatMemoryEnc(doc, &temp_xml_buf, &size, "UTF-8", 1);
memcpy(send_buf, temp_xml_buf, size);
xmlFree(temp_xml_buf);
if(doc != NULL){
release_dom_tree(doc);
}
return size;
}
static int32_t ftp_buffer_upload(char *send_buf, char *localpath, char *romotepath, char *port)
{
xmlChar *temp_xml_buf;
int size = 0;
xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST"RequestMsg");
xmlDocSetRootElement(doc, root_node);
xmlNodePtr head_node = NULL;
xmlNodePtr body_node = NULL;
xmlNodePtr temp = NULL;
head_node = xmlNewNode(NULL, BAD_CAST "MsgHead");
xmlAddChild(root_node, head_node);
package_add_xml_leaf(body_node, root_node, "MsgBody", "");
package_add_xml_leaf(temp, head_node, "UpLoadLocalPath", localpath);
package_add_xml_leaf(temp, head_node, "UpLoadRomtePath", romotepath);
package_add_xml_leaf(temp, head_node, "Port", port);
xmlDocDumpFormatMemoryEnc(doc, &temp_xml_buf, &size, "UTF-8", 1);
memcpy(send_buf, temp_xml_buf, size);
xmlFree(temp_xml_buf);
if(doc != NULL){
release_dom_tree(doc);
}
return size;
}
char *
cr_xml_dump_repomd(cr_Repomd *repomd, GError **err)
{
xmlDocPtr doc;
xmlNodePtr root;
char *result;
assert(!err || *err == NULL);
if (!repomd) {
g_set_error(err, CREATEREPO_C_ERROR, CRE_BADARG,
"No repomd object to dump specified");
return NULL;
}
// Dump IT!
doc = xmlNewDoc(BAD_CAST XML_DOC_VERSION);
root = xmlNewNode(NULL, BAD_CAST "repomd");
cr_xml_dump_repomd_body(root, repomd);
xmlDocSetRootElement(doc, root);
xmlDocDumpFormatMemoryEnc(doc,
(xmlChar **) &result,
NULL,
XML_ENCODING,
FORMAT_XML);
// Clean up
xmlFreeDoc(doc);
return result;
}
char *
cr_xml_dump_updateinfo(cr_UpdateInfo *updateinfo, GError **err)
{
xmlDocPtr doc;
xmlNodePtr root;
char *result;
assert(!err || *err == NULL);
if (!updateinfo)
return NULL;
// Dump IT!
doc = xmlNewDoc(BAD_CAST XML_DOC_VERSION);
root = xmlNewNode(NULL, BAD_CAST "updates");
cr_xml_dump_updateinfo_body(root, updateinfo);
xmlDocSetRootElement(doc, root);
xmlDocDumpFormatMemoryEnc(doc,
(xmlChar **) &result,
NULL,
XML_ENCODING,
FORMAT_XML);
// Clean up
xmlFreeDoc(doc);
return result;
}
char *
cr_xml_dump_repomd(cr_Repomd *repomd, GError **err)
{
xmlDocPtr doc;
xmlNodePtr root;
char *result;
assert(!err || *err == NULL);
if (!repomd)
return NULL;
// Dump IT!
doc = xmlNewDoc(BAD_CAST XML_DOC_VERSION);
root = xmlNewNode(NULL, BAD_CAST "repomd");
cr_xml_dump_repomd_body(root, repomd);
xmlDocSetRootElement(doc, root);
xmlDocDumpFormatMemoryEnc(doc,
(xmlChar **) &result,
NULL,
XML_ENCODING,
FORMAT_XML);
// Clean up
xmlFreeDoc(doc);
return result;
}
gchar *
gpinstruct_parser_save_to_string (GPInstructParser *parser,
GPInstructProject *project,
GError **error)
{
xmlChar *buffer;
gchar *contents;
xmlDocPtr doc = create_xml_document_from_project (project);
if (!doc)
{
g_set_error (error, GPINSTRUCT_PARSER_ERROR, GPINSTRUCT_PARSER_ERROR_PARSE,
_("Failed to create an XML document from project."));
return NULL;
}
xmlIndentTreeOutput = 1;
xmlTreeIndentString = "\t";
xmlDocDumpFormatMemoryEnc (doc, &buffer, NULL, "UTF-8", 1);
contents = g_strdup ((char*) buffer);
xmlFree (buffer);
xmlFreeDoc (doc);
return contents;
}
int File::saveXML(FILE *fp, Context *ctx) {
char *data = NULL;
int size;
xmlDocPtr doc = getXML(ctx);
if (!doc) {
goto fail;
}
xmlDocDumpFormatMemoryEnc(doc, (xmlChar**)&data, &size, "UTF-8", 1);
if (size) {
fwrite(data, size, 1, fp);
}
if (data) {
xmlFree(data);
}
xmlFreeDoc(doc);
return size;
fail:
if (data) {
xmlFree(data);
}
return 0;
}
char *osync_xml_write_to_string(xmlDoc *doc)
{
xmlChar *temp = NULL;
int size = 0;
xmlKeepBlanksDefault(0);
xmlDocDumpFormatMemoryEnc(doc, &temp, &size, NULL, 1);
return (char *)temp;
}
/**
* @brief write the cache from the xmlDoc to cache file
*
* @param[in/out] zrtpContext The zrtp context containing the cacheBuffer
*
*/
static void bzrtp_writeCache(bzrtpContext_t *zrtpContext) {
/* dump the xml document into a string */
xmlChar *xmlStringOutput;
int xmlStringLength;
xmlDocDumpFormatMemoryEnc(zrtpContext->cacheBuffer, &xmlStringOutput, &xmlStringLength, "UTF-8", 0);
/* write it to the file */
zrtpContext->zrtpCallbacks.bzrtp_writeCache(zrtpContext->ZIDCacheData, xmlStringOutput, xmlStringLength);
xmlFree(xmlStringOutput);
}
osync_bool osync_xmlformat_assemble(OSyncXMLFormat *xmlformat, char **buffer, unsigned int *size)
{
osync_assert(xmlformat);
osync_assert(buffer);
osync_assert(size);
xmlDocDumpFormatMemoryEnc(xmlformat->doc, (xmlChar **)buffer, (int *)size, NULL, 1);
return TRUE;
}
int msWFSException11(mapObj *map, const char *locator,
const char *exceptionCode, const char *version)
{
int size = 0;
char *errorString = NULL;
char *errorMessage = NULL;
char *schemasLocation = NULL;
const char *encoding;
xmlDocPtr psDoc = NULL;
xmlNodePtr psRootNode = NULL;
xmlNsPtr psNsOws = NULL;
xmlChar *buffer = NULL;
if (version == NULL)
version = "1.1.0";
psNsOws = xmlNewNs(NULL, BAD_CAST "http://www.opengis.net/ows", BAD_CAST "ows");
encoding = msOWSLookupMetadata(&(map->web.metadata), "FO", "encoding");
errorString = msGetErrorString("\n");
errorMessage = msEncodeHTMLEntities(errorString);
schemasLocation = msEncodeHTMLEntities(msOWSGetSchemasLocation(map));
psDoc = xmlNewDoc(BAD_CAST "1.0");
psRootNode = msOWSCommonExceptionReport(psNsOws, OWS_1_0_0, schemasLocation, version, msOWSGetLanguage(map, "exception"), exceptionCode, locator, errorMessage);
xmlDocSetRootElement(psDoc, psRootNode);
xmlNewNs(psRootNode, BAD_CAST "http://www.opengis.net/ows", BAD_CAST "ows");
if (encoding)
msIO_setHeader("Content-Type","text/xml; charset=%s", encoding);
else
msIO_setHeader("Content-Type","text/xml");
msIO_sendHeaders();
xmlDocDumpFormatMemoryEnc(psDoc, &buffer, &size, (encoding ? encoding : "ISO-8859-1"), 1);
msIO_printf("%s", buffer);
/*free buffer and the document */
free(errorString);
free(errorMessage);
free(schemasLocation);
xmlFree(buffer);
xmlFreeDoc(psDoc);
xmlFreeNs(psNsOws);
/* clear error since we have already reported it */
msResetErrorList();
return MS_FAILURE;
}
static int
hwloc_libxml_export_buffer(hwloc_topology_t topology, char **xmlbuffer, int *buflen)
{
xmlDocPtr doc;
doc = hwloc__libxml2_prepare_export(topology);
xmlDocDumpFormatMemoryEnc(doc, (xmlChar **)xmlbuffer, buflen, "UTF-8", 1);
xmlFreeDoc(doc);
return 0;
}
static int
hwloc_libxml_export_diff_buffer(hwloc_topology_diff_t diff, const char *refname, char **xmlbuffer, int *buflen)
{
xmlDocPtr doc;
doc = hwloc__libxml2_prepare_export_diff(diff, refname);
xmlDocDumpFormatMemoryEnc(doc, (xmlChar **)xmlbuffer, buflen, "UTF-8", 1);
xmlFreeDoc(doc);
return 0;
}
void
soup_soap_message_persist (SoupSoapMessage *msg)
{
g_return_if_fail (SOUP_SOAP_IS_MESSAGE (msg));
xmlChar *buffer;
const gchar *contents;
SoupSoapMessagePrivate *priv = msg->priv;
xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
xmlNodePtr envelope_node = xmlNewNode (NULL, BAD_CAST "Envelope");
xmlSetNs (envelope_node,
xmlNewNs (envelope_node,
BAD_CAST SOAP_ENV_NAMESPACE,
BAD_CAST "SOAP-ENV"));
xmlNewNs (envelope_node,
BAD_CAST XSD_NAMESPACE,
BAD_CAST "xsd");
xmlNewNs (envelope_node,
BAD_CAST XSI_NAMESPACE,
BAD_CAST "xsi");
xmlNewNs (envelope_node,
BAD_CAST SOAP_ENC_NAMESPACE,
BAD_CAST "SOAP-ENC");
xmlSetProp (envelope_node,
BAD_CAST "SOAP-ENV:encodingStyle",
BAD_CAST SOAP_ENCODING_STYLE);
xmlDocSetRootElement (doc, envelope_node);
create_param_node (doc, SOUP_SOAP_PARAM (priv->header), envelope_node);
xmlNodePtr body_node = xmlNewChild (envelope_node, NULL, BAD_CAST "Body", NULL);
create_param_node (doc, SOUP_SOAP_PARAM (priv->body), body_node);
xmlDocDumpFormatMemoryEnc (doc, &buffer, NULL, "UTF-8", 0);
contents = (gchar *) buffer;
soup_message_body_truncate (priv->message_body);
soup_message_body_append (priv->message_body, SOUP_MEMORY_COPY,
contents, strlen (contents));
soup_message_body_complete (priv->message_body);
xmlFree (buffer);
xmlFreeDoc (doc);
soup_message_headers_set_content_type (priv->message_headers,
"text/xml", NULL);
}
int agent_register(u32 agent_id, const char *seq)
{
//pack the login xml
xmlDocPtr doc = create_xml_doc();
xmlNodePtr devnode;
xmlNodePtr childnode;
xmlNodePtr rootnode = create_xml_root_node(doc,"AGENT_REGISTER");
struct timeval now;
gettimeofday(&now, NULL);
char * time = PRINTTIME(now);
add_xml_child(rootnode, "timestamp",time); free(time);
devnode = add_xml_child(rootnode, "device", NULL);
char aid[24];
sprintf(aid,"%d", get_pma_id());
add_xml_child_prop(devnode, "id",aid);
char dev_type[10];
if( get_protocol_type() == OSPF_ROUTER )
sprintf(dev_type, "ospf");
else if( get_protocol_type() == BGP_ROUTER )
sprintf(dev_type, "bgp");
else {}
add_xml_child(devnode, "type", dev_type);
char* xmlbuff;
int len = 0;
xmlDocDumpFormatMemoryEnc( doc, &xmlbuff, &len, "UTF-8", 0);
char* buff = (char*)malloc(len+1);
memcpy(buff, xmlbuff, len);
buff[len] = 0;
xmlFree(xmlbuff);
xmlFreeDoc(doc);
struct req_args *login_args =
(struct req_args *)malloc(sizeof(struct req_args)+len);
memset(login_args->ip, 0, sizeof(login_args->ip));
char *ip = get_server_address();
memcpy(login_args->ip, ip, strlen(ip));
login_args->port = get_server_port();
login_args->ops_type = OPS_PMA_LOGIN;
login_args->len = len;
memcpy(login_args->data, buff, len);
free(buff);
if (login(login_args) == ((void *)-1)) {
free(login_args);
return -1;
}
free(login_args);
agent_login_status = AGENT_LOGIN;
return SUCCESS;
}
osync_bool osync_capabilities_assemble(OSyncCapabilities *capabilities, char **buffer, unsigned int *size, OSyncError **error)
{
xmlDocPtr doc = NULL;
xmlNodePtr root;
char *version_str;
const char *capsformat;
OSyncList *l;
osync_assert(capabilities);
capsformat = osync_capabilities_get_format(capabilities);
if (!capsformat) {
osync_error_set(error, OSYNC_ERROR_GENERIC, "Can't assamble capabilities: Capabilities Format not set.");
goto error;
}
if (capabilities->doc)
osync_xml_free_doc(capabilities->doc);
capabilities->doc = doc = xmlNewDoc(BAD_CAST "1.0");
capabilities->doc->children = xmlNewDocNode(capabilities->doc, NULL, (xmlChar *)"Caps", NULL);
capabilities->doc->_private = capabilities;
/* Set version for capabilities configuration */
version_str = osync_strdup_printf("%u.%u", OSYNC_CAPS_MAJOR_VERSION, OSYNC_CAPS_MINOR_VERSION);
xmlSetProp(doc->children, (const xmlChar*)"Version", (const xmlChar *)version_str);
osync_free(version_str);
/* Set CapsFormat Name */
xmlSetProp(doc->children, (const xmlChar*)"CapsFormat", (const xmlChar *)capsformat);
root = doc->children;
for (l = capabilities->objtypes; l; l = l->next) {
OSyncCapabilitiesObjType *capobjtype;
capobjtype = (OSyncCapabilitiesObjType *) l->data;
if (!osync_capabilities_objtype_assemble(capobjtype, root, error))
goto error;
}
/* XXX Ugly cast, but we try to fit here the opensync API pattern of unsigned size/length types */
xmlDocDumpFormatMemoryEnc(doc, (xmlChar **) buffer, (int *) size, NULL, 1);
return TRUE;
/*
error_oom:
osync_error_set(error, OSYNC_ERROR_GENERIC, "Couldn't allocate memory to assemble capabilities file.");
*/
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s" , __func__, osync_error_print(error));
return FALSE;
}
char *DomTree::xml(bool indent) {
xmlDocPtr doc;
xmlNodePtr cur;
doc = xmlNewDoc((xmlChar *)version.c_str());
doc->children = xmlNewDocNode(doc, NULL,(const xmlChar *)name.c_str(), NULL);
for(unsigned int i = 0; i < attributes.size() ; i++) {
xmlSetProp(doc->children,(const xmlChar *)attributes[i]->getName().c_str(),(const xmlChar *)attributes[i]->getValue().c_str());
}
for(unsigned int i = 0; i < elements.size() ; i++) {
cur = xmlNewChild(doc->children,NULL,(const xmlChar *)elements[i]->getName().c_str(),(xmlChar *)elements[i]->getValue().c_str());
if(elements[i]->getAttributes().size() > 0) {
for(unsigned int a = 0; a < elements[i]->getAttributes().size() ; a++) {
xmlSetProp(cur,(const xmlChar *)elements[i]->getAttributes()[a]->getName().c_str(),(const xmlChar *)elements[i]->getAttributes()[a]->getValue().c_str());
}
}
if ( elements[i]->getChildren().size() > 0 ) {
for(unsigned int b = 0; b < elements[i]->getChildren().size() ; b++) {
dumpXmlChild(cur,elements[i]->getChildren()[b]);
}
}
}
xmlChar *output;
int len;
// len =sizeof(len);
if(indent) {
xmlDocDumpFormatMemoryEnc(doc, &output, &len , (char *)encoding.c_str(),1);
} else {
xmlDocDumpFormatMemoryEnc(doc, &output, &len,(char *)encoding.c_str(),0);
}
xmlFreeDoc(doc);
xmlCleanupParser();
return((char *)output);
}
int flattenxml(xmlDocPtr doc, char **xml, int pretty)
{
xmlChar *xmlbuff;
int buffersize;
xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, "UTF-8", pretty);
*xml = malloc(snprintf(NULL, 0, "%s", (char *) xmlbuff) + 1);
sprintf(*xml, "%s", (char *) xmlbuff);
xmlFree(xmlbuff);
return 0;
}
static void test_osmChange(osm_t::ref osm, const char *fn)
{
xmlDocGuard doc(osmchange_init());
const char *changeset = "42";
osmchange_delete(osm->modified(), xmlDocGetRootElement(doc.get()), changeset);
xmlChar *result;
int len;
xmlDocDumpFormatMemoryEnc(doc.get(), &result, &len, "UTF-8", 1);
compare_with_file(result, len, fn);
xmlFree(result);
}
/* call-seq:
* XML::Parser::Context.document(document) -> XML::Parser::Context
*
* Creates a new parser context based on the specified document.
*
* Parameters:
*
* document - An XML::Document instance.
*/
static VALUE rxml_parser_context_document(VALUE klass, VALUE document)
{
xmlParserCtxtPtr ctxt;
xmlDocPtr xdoc;
xmlChar *buffer;
int length;
if (rb_obj_is_kind_of(document, cXMLDocument) == Qfalse)
rb_raise(rb_eTypeError, "Must pass an XML::Document object");
Data_Get_Struct(document, xmlDoc, xdoc);
xmlDocDumpFormatMemoryEnc(xdoc, &buffer, &length, xdoc->encoding, 0);
ctxt = xmlCreateDocParserCtxt(buffer);
return rxml_parser_context_wrap(ctxt);
}
std::string BB::PatchCollection::serialize() const
{
std::map<const BB::Patch*, size_t> patchMap;
size_t currentPatchIndex;
xmlDocPtr doc;
xmlNodePtr collection, patch;
std::string data;
xmlChar * doc_txt;
int doc_txt_len;
doc = xmlNewDoc(BAD_CAST "1.0");
collection = xmlNewNode(NULL, BAD_CAST "collection");
xmlDocSetRootElement(doc, collection);
currentPatchIndex = 0;
for (std::set<BB::Patch*>::const_iterator
i = this->m_patches.begin(),
e = this->m_patches.end();
i != e; ++i)
{
patchMap.insert(std::make_pair(*i, currentPatchIndex));
++currentPatchIndex;
}
for (std::set<BB::Patch*>::const_iterator
i = this->m_patches.begin(),
e = this->m_patches.end();
i != e; ++i)
{
patch = (*i)->serialize(patchMap);
xmlAddChild(collection, patch);
}
doc_txt = NULL;
xmlDocDumpFormatMemoryEnc(doc, &doc_txt, &doc_txt_len, "UTF-8", 1);
if (doc_txt == NULL)
this->m_context.throwException("Unable to write memory!");
xmlFreeDoc(doc);
xmlCleanupParser();
xmlMemoryDump();
data.assign((char*)doc_txt, doc_txt_len);
return data;
}
/**
* midgard_replicator_serialize_blob:
* @object: #MidgardObject of MIDGARD_TYPE_ATTACHMENT type
*
* Serialize midgard_blob binary data.
*
* Returns: Newly allocated xml buffer, which holds blob data base64 encoded, or %NULL.
*/
gchar *
midgard_replicator_serialize_blob (MidgardObject *object)
{
GType attachment_type = g_type_from_name ("midgard_attachment");
g_return_val_if_fail (g_type_is_a (G_OBJECT_TYPE (object), attachment_type), NULL);
MidgardBlob *blob = midgard_blob_new(object, NULL);
if(!blob)
return NULL;
gsize bytes_read = 0;
gchar *content = midgard_blob_read_content(blob, &bytes_read);
if(!content) {
g_object_unref(blob);
return NULL;
}
gchar *encoded =
g_base64_encode((const guchar *)content, bytes_read);
g_free(content);
xmlDoc *doc = midgard_core_object_create_xml_doc();
xmlNode *root_node =
xmlDocGetRootElement(doc);
xmlNode *blob_node =
xmlNewTextChild(root_node, NULL,
(const xmlChar*)
"midgard_blob",
BAD_CAST encoded);
xmlNewProp(blob_node, BAD_CAST "guid",
BAD_CAST MGD_OBJECT_GUID (object));
g_free(encoded);
g_object_unref (blob);
xmlChar *buf;
gint size;
xmlDocDumpFormatMemoryEnc(doc, &buf, &size, "UTF-8", 1);
xmlFreeDoc(doc);
xmlCleanupParser();
return (gchar*) buf;
}
static ValueStruct *_CloseXML(DBG_Struct *dbg, DBCOMM_CTRL *ctrl,
RecordStruct *rec, ValueStruct *args) {
ValueStruct *obj, *ret;
xmlChar *buff;
int size;
DBG_Struct *mondbg;
buff = NULL;
ret = NULL;
if (rec->type != RECORD_DB) {
ctrl->rc = MCP_BAD_ARG;
return NULL;
}
if ((obj = GetItemLongName(args, "object")) == NULL) {
ctrl->rc = MCP_BAD_ARG;
return NULL;
}
if (XMLDoc == NULL) {
ctrl->rc = MCP_BAD_OTHER;
return NULL;
}
ctrl->rc = MCP_OK;
if (XMLmode == MODE_WRITE) {
xmlDocDumpFormatMemoryEnc(XMLDoc, &buff, &size, "UTF-8", 0);
if (buff != NULL) {
mondbg = GetDBG_monsys();
ValueObjectId(obj) = blob_import_mem(mondbg, 0, "XMLIO.xml",
"application/xml", 0, buff, size);
if (ValueObjectId(obj) != GL_OBJ_NULL) {
ret = DuplicateValue(args, TRUE);
ctrl->rc = MCP_OK;
} else {
Warning("monblob_import_mem failure");
ctrl->rc = MCP_BAD_OTHER;
}
}
xfree(buff);
}
xmlFreeDoc(XMLDoc);
XMLDoc = NULL;
XMLpos = 0;
XMLmode = MODE_NONE;
return ret;
}
int admin_send_response (xmlDocPtr doc, client_t *client,
admin_response_type response, const char *xslt_template)
{
int ret = -1;
if (response == RAW)
{
xmlChar *buff = NULL;
int len = 0;
unsigned int buf_len;
const char *http = "HTTP/1.0 200 OK\r\n"
"Content-Type: text/xml\r\n"
"Content-Length: ";
xmlDocDumpFormatMemoryEnc (doc, &buff, &len, NULL, 1);
buf_len = strlen (http) + len + 20;
client_set_queue (client, NULL);
client->refbuf = refbuf_new (buf_len);
len = snprintf (client->refbuf->data, buf_len, "%s%d\r\n\r\n%s", http, len, buff);
client->refbuf->len = len;
xmlFree(buff);
xmlFreeDoc (doc);
client->respcode = 200;
return fserve_setup_client (client);
}
if (response == XSLT)
{
char *fullpath_xslt_template;
int fullpath_xslt_template_len;
ice_config_t *config = config_get_config();
fullpath_xslt_template_len = strlen (config->adminroot_dir) +
strlen(xslt_template) + 2;
fullpath_xslt_template = malloc(fullpath_xslt_template_len);
snprintf(fullpath_xslt_template, fullpath_xslt_template_len, "%s%s%s",
config->adminroot_dir, PATH_SEPARATOR, xslt_template);
config_release_config();
DEBUG1("Sending XSLT (%s)", fullpath_xslt_template);
ret = xslt_transform (doc, fullpath_xslt_template, client);
free(fullpath_xslt_template);
xmlFreeDoc(doc);
}
return ret;
}
string cXmlDoc::write(bool indent, const char* encoding) {
if (!m_doc)
throw eXmlInvalid("Tried to write bad document");
xmlChar* output;
int outputlen;
if (indent) {
xmlDocDumpFormatMemoryEnc(m_doc.get(), &output, &outputlen, encoding, 1);
} else {
xmlDocDumpMemoryEnc(m_doc.get(), &output, &outputlen, encoding);
}
string ret;
if (output) {
ret = reinterpret_cast<char*>(output);
xmlFree(output);
}
return ret;
}
static gchar *
i_event_to_xml(const I_event *i_event)
{
GString *xml_string = g_string_new("");
xmlNodePtr root_node = NULL;
xmlDocPtr doc = NULL;
xmlChar *xml_buf = NULL;
gchar *return_string = NULL;
gint buf_size;
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST KLB_EVENT);
add_property (root_node, "version", "1.0");
/* xmlNodeSetContent(root_node, BAD_CAST "content"); */
xmlDocSetRootElement(doc, root_node);
conv_incidence_i_to_k(root_node, i_event->incidence);
if (i_event->show_time_as)
add_child_node(root_node, KLB_EVENT_SHOW_TIME_AS, show_time_as_to_kolab_string(i_event->show_time_as));
if (i_event->end_date) {
gchar *end_date_string = date_or_datetime_to_string(i_event->end_date);
add_child_node(root_node, KLB_EVENT_END_DATE, end_date_string);
g_free(end_date_string);
}
i_kolab_store_get_xml_nodes(i_event->incidence->common, i_event->incidence->common, root_node);
/* Convert xml to a string */
xmlDocDumpFormatMemoryEnc(doc, &xml_buf, &buf_size, "UTF-8", 1);
g_string_append(xml_string, (gchar*) xml_buf);
/* log_debug("%s", (char *) xmlbuff); */
/* Free associated memory. */
xmlFree(xml_buf);
xmlFreeDoc(doc);
return_string = g_string_free (xml_string, FALSE);
return return_string;
}
