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