inline void savestatus() {
xmlNodePtr root = NULL;
xmlNodePtr node = NULL;
xmlChar* tmp = NULL;
if ((strlen(statname) > 0) && (status != NULL)) {
root = xmlDocGetRootElement(status);
if (root) {
xmlMutexLock(finishedMutex);
for (node = root->children; node; node = node->next) {
if (xmlStrcmp(node->name, "current") == 0) {
xmlMutexLock(pwdMutex);
tmp = xmlEncodeEntitiesReentrant(status, (const xmlChar*) &password);
xmlMutexUnlock(pwdMutex);
if (node->children) {
if (password[0] == '\0')
xmlNodeSetContent(node->children, getfirstpassword());
else
xmlNodeSetContent(node->children, tmp);
}
xmlFree(tmp);
} else if ((finished == 1) && (xmlStrcmp(node->name,"good_password") == 0)) {
tmp = xmlEncodeEntitiesReentrant(status, (const xmlChar*) &password_good);
if (node->children)
xmlNodeSetContent(node->children, tmp);
xmlFree(tmp);
}
}
xmlMutexUnlock(finishedMutex);
}
xmlSaveFormatFileEnc(statname, status, "UTF-8", 1);
}
return;
}
static void
write_xml_label (PartLabel *label, parseXmlContext *ctxt)
{
xmlNodePtr node_label;
gchar *str;
// Create a node for the property.
node_label = xmlNewChild (ctxt->node_labels, ctxt->ns, BAD_CAST "label", NULL);
if (!node_label) {
g_warning ("Failed during save of label %s.\n", label->name);
return;
}
// Store the name.
xmlNewChild (node_label, ctxt->ns, BAD_CAST "name",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST label->name));
// Store the value.
xmlNewChild (node_label, ctxt->ns, BAD_CAST "text",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST label->text));
str = g_strdup_printf ("(%g %g)", label->pos.x, label->pos.y);
xmlNewChild (node_label, ctxt->ns, BAD_CAST "position", BAD_CAST str);
g_free (str);
}
/* {{{ static void solr_serialize_arg_list_param_value(xmlNode *xml_params_node, solr_param_t *param) */
static void solr_serialize_arg_list_param_value(xmlNode *xml_params_node, solr_param_t *param)
{
xmlNode *xml_param_node = xmlNewChild(xml_params_node, NULL, (xmlChar *) "param", NULL);
solr_param_value_t *curr_value = param->head;
solr_serialize_xml_set_param_props(xml_param_node, param);
while(curr_value != NULL)
{
xmlChar *param_value_txt = xmlEncodeEntitiesReentrant(xml_params_node->doc, (xmlChar *) curr_value->contents.arg_list.value.str);
xmlChar *arg_value_txt = xmlEncodeEntitiesReentrant(xml_params_node->doc, (xmlChar *) curr_value->contents.arg_list.arg.str);
xmlNode *xml_param_value = xmlNewChild(xml_param_node, NULL, (xmlChar *) "param_value", param_value_txt);
xmlNewProp(xml_param_value, (xmlChar *) "argument", arg_value_txt);
xmlFree(param_value_txt);
xmlFree(arg_value_txt);
curr_value = curr_value->next; /* Go to the next value in the list */
}
}
// Create an XML subtree of doc equivalent to the given Schematic.
static xmlNodePtr
write_xml_schematic (parseXmlContext *ctxt, Schematic *sm, GError **error)
{
xmlNodePtr cur;
xmlNodePtr grid;
xmlNsPtr ogo;
gchar *str;
cur = xmlNewDocNode (ctxt->doc, ctxt->ns, BAD_CAST "schematic", NULL);
if (cur == NULL) {
printf ("%s:%d NULL that shall be not NULL!\n", __FILE__,
__LINE__);
return NULL;
}
if (ctxt->ns == NULL) {
ogo = xmlNewNs (cur,
BAD_CAST "http://www.dtek.chalmers.se/~d4hult/oregano/v1",
BAD_CAST "ogo");
xmlSetNs (cur,ogo);
ctxt->ns = ogo;
}
// General information about the Schematic.
str = g_strdup_printf ("%s", schematic_get_author (sm));
xmlNewChild (cur, ctxt->ns, BAD_CAST "author", xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST str));
g_free (str);
str = g_strdup_printf ("%s", schematic_get_title (sm));
xmlNewChild (cur, ctxt->ns, BAD_CAST "title", xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST str));
g_free (str);
str = g_strdup_printf ("%s", schematic_get_comments (sm));
xmlNewChild (cur, ctxt->ns, BAD_CAST "comments", xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST str));
g_free (str);
// Grid.
grid = xmlNewChild (cur, ctxt->ns, BAD_CAST "grid", NULL);
xmlNewChild (grid, ctxt->ns, BAD_CAST "visible", BAD_CAST "true");
xmlNewChild (grid, ctxt->ns, BAD_CAST "snap", BAD_CAST "true");
// Simulation settings.
write_xml_sim_settings (cur, ctxt, sm);
// Parts.
ctxt->node_parts = xmlNewChild (cur, ctxt->ns, BAD_CAST "parts", NULL);
schematic_parts_foreach (sm, (gpointer) write_xml_part, ctxt);
// Wires.
ctxt->node_wires = xmlNewChild (cur, ctxt->ns, BAD_CAST "wires", NULL);
schematic_wires_foreach (sm, (gpointer) write_xml_wire, ctxt);
// Text boxes.
ctxt->node_textboxes = xmlNewChild (cur, ctxt->ns, BAD_CAST "textboxes", NULL);
schematic_items_foreach (sm, (gpointer) write_xml_textbox, ctxt);
return cur;
}
void
cal_write_notes (GUI *appGUI)
{
xmlDocPtr doc;
xmlNodePtr main_node, node, note_node, dc_node;
xmlAttrPtr attr;
GtkTreeIter iter;
GSList *lnode;
struct note *a;
gchar *category, *color_str;
gint i;
xmlChar *escaped;
if ((appGUI->save_status & WRT_CALENDAR_NOTES) != 0) return;
appGUI->save_status |= WRT_CALENDAR_NOTES;
doc = xmlNewDoc ((const xmlChar *) "1.0");
attr = xmlNewDocProp (doc, (const xmlChar *) "encoding", (const xmlChar *) "utf-8");
main_node = xmlNewNode (NULL, (const xmlChar *) CALENDAR_NOTES_NAME);
xmlDocSetRootElement (doc, main_node);
node = xmlNewChild (main_node, NULL, (const xmlChar *) CALENDAR_DAY_CATEGORIES_NAME, (xmlChar *) NULL);
i = 0;
while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (appGUI->opt->calendar_category_store), &iter, NULL, i++)) {
gtk_tree_model_get (GTK_TREE_MODEL (appGUI->opt->calendar_category_store), &iter, 1, &color_str, 2, &category, -1);
escaped = xmlEncodeEntitiesReentrant(doc, (const xmlChar *) category);
dc_node = xmlNewChild (node, NULL, (const xmlChar *) "name", (xmlChar *) escaped);
g_free (category);
xmlFree (escaped);
escaped = xmlEncodeEntitiesReentrant(doc, (const xmlChar *) color_str);
xmlNewProp (dc_node, (const xmlChar *) "color", (xmlChar *) escaped);
g_free (color_str);
xmlFree (escaped);
}
for (i = 0, lnode = appGUI->cal->notes_list; lnode; lnode = lnode->next, i++) {
a = g_slist_nth_data (appGUI->cal->notes_list, i);
note_node = xmlNewChild (main_node, NULL, (const xmlChar *) "note", (xmlChar *) NULL);
utl_xml_put_uint ("date", a->date, note_node);
utl_xml_put_str ("color", a->color, note_node, doc);
utl_xml_put_str ("message", a->note, note_node, doc);
}
xmlSaveFormatFileEnc (prefs_get_config_filename (CALENDAR_NOTES_FILENAME, appGUI), doc, "utf-8", 1);
xmlFreeProp (attr);
xmlFreeDoc (doc);
appGUI->save_status &= ~WRT_CALENDAR_NOTES;
}
/*
* call-seq:
* value=(content)
*
* Set the value for this Attr to +content+
*/
static VALUE set_value(VALUE self, VALUE content)
{
xmlAttrPtr attr;
Data_Get_Struct(self, xmlAttr, attr);
if(attr->children) xmlFreeNodeList(attr->children);
attr->children = attr->last = NULL;
if(content) {
xmlChar *buffer;
xmlNode *tmp;
/* Encode our content */
buffer = xmlEncodeEntitiesReentrant(attr->doc, (unsigned char *)StringValuePtr(content));
attr->children = xmlStringGetNodeList(attr->doc, buffer);
attr->last = NULL;
tmp = attr->children;
/* Loop through the children */
for(tmp = attr->children; tmp; tmp = tmp->next) {
tmp->parent = (xmlNode *)attr;
tmp->doc = attr->doc;
if(tmp->next == NULL) attr->last = tmp;
}
/* Free up memory */
xmlFree(buffer);
}
return content;
}
static void
impl_save_contents_to_xml (RBPlaylistSource *source,
xmlNodePtr node)
{
RBStaticPlaylistSourcePrivate *priv = RB_STATIC_PLAYLIST_SOURCE_GET_PRIVATE (source);
GtkTreeIter iter;
xmlSetProp (node, RB_PLAYLIST_TYPE, RB_PLAYLIST_STATIC);
if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->base_model), &iter))
return;
do {
xmlNodePtr child_node = xmlNewChild (node, NULL, RB_PLAYLIST_LOCATION, NULL);
RhythmDBEntry *entry;
xmlChar *encoded;
const char *location;
gtk_tree_model_get (GTK_TREE_MODEL (priv->base_model), &iter, 0, &entry, -1);
location = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
encoded = xmlEncodeEntitiesReentrant (NULL, BAD_CAST location);
xmlNodeSetContent (child_node, encoded);
g_free (encoded);
rhythmdb_entry_unref (entry);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->base_model), &iter));
}
static xmlNodePtr
filter_input_xml_encode (EFilterElement *element)
{
EFilterInput *input = E_FILTER_INPUT (element);
xmlNodePtr value;
GList *link;
const gchar *type;
type = input->type ? input->type : "string";
value = xmlNewNode (NULL, (xmlChar *) "value");
xmlSetProp (value, (xmlChar *) "name", (xmlChar *) element->name);
xmlSetProp (value, (xmlChar *) "type", (xmlChar *) type);
for (link = input->values; link != NULL; link = g_list_next (link)) {
xmlChar *str = link->data;
xmlNodePtr cur;
cur = xmlNewChild (value, NULL, (xmlChar *) type, NULL);
str = xmlEncodeEntitiesReentrant (NULL, str);
xmlNodeSetContent (cur, str);
xmlFree (str);
}
return value;
}
void stats_get_xml(xmlDocPtr *doc, int show_hidden)
{
stats_event_t *event;
stats_event_t *queue;
xmlNodePtr node, srcnode;
source_xml_t *src_nodes = NULL;
source_xml_t *next;
queue = NULL;
_dump_stats_to_queue(&queue);
*doc = xmlNewDoc("1.0");
node = xmlNewDocNode(*doc, NULL, "icestats", NULL);
xmlDocSetRootElement(*doc, node);
event = _get_event_from_queue(&queue);
while (event)
{
if (event->hidden <= show_hidden)
{
xmlChar *name, *value;
name = xmlEncodeEntitiesReentrant (*doc, event->name);
value = xmlEncodeEntitiesReentrant (*doc, event->value);
srcnode = node;
if (event->source) {
srcnode = _find_xml_node(event->source, &src_nodes, node);
}
xmlNewChild(srcnode, NULL, name, value);
xmlFree (value);
xmlFree (name);
}
_free_event(event);
event = _get_event_from_queue(&queue);
}
while (src_nodes) {
next = src_nodes->next;
free(src_nodes->mount);
free(src_nodes);
src_nodes = next;
}
}
static void write_xml_property (Property *prop, parseXmlContext *ctxt)
{
xmlNodePtr node_property;
// Create a node for the property.
node_property = xmlNewChild (ctxt->node_props, ctxt->ns, BAD_CAST "property", NULL);
if (!node_property) {
g_warning ("Failed during save of property %s.\n", prop->name);
return;
}
// Store the name.
xmlNewChild (node_property, ctxt->ns, BAD_CAST "name",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST prop->name));
// Store the value.
xmlNewChild (node_property, ctxt->ns, BAD_CAST "value",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST prop->value));
}
void stats_listener_to_xml (client_t *listener, xmlNodePtr parent)
{
const char *useragent;
char buf[30];
xmlNodePtr node = xmlNewChild (parent, NULL, XMLSTR("listener"), NULL);
snprintf (buf, sizeof (buf), "%lu", listener->connection.id);
xmlSetProp (node, XMLSTR("id"), XMLSTR(buf));
xmlNewChild (node, NULL, XMLSTR("IP"), XMLSTR(listener->connection.ip));
useragent = httpp_getvar (listener->parser, "user-agent");
if (useragent && xmlCheckUTF8((unsigned char *)useragent))
{
xmlChar *str = xmlEncodeEntitiesReentrant (parent->doc, XMLSTR(useragent));
xmlNewChild (node, NULL, XMLSTR("UserAgent"), str);
xmlFree (str);
}
if ((listener->flags & (CLIENT_ACTIVE|CLIENT_IN_FSERVE)) == CLIENT_ACTIVE)
{
source_t *source = listener->shared_data;
snprintf (buf, sizeof (buf), "%"PRIu64, source->client->queue_pos - listener->queue_pos);
}
else
snprintf (buf, sizeof (buf), "0");
xmlNewChild (node, NULL, XMLSTR("lag"), XMLSTR(buf));
if (listener->worker)
{
snprintf (buf, sizeof (buf), "%lu",
(unsigned long)(listener->worker->current_time.tv_sec - listener->connection.con_time));
xmlNewChild (node, NULL, XMLSTR("Connected"), XMLSTR(buf));
}
if (listener->username)
{
xmlChar *str = xmlEncodeEntitiesReentrant (parent->doc, XMLSTR(listener->username));
xmlNewChild (node, NULL, XMLSTR("username"), str);
xmlFree (str);
}
}
/*
* call-seq:
* []=(property, value)
*
* Set the +property+ to +value+
*/
static VALUE set(VALUE self, VALUE property, VALUE value)
{
xmlNodePtr node;
Data_Get_Struct(self, xmlNode, node);
xmlChar *buffer = xmlEncodeEntitiesReentrant(node->doc,
(xmlChar *)StringValuePtr(value));
xmlSetProp(node, (xmlChar *)StringValuePtr(property), buffer);
xmlFree(buffer);
return value;
}
std::string
robust_xmlEscape (xmlDocPtr doc,
const std::string& value)
{
xmlChar* escaped = xmlEncodeEntitiesReentrant (doc,
BAD_CAST value.c_str ());
std::string result((const char*)escaped);
xmlFree (escaped);
return result;
}
HRESULT node_put_text(xmlnode *This, BSTR text)
{
xmlChar *str, *str2;
TRACE("(%p)->(%s)\n", This, debugstr_w(text));
str = xmlchar_from_wchar(text);
/* Escape the string. */
str2 = xmlEncodeEntitiesReentrant(This->node->doc, str);
heap_free(str);
xmlNodeSetContent(This->node, str2);
xmlFree(str2);
return S_OK;
}
static char *mangle_encoding(xmlNode *node)
{
char *str = xmlNodeGetContent(node), *enc;
if (!str)
return str;
enc = xmlEncodeEntitiesReentrant(node->doc, str);
free(str);
if (!enc || !strchr(enc, '&'))
return enc;
/* FIXME: add encodings for non-ASCII characters */
__mangle_encoding(enc, "&", "&;");
__mangle_encoding(enc, "<", ">;");
__mangle_encoding(enc, ">", "<;");
return enc;
}
static int __replace_string(struct sdtid *s, xmlNode *node,
const char *name, const char *value)
{
int ret;
for (node = node->children; node; node = node->next) {
ret = __replace_string(s, node, name, value);
if (ret != ERR_GENERAL)
return ret;
if (xmlnode_is_named(node, name)) {
xmlChar *input = xmlEncodeEntitiesReentrant(s->doc,
value);
if (!input)
return ERR_NO_MEMORY;
xmlNodeSetContent(node, input);
free(input);
return ERR_NONE;
}
}
return ERR_GENERAL;
}
/*!
* \brief Add string data to an attribute node.
* @param attr The attribute node.
* @param str The value to set.
* \ingroup DiagramXmlOut
*/
void
data_add_string(AttributeNode attr, const char *str, DiaContext *ctx)
{
xmlChar *escaped_str;
xmlChar *sharped_str;
if (str==NULL) {
(void)xmlNewChild(attr, NULL, (const xmlChar *)"string", (const xmlChar *)"##");
return;
}
escaped_str = xmlEncodeEntitiesReentrant(attr->doc, (xmlChar *) str);
sharped_str = (xmlChar *) g_strconcat("#", (char *) escaped_str, "#", NULL);
xmlFree(escaped_str);
(void)xmlNewChild(attr, NULL, (const xmlChar *)"string", (xmlChar *) sharped_str);
g_free(sharped_str);
}
static void
foreach_save_func (gpointer key,
gpointer value,
gpointer user_data)
{
struct save_data *sd = user_data;
xmlNodePtr new_node;
xmlChar *enc;
if (sd->type == E_XML_HASH_TYPE_OBJECT_UID) {
new_node = xmlNewNode (NULL, (xmlChar *)"object");
xmlNewProp (new_node, (xmlChar *)"uid", (const xmlChar *) key);
} else
new_node = xmlNewNode (NULL, (const xmlChar *) key);
enc = xmlEncodeEntitiesReentrant (sd->doc, value);
xmlNodeSetContent (new_node, enc);
xmlFree (enc);
xmlAddChild (sd->root, new_node);
}
xmlNodePtr
create_param_node (xmlDocPtr doc,
SoupSoapParam *param,
xmlNodePtr parent_node)
{
xmlNodePtr node = xmlNewChild (parent_node, NULL,
BAD_CAST soup_soap_param_get_name (param),
NULL);
SoupSoapParam *param_child;
if (SOUP_SOAP_IS_PARAM_GROUP (param))
{
GList *elements =
soup_soap_param_group_get_elements (SOUP_SOAP_PARAM_GROUP (param));
GList *curr_element = elements;
while (curr_element)
{
param_child = curr_element->data;
create_param_node (doc, param_child, node);
curr_element = g_list_next (curr_element);
}
}
else
{
xmlChar *content = xmlEncodeEntitiesReentrant (doc,
BAD_CAST soup_soap_param_get_value (param));
xmlNodeSetContent (node, content);
xmlFree (content);
}
return node;
}
/**
*dump一个节点到结果集
*@param nodePtr 当前的节点指针
*@param resultSet 返回的结果集,参见XmlApi::getXPathResultSet(multimap<string,string>& resultSet)方法的说明
*@return 成功返回true,否则返回false;
*/
bool gpl::xml::LibXml::getDumpNode(xmlNodePtr nodePtr, std::multimap<std::string, std::string>&resultSet)
{
if (nodePtr == NULL)
return false;
std::string name, value;
switch (nodePtr->type)
{
case XML_ELEMENT_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
value = getStringByXmlCharPtr(xmlNodeListGetString(doc, nodePtr->xmlChildrenNode, 1), 1);
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
value = "";
if (nodePtr->content != NULL)
{
if (isOnlyEntityName)
value = getStringByXmlCharPtr(nodePtr->content);
else
{
xmlChar *buffer;
buffer = xmlEncodeEntitiesReentrant(doc, nodePtr->content);
if (buffer != NULL)
{
value = getStringByXmlCharPtr(buffer, 1);
}
}
}
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
case XML_PI_NODE:
case XML_COMMENT_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
if (nodePtr->content != NULL)
{
value = getStringByXmlCharPtr(nodePtr->content);
}
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("document or html_document"), std::string("/")));
break;
case XML_ATTRIBUTE_NODE:
return getDumpAttribute(reinterpret_cast<xmlAttrPtr>(nodePtr), resultSet);
case XML_ENTITY_REF_NODE:
name = getStringByXmlCharPtr((xmlChar *)nodePtr->name);
value = "";
if (nodePtr->content != NULL)
{
if (isOnlyEntityName)
{
//value = getStringByXmlCharPtr(nodePtr->content);
xmlEntityPtr ent = xmlGetDocEntity(doc, nodePtr->name);
if (ent != NULL)
{
xmlChar *buffer;
/* an entity content can be any "well balanced chunk",
* i.e. the result of the content [43] production:
* http://www.w3.org/TR/REC-xml#NT-content.
* So it can contain text, CDATA section or nested
* entity reference nodes (among others).
* -> we recursive call xmlNodeListGetString()
* which handles these types */
buffer = xmlNodeListGetString(doc, ent->children, 1);
if (buffer != NULL)
{
value = getStringByXmlCharPtr(buffer, 1);
}
}
else
{
value = getStringByXmlCharPtr(nodePtr->content);
}
}
else
{
value = "&" + getStringByXmlCharPtr((xmlChar*)nodePtr->name) + ";";
}
}
resultSet.insert(std::multimap<std::string, std::string>::value_type(name, value));
break;
default:
;
}
return true;
}
static void
node_set_value(xmlNodePtr node, GConfValue* value)
{
const gchar* type;
gchar* value_str;
g_return_if_fail(node != NULL);
g_return_if_fail(value != NULL);
g_return_if_fail(value->type != GCONF_VALUE_INVALID);
type = gconf_value_type_to_string(value->type);
g_assert(type != NULL);
my_xmlSetProp(node, "type", type);
switch (value->type)
{
case GCONF_VALUE_INT:
case GCONF_VALUE_FLOAT:
case GCONF_VALUE_BOOL:
free_childs(node);
value_str = gconf_value_to_string(value);
my_xmlSetProp(node, "value", value_str);
g_free(value_str);
break;
case GCONF_VALUE_STRING:
{
xmlChar* encoded;
free_childs(node);
encoded = xmlEncodeEntitiesReentrant(node->doc,
(xmlChar *)gconf_value_get_string(value));
xmlNewChild(node, NULL, (xmlChar *)"stringvalue",
encoded);
xmlFree(encoded);
}
break;
case GCONF_VALUE_SCHEMA:
{
node_set_schema_value(node, value);
}
break;
case GCONF_VALUE_LIST:
{
GSList* list;
free_childs(node);
my_xmlSetProp(node, "ltype",
gconf_value_type_to_string(gconf_value_get_list_type(value)));
/* Add a new child for each node */
list = gconf_value_get_list(value);
while (list != NULL)
{
xmlNodePtr child;
/* this is O(1) because libxml saves the list tail */
child = xmlNewChild(node, NULL, (xmlChar *)"li", NULL);
g_return_if_fail(list->data != NULL);
node_set_value(child, (GConfValue*)list->data);
list = g_slist_next(list);
}
}
break;
case GCONF_VALUE_PAIR:
{
xmlNodePtr car, cdr;
free_childs(node);
car = xmlNewChild(node, NULL, (xmlChar *)"car", NULL);
cdr = xmlNewChild(node, NULL, (xmlChar *)"cdr", NULL);
g_return_if_fail(gconf_value_get_car(value) != NULL);
g_return_if_fail(gconf_value_get_cdr(value) != NULL);
node_set_value(car, gconf_value_get_car(value));
node_set_value(cdr, gconf_value_get_cdr(value));
}
break;
default:
g_assert_not_reached();
break;
}
}
int
peer_author_updatename(xmlDocPtr doc, const char *peerid, const char *name, const char *surname)
{
/* Check input peerid */
if (peerid==NULL) {
fprintf(stderr, "ERROR! Must supply a PeerID!\n");
return -1;
}
/* Check input affiliation */
char *name_new = str_trim(name);
char *surname_new = str_trim(surname);
if (name_new==NULL || surname_new==NULL) {
printf("Void name or surname, do nothing.\n");
return 0;
}
char *fullname_new = str_concat(name_new, " ", surname_new, NULL);
char *fullname_old = NULL;
char *ans = NULL;
xmlXPathObjectPtr result;
xmlNodePtr cur, child;
xmlChar *tmp;
/* Get the node */
char *xpath = str_concat("/db/authors[1]/author[peerid='", peerid, "']", NULL);
result = peer_getnodeset(doc, (xmlChar*)xpath);
if (result->nodesetval->nodeNr != 1) {
fprintf(stderr, "ERROR! Found %d authors with PeerID %s\n", result->nodesetval->nodeNr, peerid);
} else {
cur = result->nodesetval->nodeTab[0];
fullname_old = (char*)peer_getchildinfo(doc, cur, "fullname");
if (strlen(fullname_new)>strlen(fullname_old) && strcmp(fullname_new, fullname_old)!=0) {
printf("Update old name <%s> with new <%s>? (y/n) ", fullname_old, fullname_new);
str_getline(&ans, stdin);
if (ans[0]=='y' || ans[0]=='Y') {
/* Update name! */
child = cur->xmlChildrenNode;
while (child!=NULL) {
if ((!xmlStrcmp(child->name, (const xmlChar *)"name"))) {
tmp = xmlEncodeEntitiesReentrant(doc, (xmlChar*)name_new);
xmlNodeSetContent(child, tmp);
free(tmp); tmp=NULL;
} else if ((!xmlStrcmp(child->name, (const xmlChar *)"surname"))) {
tmp = xmlEncodeEntitiesReentrant(doc, (xmlChar*)surname_new);
xmlNodeSetContent(child, tmp);
free(tmp); tmp=NULL;
} else if ((!xmlStrcmp(child->name, (const xmlChar *)"fullname"))) {
tmp = xmlEncodeEntitiesReentrant(doc, (xmlChar*)fullname_new);
xmlNodeSetContent(child, tmp);
free(tmp); tmp=NULL;
}
child = child->next;
}
}
free(ans); ans=NULL;
}
free(fullname_old); fullname_old=NULL;
}
/* Free memory and exit */
free(xpath);
free(name_new);
free(surname_new);
free(fullname_new);
xmlXPathFreeObject(result);
return 0;
}
void on_connectdbok_clicked(GtkWidget *widget, gpointer user_data) {
gchar *host;
gchar *user;
gchar *password;
gchar *dbname;
gchar dbquery[200];
gchar dbstatus[1000];
int broken,found;
xmlNodePtr node;
host=gtk_entry_get_text((GtkEntry *)gnome_entry_gtk_entry(connectdb_host));
user=gtk_entry_get_text((GtkEntry *)gnome_entry_gtk_entry(connectdb_user));
password=gtk_entry_get_text(connectdb_password);
dbname=gtk_entry_get_text((GtkEntry *)gnome_entry_gtk_entry(connectdb_database));
broken=FALSE;
mysql=mysql_init(NULL);
if (!mysql_real_connect(mysql,host,user,password,NULL,0,NULL,0)) {
error_dialog("Could not connect to Database");
fprintf(stderr, "Failed to connect to database: Error: %s\n", mysql_error(mysql));
mysql_close(mysql);
mysql=NULL;
} else {
sprintf(dbquery,"use %s",dbname);
mysql_query(mysql,dbquery);
if (mysql_errno(mysql)!=0) {
switch (ok_cancel_dialog("The database does not exist.\nCreate a new one?")) {
case 0:
g_message("Creating new Database %s.\n",dbname);
sprintf(dbquery,"create database %s",dbname);
if (mysql_query(mysql,dbquery)!=0) {
fprintf(stderr, "Failed to create database: Error: %s\n", mysql_error(mysql));
}
sprintf(dbquery,"use %s",dbname);
if (mysql_query(mysql,dbquery)!=0) {
fprintf(stderr, "Failed to use database: Error: %s\n", mysql_error(mysql));
}
break;
case 1:
broken=TRUE;
break;
default:
broken=TRUE;
break;
}
}
if (broken==FALSE) {
sprintf(dbquery,"create table _TableNames (Name Text,TName Text,Comment Text)");
mysql_query(mysql,dbquery);
name_cache=g_hash_table_new(g_str_hash,g_str_equal);
tname_cache=g_hash_table_new(g_str_hash,g_str_equal);
sprintf(dbstatus,"Database: %s\nuser: %s\nhost: %s",dbname,user,host);
gtk_label_set_text(database_status_label,dbstatus);
// -------------------------------
found=FALSE;
node=global_configs_doc->children;
while (node) {
if (strcmp(node->name,"configurations")==0) {
node=node->children;
break;
}
node=node->next;
}
if (node) {
while (node) {
if (strcmp(node->name,"dbconfig")==0) {
if (strcmp(xmlGetProp(node,"dbname"),dbname)==0) {
found=TRUE;
db_global_configs_node=node;
break;
}
}
node=node->next;
}
}
if (!found) {
db_global_configs_node=xmlNewNode(NULL,"dbconfig");
xmlSetProp(db_global_configs_node,"dbname",dbname);
xmlAddChild(global_configs_doc->children,db_global_configs_node);
}
// ---------------------------------
found=FALSE;
node=local_configs_doc->children;
while (node) {
if (strcmp(node->name,"configurations")==0) {
node=node->children;
break;
}
node=node->next;
}
if (node) {
while (node) {
if (strcmp(node->name,"dbconfig")==0) {
if (strcmp(xmlGetProp(node,"dbname"),dbname)==0) {
found=TRUE;
db_local_configs_node=node;
break;
}
}
node=node->next;
}
}
if (!found) {
db_local_configs_node=xmlNewNode(NULL,"dbconfig");
xmlSetProp(db_local_configs_node,"dbname",xmlEncodeEntitiesReentrant(local_configs_doc,dbname));
xmlAddChild(local_configs_doc->children,db_local_configs_node);
} else {
gtk_widget_set_sensitive(GTK_WIDGET(connect_button),FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(disconnect_button),TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(add_category_button),TRUE);
}
// ---------------------------------
gnome_dialog_close(connectdb_dialog);
update_tablelist(mysql);
}
}
}
static void _write_nodes(GObject *object, xmlNodePtr node)
{
g_assert(object);
g_assert(node);
guint prop_n;
MidgardObject *mgdobject = (MidgardObject *)object;
MidgardReflectionProperty *mrp = NULL;
MidgardObjectClass *klass = NULL;
GParamSpec **pspec = g_object_class_list_properties(
G_OBJECT_GET_CLASS(G_OBJECT(object)), &prop_n);
if(MIDGARD_IS_OBJECT(object)) {
klass =
MIDGARD_OBJECT_GET_CLASS(object);
if(klass)
mrp = midgard_reflection_property_new(
MIDGARD_DBOBJECT_CLASS(klass));
}
GValue pval = {0, }, *lval;
GString *gstring;
gchar *strprop = NULL;
xmlChar *escaped;
guint i;
xmlNodePtr op_node = NULL;
const gchar *linktype;
MidgardCollector *mc;
guint _uint;
gint _int;
GObject *_object;
if(MIDGARD_IS_OBJECT(mgdobject)) {
gint object_action = -1;
if(MGD_OBJECT_GUID (mgdobject)) {
GString *_sql = g_string_new(" ");
g_string_append_printf(_sql, "guid = '%s' ",
MGD_OBJECT_GUID (mgdobject));
gchar *tmpstr = g_string_free(_sql, FALSE);
GValue *avalue =
midgard_core_query_get_field_value(
MGD_OBJECT_CNC (mgdobject),
"object_action",
"repligard",
(const gchar*)tmpstr);
if(avalue) {
MIDGARD_GET_UINT_FROM_VALUE(object_action, avalue);
g_value_unset(avalue);
g_free(avalue);
}
g_free(tmpstr);
}
gchar *_action;
if(object_action > -1) {
switch(object_action) {
case MGD_OBJECT_ACTION_CREATE:
_action = "created";
break;
case MGD_OBJECT_ACTION_UPDATE:
_action = "updated";
break;
case MGD_OBJECT_ACTION_DELETE:
_action = "deleted";
break;
case MGD_OBJECT_ACTION_PURGE:
_action = "purged";
break;
default:
_action = "none";
break;
}
xmlNewProp(node, BAD_CAST "action",
BAD_CAST _action);
}
}
for(i = 0; i < prop_n; i++) {
g_value_init(&pval,pspec[i]->value_type);
g_object_get_property(G_OBJECT(object),
pspec[i]->name, &pval);
if(g_str_equal("guid", pspec[i]->name)) {
/* Add guid attribute */
xmlNewProp(node, BAD_CAST "guid",
BAD_CAST MGD_OBJECT_GUID (object));
g_value_unset(&pval);
continue;
}
/* Object is not fetched from database. Skip references */
if(MGD_OBJECT_GUID (mgdobject) == NULL)
goto export_unchecked_property;
/* If property is a link we need to query guid
* which identifies link object. Only if property
* is not of guid or string type */
if(mrp){
if(midgard_reflection_property_is_link(mrp,
pspec[i]->name)){
lval = g_new0(GValue, 1);
switch(pspec[i]->value_type) {
case G_TYPE_UINT:
g_value_init(lval, G_TYPE_UINT);
_uint = g_value_get_uint(&pval);
if(!_uint){
g_value_unset(lval);
g_free(lval);
goto export_unchecked_property;
}
g_value_set_uint(lval, _uint);
break;
case G_TYPE_INT:
g_value_init(lval, G_TYPE_INT);
_int = g_value_get_int(&pval);
if(!_int){
g_value_unset(lval);
g_free(lval);
goto export_unchecked_property;
}
g_value_set_int(lval, _int);
break;
default:
g_free(lval);
goto export_unchecked_property;
}
linktype =
midgard_reflection_property_get_link_name(
mrp, pspec[i]->name);
if(linktype){
mc = midgard_collector_new(
MGD_OBJECT_CNC (mgdobject),
linktype,
"id",
lval);
midgard_collector_set_key_property(
mc,
"guid", NULL);
if(!midgard_collector_execute(mc)){
g_object_unref(mc);
g_value_unset(&pval);
continue;
}
gchar **linkguid =
midgard_collector_list_keys(mc);
if(linkguid){
if(linkguid[0])
strprop = g_strdup(linkguid[0]);
}
if(!strprop)
strprop = g_strdup("");
/* Create node */
escaped = xmlEncodeEntitiesReentrant(
NULL, (const xmlChar*)strprop);
xmlNewTextChild(node, NULL,
BAD_CAST pspec[i]->name,
BAD_CAST escaped);
g_free(linkguid);
g_free(strprop);
g_free(escaped);
g_object_unref(mc);
}
g_value_unset(&pval);
continue;
}
}
export_unchecked_property:
switch (G_TYPE_FUNDAMENTAL(pspec[i]->value_type)) {
case G_TYPE_STRING:
strprop = g_value_dup_string(&pval);
if(!strprop)
strprop = g_strdup("");
escaped = xmlEncodeEntitiesReentrant(
NULL, (const xmlChar*)strprop);
xmlNewTextChild(node, NULL,
BAD_CAST pspec[i]->name,
BAD_CAST escaped);
g_free(strprop);
g_free(escaped);
break;
case G_TYPE_INT:
gstring = g_string_new("");
g_string_append_printf(gstring,
"%d", g_value_get_int(&pval));
xmlNewChild(node, NULL,
BAD_CAST pspec[i]->name,
BAD_CAST (xmlChar *)gstring->str);
g_string_free (gstring, TRUE);
break;
case G_TYPE_UINT:
gstring = g_string_new("");
g_string_append_printf(gstring,
"%d", g_value_get_uint(&pval));
xmlNewChild(node, NULL,
BAD_CAST pspec[i]->name,
BAD_CAST (xmlChar *)gstring->str);
g_string_free (gstring, TRUE);
break;
case G_TYPE_FLOAT:
gstring = g_string_new("");
g_string_append_printf(gstring,
"%g", g_value_get_float(&pval));
xmlNewChild(node, NULL,
BAD_CAST pspec[i]->name,
BAD_CAST (xmlChar *)gstring->str);
g_string_free (gstring, TRUE);
break;
case G_TYPE_BOOLEAN:
if(g_value_get_boolean(&pval))
strprop = "1";
else
strprop = "0";
xmlNewChild(node, NULL,
BAD_CAST pspec[i]->name,
BAD_CAST (xmlChar *)strprop);
break;
case G_TYPE_OBJECT:
_object = g_value_get_object (&pval);
if (_object) {
op_node = xmlNewNode(NULL, BAD_CAST pspec[i]->name);
_write_nodes(_object, op_node);
xmlAddChild(node, op_node);
}
break;
default:
if (pspec[i]->value_type == MIDGARD_TYPE_TIMESTAMP) {
GValue strval = {0, };
g_value_init (&strval, G_TYPE_STRING);
g_value_transform (&pval, &strval);
xmlNewChild(node, NULL,
BAD_CAST pspec[i]->name,
BAD_CAST (xmlChar *)g_value_get_string (&strval));
g_value_unset (&strval);
} else {
g_warning ("midgard_replicator_serialize: unhandled %s property type (%s)",
pspec[i]->name, g_type_name (pspec[i]->value_type));
}
}
g_value_unset(&pval);
}
g_free(pspec);
if(mrp)
g_object_unref(mrp);
}
/* #############################################################################
*
* Description encode the XML entities in the given string
* Author Harry Brueckner
* Date 2005-07-08
* Arguments xmlChar* string - string to encode the entities
* Return xmlChar* encoded string
*/
xmlChar* xmlEncodeCommentEntities(xmlChar* string)
{
TRACE(99, "xmlEncodeCommentEntities()", NULL);
return xmlEncodeEntitiesReentrant(xmldoc, string);
}
static void
write_xml_part (Part *part, parseXmlContext *ctxt)
{
PartPriv *priv;
xmlNodePtr node_part;
gchar *str;
Coords pos;
priv = part->priv;
// Create a node for the part.
node_part = xmlNewChild (ctxt->node_parts, ctxt->ns, BAD_CAST "part", NULL);
if (!node_part) {
g_warning ("Failed during save of part %s.\n", priv->name);
return;
}
str = g_strdup_printf ("%d", priv->rotation);
xmlNewChild (node_part, ctxt->ns, BAD_CAST "rotation",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST str));
g_free (str);
if (priv->flip & ID_FLIP_HORIZ)
xmlNewChild (node_part, ctxt->ns, BAD_CAST "flip",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST "horizontal"));
if (priv->flip & ID_FLIP_VERT)
xmlNewChild (node_part, ctxt->ns, BAD_CAST "flip",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST "vertical"));
// Store the name.
xmlNewChild (node_part, ctxt->ns, BAD_CAST "name",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST priv->name));
// Store the name of the library the part resides in.
xmlNewChild (node_part, ctxt->ns, BAD_CAST "library",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST priv->library->name));
// Which symbol to use.
xmlNewChild (node_part, ctxt->ns, BAD_CAST "symbol",
xmlEncodeEntitiesReentrant (ctxt->doc, BAD_CAST priv->symbol_name));
// Position.
item_data_get_pos (ITEM_DATA (part), &pos);
str = g_strdup_printf ("(%g %g)", pos.x, pos.y);
xmlNewChild (node_part, ctxt->ns, BAD_CAST "position", BAD_CAST str);
g_free (str);
// Create a node for the properties.
ctxt->node_props = xmlNewChild (node_part, ctxt->ns, BAD_CAST "properties",
NULL);
if (!ctxt->node_props) {
g_warning ("Failed during save of part %s.\n", priv->name);
return;
}
else{
g_slist_foreach (priv->properties, (GFunc) write_xml_property,
ctxt);
}
// Create a node for the labels.
ctxt->node_labels = xmlNewChild (node_part, ctxt->ns, BAD_CAST "labels", NULL);
if (!ctxt->node_labels) {
g_warning ("Failed during save of part %s.\n", priv->name);
return;
}
else{
g_slist_foreach (priv->labels, (GFunc) write_xml_label, ctxt);
}
}
int
stonith__lha_metadata(const char *agent, int timeout, char **output)
{
int rc = 0;
char *buffer = NULL;
static const char *no_parameter_info = "<!-- no value -->";
Stonith *stonith_obj = NULL;
static gboolean need_init = TRUE;
static Stonith *(*st_new_fn) (const char *) = NULL;
static const char *(*st_info_fn) (Stonith *, int) = NULL;
static void (*st_del_fn) (Stonith *) = NULL;
static void (*st_log_fn) (Stonith *, PILLogFun) = NULL;
if (need_init) {
need_init = FALSE;
st_new_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
"stonith_new", FALSE);
st_del_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
"stonith_delete", FALSE);
st_log_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
"stonith_set_log", FALSE);
st_info_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
"stonith_get_info", FALSE);
}
if (lha_agents_lib && st_new_fn && st_del_fn && st_info_fn && st_log_fn) {
char *xml_meta_longdesc = NULL;
char *xml_meta_shortdesc = NULL;
char *meta_param = NULL;
char *meta_longdesc = NULL;
char *meta_shortdesc = NULL;
stonith_obj = (*st_new_fn) (agent);
if (stonith_obj) {
(*st_log_fn) (stonith_obj, (PILLogFun) & stonith_plugin);
meta_longdesc = strdup_null((*st_info_fn) (stonith_obj, ST_DEVICEDESCR));
if (meta_longdesc == NULL) {
crm_warn("no long description in %s's metadata.", agent);
meta_longdesc = strdup(no_parameter_info);
}
meta_shortdesc = strdup_null((*st_info_fn) (stonith_obj, ST_DEVICEID));
if (meta_shortdesc == NULL) {
crm_warn("no short description in %s's metadata.", agent);
meta_shortdesc = strdup(no_parameter_info);
}
meta_param = strdup_null((*st_info_fn) (stonith_obj, ST_CONF_XML));
if (meta_param == NULL) {
crm_warn("no list of parameters in %s's metadata.", agent);
meta_param = strdup(no_parameter_info);
}
(*st_del_fn) (stonith_obj);
} else {
errno = EINVAL;
crm_perror(LOG_ERR, "Agent %s not found", agent);
return -EINVAL;
}
xml_meta_longdesc =
(char *)xmlEncodeEntitiesReentrant(NULL, (const unsigned char *)meta_longdesc);
xml_meta_shortdesc =
(char *)xmlEncodeEntitiesReentrant(NULL, (const unsigned char *)meta_shortdesc);
buffer = crm_strdup_printf(META_TEMPLATE, agent, xml_meta_longdesc,
xml_meta_shortdesc, meta_param);
xmlFree(xml_meta_longdesc);
xmlFree(xml_meta_shortdesc);
free(meta_shortdesc);
free(meta_longdesc);
free(meta_param);
}
if (output) {
*output = buffer;
} else {
free(buffer);
}
return rc;
}
