char *DomTree::dumpXmlStr() const { xmlDocPtr doc; xmlNodePtr cur; doc = xmlNewDoc((const xmlChar *)version.c_str()); doc->children = xmlNewDocNode(doc, NULL,(const xmlChar *)name.c_str(), NULL); 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(doc); xmlDocDumpFormatMemory(doc, &output, &len,1); xmlFreeDoc(doc); return((char *)output); }
static ESourceGroup * create_group (EAccount * account, const char *type_string) { ESourceGroup *gfake; char *uid; char *base_uri; xmlDocPtr doc; xmlNodePtr root; EUri *euri; const char *surl; uid = g_strdup_printf ("%s@%s", type_string, account->uid); doc = xmlNewDoc ("1.0"); root = xmlNewDocNode (doc, NULL, "group", NULL); xmlDocSetRootElement (doc, root); surl = e_account_get_string (account, E_ACCOUNT_SOURCE_URL); euri = e_uri_new (surl); base_uri = create_base_uri (euri); e_uri_free (euri); xmlSetProp (root, "uid", uid); xmlSetProp (root, "name", account->name); xmlSetProp (root, "base_uri", base_uri); gfake = e_source_group_new_from_xmldoc (doc); g_free (base_uri); g_free (uid); xmlFreeDoc (doc); return gfake; }
static xmlDoc * ews_create_autodiscover_xml (const gchar *email) { xmlDoc *doc; xmlNode *node; xmlNs *ns; doc = xmlNewDoc ((xmlChar *) "1.0"); node = xmlNewDocNode (doc, NULL, (xmlChar *) "Autodiscover", NULL); xmlDocSetRootElement (doc, node); ns = xmlNewNs ( node, (xmlChar *) "http://schemas.microsoft.com/exchange/autodiscover/outlook/requestschema/2006", NULL); node = xmlNewChild (node, ns, (xmlChar *) "Request", NULL); xmlNewChild (node, ns, (xmlChar *) "EMailAddress", (xmlChar *) email); xmlNewChild ( node, ns, (xmlChar *) "AcceptableResponseSchema", (xmlChar *) "http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a"); return doc; }
gint writePalettes (void) { gint ret = -1; xmlDocPtr doc; xmlNodePtr parent, child; gchar *localpal = NULL; localpal = g_build_filename (get_user_data_dir (TRUE), "actions", "palettes.xml", NULL); doc = xmlNewDoc ((xmlChar *) "1.0"); doc->xmlRootNode = parent = xmlNewDocNode (doc, NULL, (xmlChar *) "Denemo", NULL); GList *g; for( g = Denemo.palettes; g; g = g->next) { child = xmlNewChild (parent, NULL, (xmlChar *) "palette", NULL); save_palette (child, g->data); } if (xmlSaveFormatFile (localpal, doc, 1) < 0) { g_warning ("Could not save file %s", localpal); ret = -1; } else ret = 0; xmlFreeDoc (doc); return ret; }
static void gss_config_append_config_file (GString * s) { GList *g; xmlNsPtr ns; xmlDocPtr doc; doc = xmlNewDoc ((xmlChar *) "1.0"); doc->xmlRootNode = xmlNewDocNode (doc, NULL, (xmlChar *) "oberon", NULL); ns = xmlNewNs (doc->xmlRootNode, (xmlChar *) "http://entropywave.com/oberon/1.0/", (xmlChar *) "ew"); for (g = config_list; g; g = g_list_next (g)) { GObject *object = g->data; gss_config_dump_object (object, ns, doc->xmlRootNode); } { xmlChar *str; int len; xmlDocDumpFormatMemory (doc, &str, &len, 1); g_string_append (s, (char *) str); xmlFree (str); } xmlFreeDoc (doc); }
static void command_manageauth(client_t *client, source_t *source, int response) { xmlDocPtr doc; xmlNodePtr node, srcnode, msgnode; char *action = NULL; char *username = NULL; char *password = NULL; char *message = NULL; int ret = AUTH_OK; if((COMMAND_OPTIONAL(client, "action", action))) { if (!strcmp(action, "add")) { COMMAND_REQUIRE(client, "username", username); COMMAND_REQUIRE(client, "password", password); ret = auth_adduser(source, username, password); if (ret == AUTH_FAILED) { message = strdup("User add failed - check the icecast error log"); } if (ret == AUTH_USERADDED) { message = strdup("User added"); } if (ret == AUTH_USEREXISTS) { message = strdup("User already exists - not added"); } } if (!strcmp(action, "delete")) { COMMAND_REQUIRE(client, "username", username); ret = auth_deleteuser(source, username); if (ret == AUTH_FAILED) { message = strdup("User delete failed - check the icecast error log"); } if (ret == AUTH_USERDELETED) { message = strdup("User deleted"); } } } doc = xmlNewDoc("1.0"); node = xmlNewDocNode(doc, NULL, "icestats", NULL); srcnode = xmlNewChild(node, NULL, "source", NULL); xmlSetProp(srcnode, "mount", source->mount); if (message) { msgnode = xmlNewChild(node, NULL, "iceresponse", NULL); xmlNewChild(msgnode, NULL, "message", message); } xmlDocSetRootElement(doc, node); auth_get_userlist(source, srcnode); admin_send_response(doc, client, response, MANAGEAUTH_TRANSFORMED_REQUEST); if (message) { free(message); } xmlFreeDoc(doc); client_destroy(client); }
bool CXmlTree::CreateNewTree(const char *name, const char *value /* = NULL */) { CServerIo::trace(3,"CXmlTree::CreateNewTree(%s,%s)",(name)?name:"NULL",(value)?value:"NULL"); DiscardTree(); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlSetStructuredErrorFunc()"); xmlSetStructuredErrorFunc(this, errorFunc); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlKeepBlanksDefault(0)"); xmlKeepBlanksDefault(0); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlLineNumbersDefault(1)"); xmlLineNumbersDefault(1); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlNewDoc()"); m_doc = xmlNewDoc((const xmlChar *)"1.0"); if(!m_doc) return false; CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlNewDocNode()"); xmlNodePtr node = xmlNewDocNode(m_doc, NULL, (const xmlChar *)name, (const xmlChar *)value); if(!node) return false; CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlDocSetRootElement()"); xmlDocSetRootElement (m_doc, node); CServerIo::trace(3,"CXmlTree::CreateNewTree() - return"); return true; }
int fserve_list_clients (client_t *client, const char *mount, int response, int show_listeners) { int ret; fbinfo finfo; xmlDocPtr doc; xmlNodePtr node, srcnode; finfo.flags = 0; finfo.mount = (char*)mount; finfo.limit = 0; finfo.fallback = NULL; doc = xmlNewDoc(XMLSTR("1.0")); node = xmlNewDocNode(doc, NULL, XMLSTR("icestats"), NULL); xmlDocSetRootElement(doc, node); srcnode = xmlNewChild(node, NULL, XMLSTR("source"), NULL); xmlSetProp(srcnode, XMLSTR("mount"), XMLSTR(mount)); ret = fserve_list_clients_xml (srcnode, &finfo); if (ret == 0 && finfo.flags&FS_FALLBACK) { finfo.flags = 0; // retry ret = fserve_list_clients_xml (srcnode, &finfo); } if (ret) { char buf [20]; snprintf (buf, sizeof(buf), "%d", ret); xmlNewChild (srcnode, NULL, XMLSTR("listeners"), XMLSTR(buf)); return admin_send_response (doc, client, response, "listclients.xsl"); } xmlFreeDoc (doc); return client_send_400 (client, "mount does not exist"); }
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; }
enum jal_status jal_create_audit_transforms_elem( xmlDocPtr doc, xmlNodePtr *new_elem) { if (!new_elem || *new_elem || !doc) { return JAL_E_XML_CONVERSION; } xmlChar *namespace_uri = (xmlChar *)JAL_XMLDSIG_URI; xmlNodePtr out_elem = xmlNewDocNode(doc, NULL, (xmlChar *) JAL_XML_TRANSFORMS, NULL); xmlNsPtr ns = xmlNewNs(out_elem, namespace_uri, NULL); xmlSetNs(out_elem, ns); xmlNodePtr transform_elem = xmlNewChild( out_elem, NULL, (xmlChar *) JAL_XML_TRANSFORM, NULL); xmlSetProp(transform_elem, (xmlChar *) JAL_XML_ALGORITHM, (xmlChar *) JAL_XML_WITH_COMMENTS); *new_elem = out_elem; return JAL_OK; }
static int command_show_listeners (client_t *client, source_t *source, int response) { xmlDocPtr doc; xmlNodePtr node, srcnode; long id = -1; const char *ID_str = NULL; char buf[22]; doc = xmlNewDoc(XMLSTR("1.0")); node = xmlNewDocNode(doc, NULL, XMLSTR("icestats"), NULL); srcnode = xmlNewChild(node, NULL, XMLSTR("source"), NULL); xmlSetProp(srcnode, XMLSTR("mount"), XMLSTR(source->mount)); xmlDocSetRootElement(doc, node); snprintf(buf, sizeof(buf), "%lu", source->listeners); xmlNewChild(srcnode, NULL, XMLSTR("listeners"), XMLSTR(buf)); COMMAND_OPTIONAL(client, "id", ID_str); if (ID_str) id = atoi (ID_str); if (id == -1) admin_source_listeners (source, srcnode); else { client_t *listener = source_find_client (source, id); if (listener) stats_listener_to_xml (listener, srcnode); } thread_mutex_unlock (&source->lock); return admin_send_response (doc, client, response, "listclients.xsl"); }
xmlChar * xsltEvalTemplateString(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst) { xmlNodePtr oldInsert, insert = NULL; xmlChar *ret; if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL)) return(NULL); if (inst->children == NULL) return(NULL); insert = xmlNewDocNode(ctxt->output, NULL, (const xmlChar *)"fake", NULL); if (insert == NULL) { xsltTransformError(ctxt, NULL, contextNode, "Failed to create temporary node\n"); return(NULL); } oldInsert = ctxt->insert; ctxt->insert = insert; xsltApplyOneTemplate(ctxt, contextNode, inst->children, NULL, NULL); ctxt->insert = oldInsert; ret = xmlNodeGetContent(insert); if (insert != NULL) xmlFreeNode(insert); return(ret); }
/* Populate the preset with the current values in sliders, and save it to * disk */ static void preset_save(xmlDoc *preset, GtkWidget *slider_band[NUM_BANDS]) { gint i; gchar *gain; gchar *band_number; gchar *preset_fullname; xmlNode *child_node; xmlNode *root_node; /* Create nodes with band values */ root_node = xmlNewDocNode(preset, NULL, BAD_CAST XML_NODE_EQUALIZER, NULL); xmlDocSetRootElement(preset, root_node); for (i = 0; i < NUM_BANDS; i++) { gain = g_strdup_printf( "%.1f", gtk_range_get_value(GTK_RANGE(slider_band[i]))); band_number = g_strdup_printf("%d", i); child_node = xmlNewChild(root_node, NULL, BAD_CAST XML_NODE_BAND, BAD_CAST gain); xmlSetProp(child_node, BAD_CAST XML_PROP_BAND_NUMBER, BAD_CAST band_number); g_free(gain); g_free(band_number); } preset_fullname = g_strdup_printf ("%s/%s", HOME_PRESETS, preset->name); xmlSaveFile(preset_fullname, preset); g_free(preset_fullname); }
xmlNode* child_node_list::create_element_(const std::string& qname, const std::string& uri) { // Split QName into prefix and local name. std::pair<std::string, std::string> name_pair = detail::split_qname(qname); const std::string& prefix = name_pair.first; const std::string& name = name_pair.second; // Create element without namespace. xmlNode* px = xmlNewDocNode( raw_->doc, 0, detail::to_xml_chars(name.c_str()), 0 ); if (px == 0) { std::string what = "fail to create libxml2 element node for " + name; throw internal_dom_error(what); } // Declare XML namespace on the element, and put the element under it. xmlNs* ns = xmlNewNs( px, detail::to_xml_chars(uri.c_str()), prefix.empty() ? 0 : detail::to_xml_chars(prefix.c_str()) ); if (ns == 0) { // TODO: delete the node. std::string what = "fail to create libxml2 namespace for " + prefix + "=" + uri; throw internal_dom_error(what); } xmlSetNs(px, ns); // Return the new element. return px; }
xmlNode* child_node_list::create_element_(const std::string& qname) { // Split QName into prefix and local name. std::pair<std::string, std::string> name_pair = detail::split_qname(qname); const std::string& prefix = name_pair.first; const std::string& name = name_pair.second; // Find xmlns by prefix (if this child node list belongs to an element). xmlNs* ns = 0; if (raw_->type == XML_ELEMENT_NODE) { ns = xmlSearchNs( raw_->doc, raw_, prefix.empty() ? 0 : detail::to_xml_chars(prefix.c_str()) ); } if (!prefix.empty() && ns == 0) { std::string what = "fail to create element " + qname + ": xmlns for prefix " + prefix + " not found"; throw bad_dom_operation(what); } // Create element under the xmlns. xmlNode* px = xmlNewDocNode( raw_->doc, ns, detail::to_xml_chars(name.c_str()), 0 ); if (px == 0) { std::string what = "fail to create libxml2 element node for " + name; throw internal_dom_error(what); } // Return the new element. return px; }
/** * 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; xmlNodePtr tables_node = NULL; GList *list, *l; 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; }
static int command_alloc(client_t *client) { xmlDocPtr doc = xmlNewDoc (XMLSTR("1.0")); xmlNodePtr rootnode = xmlNewDocNode(doc, NULL, XMLSTR("icestats"), NULL); avl_node *node; xmlDocSetRootElement(doc, rootnode); avl_tree_rlock (global.alloc_tree); node = avl_get_first (global.alloc_tree); while (node) { alloc_node *an = node->key; char value[25]; xmlNodePtr bnode = xmlNewChild (rootnode, NULL, XMLSTR("block"), NULL); xmlSetProp (bnode, XMLSTR("name"), XMLSTR(an->name)); snprintf (value, sizeof value, "%d", an->count); xmlNewChild (bnode, NULL, XMLSTR("count"), XMLSTR(value)); snprintf (value, sizeof value, "%d", an->allocated); xmlNewChild (bnode, NULL, XMLSTR("allocated"), XMLSTR(value)); node = avl_get_next (node); } avl_tree_unlock (global.alloc_tree); return admin_send_response (doc, client, RAW, "stats.xsl"); }
enum jal_status jal_create_base64_element( xmlDocPtr doc, const uint8_t *buffer, const size_t buf_len, const xmlChar *namespace_uri, const xmlChar *elm_name, xmlNodePtr *new_elem) { if (!doc || !buffer || (buf_len == 0) || !namespace_uri || !elm_name || !new_elem || *new_elem) { return JAL_E_INVAL; } char *base64_val = NULL; xmlChar *xml_base64_val = NULL; base64_val = jal_base64_enc(buffer, buf_len); if (!base64_val) { // this should never actually happen since the input is // non-zero in length. return JAL_E_INVAL; } xml_base64_val = (xmlChar *)base64_val; xmlNodePtr elm = xmlNewDocNode(doc, NULL, elm_name, NULL); xmlNsPtr ns = xmlNewNs(elm, namespace_uri, NULL); xmlSetNs(elm, ns); xmlNodeAddContent(elm, xml_base64_val); free(base64_val); *new_elem = elm; return JAL_OK; }
static int command_move_clients (client_t *client, source_t *source, int response) { const char *dest_source; xmlDocPtr doc; xmlNodePtr node; int parameters_passed = 0; char buf[255]; if((COMMAND_OPTIONAL(client, "destination", dest_source))) { parameters_passed = 1; } if (!parameters_passed) { doc = admin_build_sourcelist(source->mount); thread_mutex_unlock (&source->lock); return admin_send_response(doc, client, response, "moveclients.xsl"); } INFO2 ("source is \"%s\", destination is \"%s\"", source->mount, dest_source); doc = xmlNewDoc(XMLSTR("1.0")); node = xmlNewDocNode(doc, NULL, XMLSTR("iceresponse"), NULL); xmlDocSetRootElement(doc, node); source_set_fallback (source, dest_source); source->termination_count = source->listeners; source->flags |= SOURCE_LISTENERS_SYNC; snprintf (buf, sizeof(buf), "Clients moved from %s to %s", source->mount, dest_source); thread_mutex_unlock (&source->lock); xmlNewChild(node, NULL, XMLSTR("message"), XMLSTR(buf)); xmlNewChild(node, NULL, XMLSTR("return"), XMLSTR("1")); return admin_send_response (doc, client, response, "response.xsl"); }
static gboolean snippets_load_finished_lcb(gpointer data) { xmlDocPtr doc = (xmlDocPtr)data; xmlNodePtr cur=NULL; DEBUG_SIG("snippets_load_finished_lcb, priority=%d\n",G_PRIORITY_LOW); DEBUG_MSG("snippets_load_finished_lcb, doc=%p, starting to load xml data into treestore\n", doc); if (doc) { cur = xmlDocGetRootElement(doc); if (cur) { if (xmlStrEqual(cur->name, (const xmlChar *) "snippets")) { snippets_v.doc = doc; walk_tree(cur, NULL); snippets_rebuild_accelerators(); DEBUG_MSG("snippets_load_finished_lcb, finished walking tree\n"); return FALSE; } } xmlFreeDoc(doc); doc = NULL; } if (doc == NULL) { snippets_v.doc = xmlNewDoc((const xmlChar *)"1.0"); cur = xmlNewDocNode(snippets_v.doc,NULL, (const xmlChar *)"snippets",NULL); xmlDocSetRootElement(snippets_v.doc, cur); /* DEBUG_MSG("snippets_load_finished_lcb, loading from cmenu %p and %p\n",main_v->props.cmenu_insert, main_v->props.cmenu_replace); */ /* now check if there is a custom menu configuration. If there is one, parse it and build a xml tree */ /* if (snippets_convert_cmenu(cur)) { walk_tree(cur, NULL); }*/ } DEBUG_MSG("snippets_load_finished_lcb, finished empty tree\n"); return FALSE; }
int fserve_kill_client (client_t *client, const char *mount, int response) { int loop = 2, id; fbinfo finfo; xmlDocPtr doc; xmlNodePtr node; const char *idtext, *v = "0"; char buf[50]; finfo.flags = 0; finfo.mount = (char*)mount; finfo.limit = 0; finfo.fallback = NULL; idtext = httpp_get_query_param (client->parser, "id"); if (idtext == NULL) return client_send_400 (client, "missing parameter id"); id = atoi(idtext); doc = xmlNewDoc(XMLSTR("1.0")); node = xmlNewDocNode(doc, NULL, XMLSTR("iceresponse"), NULL); xmlDocSetRootElement(doc, node); snprintf (buf, sizeof(buf), "Client %d not found", id); avl_tree_rlock (fh_cache); while (1) { avl_node *node; fh_node *fh = find_fh (&finfo); if (fh) { thread_mutex_lock (&fh->lock); avl_tree_unlock (fh_cache); node = avl_get_first (fh->clients); while (node) { client_t *listener = (client_t *)node->key; if (listener->connection.id == id) { listener->connection.error = 1; snprintf (buf, sizeof(buf), "Client %d removed", id); v = "1"; loop = 0; break; } node = avl_get_next (node); } thread_mutex_unlock (&fh->lock); avl_tree_rlock (fh_cache); } if (loop == 0) break; loop--; if (loop == 1) finfo.flags = FS_FALLBACK; } avl_tree_unlock (fh_cache); xmlNewChild (node, NULL, XMLSTR("message"), XMLSTR(buf)); xmlNewChild (node, NULL, XMLSTR("return"), XMLSTR(v)); return admin_send_response (doc, client, response, "response.xsl"); }
/* =========== QE_SaveProject TTimo: whenever QE_SaveProject is called, prefs are updated and saved with the path to the project =========== */ qboolean QE_SaveProject( const char* filename ){ Sys_Printf( "Save project file '%s'\n", filename ); xmlNodePtr node; xmlDocPtr doc = xmlNewDoc( (xmlChar *)"1.0" ); // create DTD node xmlCreateIntSubset( doc, (xmlChar *)"project", NULL, (xmlChar *)"project.dtd" ); // create project node doc->children->next = xmlNewDocNode( doc, NULL, (xmlChar *)"project", NULL ); for ( epair_t* epair = g_qeglobals.d_project_entity->epairs; epair != NULL; epair = epair->next ) { node = xmlNewChild( doc->children->next, NULL, (xmlChar *)"key", NULL ); xmlSetProp( node, (xmlChar*)"name", (xmlChar*)epair->key ); xmlSetProp( node, (xmlChar*)"value", (xmlChar*)epair->value ); } CreateDirectoryPath( filename ); if ( xmlSaveFormatFile( filename, doc, 1 ) != -1 ) { xmlFreeDoc( doc ); Sys_Printf( "Setting current project in prefs to \"%s\"\n", filename ); g_PrefsDlg.m_strLastProject = filename; g_PrefsDlg.SavePrefs(); return TRUE; } else { xmlFreeDoc( doc ); Sys_FPrintf( SYS_ERR, "failed to save project file: \"%s\"\n", filename ); return FALSE; } }
xmlelf_t * xmlelf_create_info( elf_t * elf , char * name ) { xmlDocPtr doc; xmlelf_t * ret; if(!elf||!name) error_ret("null args",NULL); if(!(ret = calloc(1,sizeof(*ret)))) perror_die("calloc()",1); if(!(doc = xmlNewDoc("1.0"))){ free(ret); error_ret("can't get doc",NULL); } if(!(ret->root = xmlNewDocNode( doc ,NULL,"elf",NULL))){ xmlFreeDoc(doc); free(ret); error_ret("Can't root node",NULL); } doc->children = ret->root; ret->name = strdup(name); ret->doc = doc; xmlelf_set_elf( ret , elf ); return(ret); }
bool BayesianClassifier::Save(const char* filename) { FILE* file; xmlDocPtr document; xmlNodePtr rootNode; bool retCode = true; if ( !filename || !*filename ) { fprintf(stderr, "BayesianClassifier::Save - Invalid parameter\n"); return false; } file = fopen(filename, "w"); if ( !file ) { fprintf(stderr, "BayesianClassifier::Save - Failed opening %s\n", filename); return false; } document = xmlNewDoc(NULL); rootNode = xmlNewDocNode(document, NULL, (const xmlChar *)BAYESIAN_CLASSIFIER_STR, NULL); xmlDocSetRootElement(document, rootNode); retCode = Save(rootNode); xmlDocFormatDump(file, document, 1); fclose(file); xmlFreeDoc(document); return retCode; }
void CLogicStateMachine::write (xmlDocPtr doc) const { // Create the first node xmlNodePtr node = xmlNewDocNode (doc, NULL, (const xmlChar*)"STATE_MACHINE", NULL); xmlDocSetRootElement (doc, node); xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)_Name.c_str()); xmlSetProp (node, (const xmlChar*)"CurrentState", (const xmlChar*)_CurrentState.c_str()); for (std::map<std::string, CLogicVariable>::const_iterator vit = _Variables.begin(); vit != _Variables.end(); vit++) { (*vit).second.write(node); } for (std::map<std::string, CLogicCounter>::const_iterator cit = _Counters.begin(); cit != _Counters.end(); cit++) { (*cit).second.write(node); } for (std::map<std::string, CLogicCondition>::const_iterator c2it = _Conditions.begin(); c2it != _Conditions.end(); c2it++) { (*c2it).second.write(node); } for (std::map<std::string, CLogicState>::const_iterator sit = _States.begin(); sit != _States.end(); sit++) { (*sit).second.write(node); } }
/* * Public API */ Local::Heap::Heap (boost::shared_ptr<Ekiga::PresenceCore> _presence_core, boost::shared_ptr<Local::Cluster> _local_cluster): presence_core(_presence_core), local_cluster(_local_cluster), doc () { xmlNodePtr root; contacts_settings = boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (CONTACTS_SCHEMA)); std::string raw = contacts_settings->get_string (ROSTER_KEY); // Build the XML document representing the contacts list from the configuration if (!raw.empty ()) { doc = boost::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc); if ( !doc) doc = boost::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc); root = xmlDocGetRootElement (doc.get ()); if (root == NULL) { root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL); xmlDocSetRootElement (doc.get (), root); } for (xmlNodePtr child = root->children; child != NULL; child = child->next) if (child->type == XML_ELEMENT_NODE && child->name != NULL && xmlStrEqual (BAD_CAST ("entry"), child->name)) add (child); // Or create a new XML document } else { doc = boost::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc); root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL); xmlDocSetRootElement (doc.get (), root); { // add 500, 501 and 520 at ekiga.net in this case! std::set<std::string> groups; groups.insert (_("Services")); add (_("Echo test"), "sip:[email protected]", groups); add (_("Conference room"), "sip:[email protected]", groups); add (_("Call back test"), "sip:[email protected]", groups); } } }
static gchar * htmlview_render_item (itemPtr item, guint viewMode, gboolean summaryMode) { renderParamPtr params; gchar *output = NULL, *baseUrl = NULL; nodePtr node; xmlDocPtr doc; xmlNodePtr xmlNode; const gchar *text_direction = NULL; gboolean isMergedItemset; debug_enter ("htmlview_render_item"); /* don't use node from htmlView_priv as this would be wrong for folders and other merged item sets */ node = node_from_id (item->nodeId); isMergedItemset = (node != htmlView_priv.node); /* do the XML serialization */ doc = xmlNewDoc ("1.0"); xmlNode = xmlNewDocNode (doc, NULL, "itemset", NULL); xmlDocSetRootElement (doc, xmlNode); item_to_xml(item, xmlDocGetRootElement (doc)); text_direction = htmlview_get_item_direction (item); if (IS_FEED (node)) { xmlNodePtr feed; feed = xmlNewChild (xmlDocGetRootElement (doc), NULL, "feed", NULL); feed_to_xml (node, feed); } /* do the XSLT rendering */ params = render_parameter_new (); if (NULL != node_get_base_url (node)) { baseUrl = common_uri_escape (node_get_base_url (node)); render_parameter_add (params, "baseUrl='%s'", baseUrl); } render_parameter_add (params, "summary='%d'", summaryMode?1:0); render_parameter_add (params, "showFeedName='%d'", isMergedItemset?1:0); render_parameter_add (params, "single='%d'", (viewMode == ITEMVIEW_SINGLE_ITEM)?1:0); render_parameter_add (params, "txtDirection='%s'", text_direction); render_parameter_add (params, "appDirection='%s'", common_get_app_direction ()); output = render_xml (doc, "item", params); /* For debugging use: xmlSaveFormatFile("/tmp/test.xml", doc, 1); */ xmlFreeDoc (doc); g_free (baseUrl); debug_exit ("htmlview_render_item"); return output; }
/* * Public API */ Local::Heap::Heap (Ekiga::ServiceCore &_core): core (_core), doc () { xmlNodePtr root; gchar *c_raw = gm_conf_get_string (KEY); // Build the XML document representing the contacts list from the configuration if (c_raw != NULL) { const std::string raw = c_raw; doc = std::tr1::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc); if ( !doc) doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc); root = xmlDocGetRootElement (doc.get ()); if (root == NULL) { root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL); xmlDocSetRootElement (doc.get (), root); } for (xmlNodePtr child = root->children; child != NULL; child = child->next) if (child->type == XML_ELEMENT_NODE && child->name != NULL && xmlStrEqual (BAD_CAST ("entry"), child->name)) add (child); g_free (c_raw); // Or create a new XML document } else { doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc); root = xmlNewDocNode (doc.get (), NULL, BAD_CAST "list", NULL); xmlDocSetRootElement (doc.get (), root); { // add 500 and 501 at ekiga.net in this case! std::set<std::string> groups; groups.insert (_("Services")); add (_("Echo test"), "sip:[email protected]", groups); add (_("Conference room"), "sip:[email protected]", groups); } } }
void CSoundAnimation::save() { // File stream COFile file; vector<NLMISC::CSheetId> sounds; // Open the file if (!file.open(_Filename.c_str())) { throw NLMISC::Exception("Can't open the file for writing"); } // Create the XML stream COXml output; // Init if (output.init (&file, "1.0")) { xmlDocPtr xmlDoc = output.getDocument(); // Create the first node xmlNodePtr root = xmlNewDocNode (xmlDoc, NULL, (const xmlChar*)"SOUNDANIMATION", NULL); xmlDocSetRootElement (xmlDoc, root); vector<CSoundAnimMarker*>::iterator iter; for (iter = _Markers.begin(); iter != _Markers.end(); iter++) { CSoundAnimMarker* marker = (*iter); set<string>::iterator iter; char s[64]; smprintf(s, 64, "%f", marker->getTime()); xmlNodePtr markerNode = xmlNewChild (root, NULL, (const xmlChar*)"MARKER", NULL); xmlSetProp (markerNode, (const xmlChar*) "time", (const xmlChar*) s); marker->getSounds(sounds); vector<NLMISC::CSheetId>::iterator iter2; for (iter2 = sounds.begin(); iter2 != sounds.end(); iter2++) { xmlNodePtr soundNode = xmlNewChild ( markerNode, NULL, (const xmlChar*)"SOUND", NULL ); xmlSetProp (soundNode, (const xmlChar*)"name", (const xmlChar*)iter2->toString().c_str() /*CStringMapper::unmap(*iter2).c_str()*/); } sounds.clear(); } // Flush the stream, write all the output file output.flush (); } // Close the file file.close (); _Dirty = false; }
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; }