Ejemplo n.º 1
0
/**
 * base_tool_output_result_to_string:
 * @res: a #ToolCommandResult
 * @format: a #ToolOutputFormat format specification
 * @stream: (allow-none): a stream which the returned string will be put to, or %NULL
 * @options: (allow-none): a #GdaSet containing options, or %NULL
 *
 * Converts @res to a string
 *
 * Returns: (transfer full): a new string
 */
gchar *
base_tool_output_result_to_string (ToolCommandResult *res, ToolOutputFormat format,
                                   FILE *stream, GdaSet *options)
{
    switch (res->type) {
    case BASE_TOOL_COMMAND_RESULT_DATA_MODEL:
        return base_tool_output_data_model_to_string (res->u.model, format, stream, options);

    case BASE_TOOL_COMMAND_RESULT_SET: {
        GSList *list;
        GString *string;
        xmlNodePtr node;
        xmlBufferPtr buffer;
        gchar *str;

        if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) {
            string = g_string_new ("");
            for (list = res->u.set->holders; list; list = list->next) {
                const GValue *value;
                gchar *tmp;
                const gchar *cstr;
                GdaHolder *h;
                h = GDA_HOLDER (list->data);

                cstr = gda_holder_get_id (h);
                value = gda_holder_get_value (h);
                if (!strcmp (cstr, "IMPACTED_ROWS")) {
                    g_string_append_printf (string, "%s: ",
                                            _("Number of rows impacted"));
                    tmp = gda_value_stringify (value);
                    g_string_append_printf (string, "%s", tmp);
                    g_free (tmp);
                }
                else if (!strcmp (cstr, "EXEC_DELAY")) {
                    g_string_append_printf (string, "%s: ",
                                            _("Execution delay"));
                    gdouble etime;
                    etime = g_value_get_double (value);
                    g_string_append_printf (string, "%.03f s", etime);
                }
                else {
                    tmp = g_markup_escape_text (cstr, -1);
                    g_string_append_printf (string, "%s: ", tmp);
                    g_free (tmp);

                    tmp = gda_value_stringify (value);
                    g_string_append_printf (string, "%s", tmp);
                    g_free (tmp);
                }
                g_string_append (string, "\n");
            }
            str = string->str;
            g_string_free (string, FALSE);
            return str;
        }
        else if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
            buffer = xmlBufferCreate ();
            node = xmlNewNode (NULL, BAD_CAST "parameters");
            for (list = res->u.set->holders; list; list = list->next) {
                const GValue *value;
                xmlNodePtr pnode, vnode;

                pnode = xmlNewNode (NULL, BAD_CAST "parameter");
                xmlAddChild (node, pnode);
                xmlSetProp (pnode, BAD_CAST "name",
                            BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
                value = gda_holder_get_value (GDA_HOLDER (list->data));
                vnode = gda_value_to_xml (value);
                xmlAddChild (pnode, vnode);
            }
            xmlNodeDump (buffer, NULL, node, 0, 1);
            str = g_strdup ((gchar *) xmlBufferContent (buffer));
            xmlBufferFree (buffer);
            xmlFreeNode (node);
            return str;
        }
        else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
            buffer = xmlBufferCreate ();
            node = xmlNewNode (NULL, BAD_CAST "ul");
            for (list = res->u.set->holders; list; list = list->next) {
                const GValue *value;
                xmlNodePtr pnode, vnode;

                pnode = xmlNewNode (NULL, BAD_CAST "li");
                xmlAddChild (node, pnode);
                xmlSetProp (pnode, BAD_CAST "name",
                            BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
                value = gda_holder_get_value (GDA_HOLDER (list->data));
                vnode = gda_value_to_xml (value);
                xmlAddChild (pnode, vnode);
            }
            xmlNodeDump (buffer, NULL, node, 0, 1);
            str = g_strdup ((gchar *) xmlBufferContent (buffer));
            xmlBufferFree (buffer);
            xmlFreeNode (node);
            return str;
        }
        else if (format & BASE_TOOL_OUTPUT_FORMAT_CSV) {
            string = g_string_new ("");
            for (list = res->u.set->holders; list; list = list->next) {
                const GValue *value;
                gchar *tmp;
                const gchar *cstr;
                GdaHolder *h;
                h = GDA_HOLDER (list->data);

                cstr = gda_holder_get_id (h);
                value = gda_holder_get_value (h);
                if (!strcmp (cstr, "IMPACTED_ROWS")) {
                    g_string_append_printf (string, "\"%s\",",
                                            _("Number of rows impacted"));
                    tmp = gda_value_stringify (value);
                    g_string_append_printf (string, "\"%s\"", tmp);
                    g_free (tmp);
                }
                else if (!strcmp (cstr, "EXEC_DELAY")) {
                    g_string_append_printf (string, "\"%s\",",
                                            _("Execution delay"));
                    gdouble etime;
                    etime = g_value_get_double (value);
                    g_string_append_printf (string, "\"%.03f s\"", etime);
                }
                else {
                    tmp = g_markup_escape_text (cstr, -1);
                    g_string_append_printf (string, "\"%s\",", tmp);
                    g_free (tmp);

                    tmp = gda_value_stringify (value);
                    g_string_append_printf (string, "\"%s\"", tmp);
                    g_free (tmp);
                }
                g_string_append (string, "\n");
            }
            str = string->str;
            g_string_free (string, FALSE);
            return str;
        }
        else {
            TO_IMPLEMENT;
            return NULL;
        }
    }

    case BASE_TOOL_COMMAND_RESULT_TREE: {
        GdaSet *options2, *merge = NULL;

        options2 = g_object_get_data ((GObject*) res->u.tree, "BASE_TOOL_OUTPUT_OPTIONS");
        if (options && options2) {
            merge = gda_set_copy (options2);
            gda_set_merge_with_set (merge, options);
        }
        gchar *tmp;
        tmp = tree_to_string (res->u.tree, format, stream, merge ? merge : (options ? options : options2));
        if (merge)
            g_object_unref (merge);
        return tmp;
    }

    case BASE_TOOL_COMMAND_RESULT_TXT: {
        xmlNodePtr node;
        xmlBufferPtr buffer;
        gchar *str;

        if ((format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) ||
                (format & BASE_TOOL_OUTPUT_FORMAT_CSV))
            return g_strdup (res->u.txt->str);
        else if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
            buffer = xmlBufferCreate ();
            node = xmlNewNode (NULL, BAD_CAST "txt");
            xmlNodeSetContent (node, BAD_CAST res->u.txt->str);
            xmlNodeDump (buffer, NULL, node, 0, 1);
            str = g_strdup ((gchar *) xmlBufferContent (buffer));
            xmlBufferFree (buffer);
            xmlFreeNode (node);
            return str;
        }
        else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
            buffer = xmlBufferCreate ();
            node = xmlNewNode (NULL, BAD_CAST "p");
            xmlNodeSetContent (node, BAD_CAST res->u.txt->str);
            xmlNodeDump (buffer, NULL, node, 0, 1);
            str = g_strdup ((gchar *) xmlBufferContent (buffer));
            xmlBufferFree (buffer);
            xmlFreeNode (node);
            return str;
        }
        else {
            TO_IMPLEMENT;
            return NULL;
        }
    }

    case BASE_TOOL_COMMAND_RESULT_EMPTY:
        return g_strdup ("");

    case BASE_TOOL_COMMAND_RESULT_MULTIPLE: {
        GSList *list;
        GString *string = NULL;
        gchar *str;

        for (list = res->u.multiple_results; list; list = list->next) {
            ToolCommandResult *tres = (ToolCommandResult*) list->data;
            gchar *tmp;

            tmp = base_tool_output_result_to_string (tres,
                    format & BASE_TOOL_OUTPUT_FORMAT_COLOR_TERM ? TRUE : FALSE,
                    stream, options);
            if (!string)
                string = g_string_new (tmp);
            else {
                g_string_append_c (string, '\n');
                g_string_append (string, tmp);
            }
            g_free (tmp);
        }
        if (string) {
            str = string->str;
            g_string_free (string, FALSE);
        }
        else
            str = g_strdup ("");
        return str;
    }

    case BASE_TOOL_COMMAND_RESULT_HELP: {
        if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
            xmlBufferPtr buffer;
            gchar *str;
            buffer = xmlBufferCreate ();
            xmlNodeDump (buffer, NULL, res->u.xml_node, 0, 1);
            str = g_strdup ((gchar *) xmlBufferContent (buffer));
            xmlBufferFree (buffer);
            return str;
        }
        else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
            TO_IMPLEMENT;
            return NULL;
        }
        else {
            gint width = -1;
            gboolean term_color;
            if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT)
                base_tool_input_get_size (&width, NULL);
            term_color = format & BASE_TOOL_OUTPUT_FORMAT_COLOR_TERM ? TRUE : FALSE;
            return base_tool_help_to_string (res, width, term_color);
        }
        break;
    }

    default:
        g_assert_not_reached ();
        return NULL;
    }
}
Ejemplo n.º 2
0
Archivo: admin.c Proyecto: krattai/AEBL
static void command_manageauth(client_t *client, source_t *source,
    int response)
{
    xmlDocPtr doc;
    xmlNodePtr node, srcnode, msgnode;
    const char *action = NULL;
    const char *username = NULL;
    char *message = NULL;
    int ret = AUTH_OK;
    ice_config_t *config = config_get_config ();
    mount_proxy *mountinfo = config_find_mount (config, source->mount);

    do
    {
        if (mountinfo == NULL || mountinfo->auth == NULL)
        {
            WARN1 ("manage auth request for %s but no facility available", source->mount);
            break;
        }
        COMMAND_OPTIONAL(client, "action", action);
        COMMAND_OPTIONAL (client, "username", username);

        if (action == NULL)
            action = "list";

        if (!strcmp(action, "add"))
        {
            const char *password = NULL;
            COMMAND_OPTIONAL (client, "password", password);

            if (username == NULL || password == NULL)
            {
                WARN1 ("manage auth request add for %s but no user/pass", source->mount);
                break;
            }
            ret = mountinfo->auth->adduser(mountinfo->auth, 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"))
        {
            if (username == NULL)
            {
                WARN1 ("manage auth request delete for %s but no username", source->mount);
                break;
            }
            ret = mountinfo->auth->deleteuser(mountinfo->auth, 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 (XMLSTR("1.0"));
        node = xmlNewDocNode(doc, NULL, XMLSTR("icestats"), NULL);
        srcnode = xmlNewChild(node, NULL, XMLSTR("source"), NULL);
        xmlSetProp(srcnode, XMLSTR("mount"), XMLSTR(source->mount));

        if (message) {
            msgnode = xmlNewChild(node, NULL, XMLSTR("iceresponse"), NULL);
            xmlNewChild(msgnode, NULL, XMLSTR("message"), XMLSTR(message));
        }

        xmlDocSetRootElement(doc, node);

        if (mountinfo && mountinfo->auth && mountinfo->auth->listuser)
            mountinfo->auth->listuser (mountinfo->auth, srcnode);

        config_release_config ();

        admin_send_response(doc, client, response, 
                MANAGEAUTH_TRANSFORMED_REQUEST);
        free (message);
        xmlFreeDoc(doc);
        return;
    } while (0);

    config_release_config ();
    client_send_400 (client, "missing parameter");
}
Ejemplo n.º 3
0
void XmlNode::property(std::string n, std::string v)
{
    ::cleanXml( n );
    ::cleanXml( v );
    xmlSetProp(node_, (xmlChar*) n.c_str(), (xmlChar*) v.c_str());
}
Ejemplo n.º 4
0
int DEFAULT_CC
send_sessions(int client)
{
	struct session_item* sess;
	xmlNodePtr node, node2, node3;
	xmlDocPtr doc;
	int count, i;
	xmlChar* version;
	xmlChar* encoding;
	xmlChar* s_node;
	xmlChar* s_node2;

	log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[send_sessions]: "
			"request for sessions list");

	lock_chain_acquire();
	sess = (struct session_item*)session_list_session(&count);
	lock_chain_release();

	log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[send_sessions]: "
			"%i count sessions",count);
	version = xmlCharStrdup("1.0");
	doc = xmlNewDoc(version);
	if (doc ==NULL)
	{
		log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[send_sessions]: "
				"Unable to create the document");
		return 1;
	}
	doc->encoding = xmlCharStrdup("UTF-8");
	s_node = xmlCharStrdup("response");
	node = xmlNewNode(NULL, s_node);
	s_node2 = xmlCharStrdup("sessions");
	node2 = xmlNewNode(NULL, s_node2);
	xmlAddChild(node, node2);
	char prop[128];

	for ( i=0 ; i<count ; i++)
	{
		g_sprintf(prop, "%i", sess[i].display);
		xmlChar* s_session = xmlCharStrdup("session");
		xmlChar* s_id = xmlCharStrdup("id");
		xmlChar* s_id_value = xmlCharStrdup(prop);
		xmlChar* s_username = xmlCharStrdup("username");
		xmlChar* s_username_value = xmlCharStrdup(sess[i].name);
		xmlChar* s_status = xmlCharStrdup("status");
		xmlChar* s_status_value = xmlCharStrdup(session_get_status_string(sess[i].status));

		node3 = xmlNewNode(NULL, s_session);
		xmlSetProp(node3, s_id, s_id_value );
		xmlSetProp(node3, s_username,	s_username_value);
		xmlSetProp(node3, s_status, s_status_value );
		xmlAddChild(node2, node3);
		xmlFree(s_session);
		xmlFree(s_id);
		xmlFree(s_id_value);
		xmlFree(s_username);
		xmlFree(s_username_value);
		xmlFree(s_status);
		xmlFree(s_status_value);
	}
	xmlAddChild(node, node2);
	xmlDocSetRootElement(doc, node);
	xml_send_info(client, doc);

	xmlFree(version);
	xmlFree(s_node);
	xmlFree(s_node2);
	g_free(sess);
	xmlFreeDoc(doc);
	return 0;
}
Ejemplo n.º 5
0
int DEFAULT_CC
send_logoff(int client, int session_id)
{
	struct session_item* sess;
	xmlNodePtr node, node2;
	xmlDocPtr doc;
	xmlChar* version;
	xmlChar* response;
	xmlChar* session;
	xmlChar* username;
	xmlChar* username_value;
	xmlChar* id;
	xmlChar* id_value;
	xmlChar* status;
	xmlChar* status_value;


	char prop[128];
	int display;

	if (session_id == 0) {
		log_message(&(g_cfg->log), LOG_LEVEL_WARNING, "sesman[send_logoff]: "
				"%i is not a valid session id", session_id);
		return 1;
	}

	log_message(&(g_cfg->log), LOG_LEVEL_DEBUG, "sesman[send_logoff]: "
			"request session %i logoff", session_id);

	lock_chain_acquire();
	sess = session_get_by_display(session_id);
	lock_chain_release();

	if( sess == NULL)
	{
		log_message(&(g_cfg->log), LOG_LEVEL_DEBUG, "sesman[send_logoff]: "
				"The session %i did not exist", session_id);
		xml_send_error(client, "the session id of the request did not exist");
		return 1;
	}

	session_update_status_by_user(sess->name, SESMAN_SESSION_STATUS_TO_DESTROY);
	version = xmlCharStrdup("1.0");
	doc = xmlNewDoc(version);
	if (doc == NULL)
	{
		log_message(&(g_cfg->log), LOG_LEVEL_DEBUG, "sesman[send_logoff]: "
				"Unable to create the document");
		g_free(sess);
		xmlFree(version);
		xmlFreeDoc(doc);
		return 1;
	}
	doc->encoding = xmlCharStrdup("UTF-8");
	response = xmlCharStrdup("response");
	session = xmlCharStrdup("session");
	node = xmlNewNode(NULL, response);
	node2 = xmlNewNode(NULL, session);
	sprintf(prop, "%i", display);

	id = xmlCharStrdup("id");
	id_value = xmlCharStrdup(prop);
	username = xmlCharStrdup("username");
	username_value = xmlCharStrdup(sess->name);
	status = xmlCharStrdup("status");
	status_value = xmlCharStrdup("CLOSED");
	xmlSetProp(node2, id, id_value);
	xmlSetProp(node2, username, username_value);
	xmlSetProp(node2, status, status_value);
	xmlAddChild(node, node2);
	xmlDocSetRootElement(doc, node);
	xml_send_info(client, doc);

	xmlFreeDoc(doc);
	xmlFree(version);
	xmlFree(response);
	xmlFree(session);
	xmlFree(username);
	xmlFree(username_value);
	xmlFree(id);
	xmlFree(id_value);
	xmlFree(status);
	xmlFree(status_value);
	g_free(sess);
	return 0;
}
Ejemplo n.º 6
0
void XmlNodo::setPropiedad(const std::string& nombre, const std::string& valor) {
	xmlSetProp(nodo, (const xmlChar*) nombre.c_str(), (const xmlChar*) valor.c_str());
}
Ejemplo n.º 7
0
static xmlNodePtr
invoice_dom_tree_create (GncInvoice* invoice)
{
    xmlNodePtr ret;
    Timespec ts;
    Transaction* txn;
    GNCLot* lot;
    Account* acc;
    GncBillTerm* term;
    GncOwner* billto;
    gnc_numeric amt;

    ret = xmlNewNode (NULL, BAD_CAST gnc_invoice_string);
    xmlSetProp (ret, BAD_CAST "version", BAD_CAST invoice_version_string);

    xmlAddChild (ret, guid_to_dom_tree (invoice_guid_string,
                                        qof_instance_get_guid (QOF_INSTANCE (invoice))));

    xmlAddChild (ret, text_to_dom_tree (invoice_id_string,
                                        gncInvoiceGetID (invoice)));

    xmlAddChild (ret, gnc_owner_to_dom_tree (invoice_owner_string,
                                             gncInvoiceGetOwner (invoice)));

    ts = gncInvoiceGetDateOpened (invoice);
    xmlAddChild (ret, timespec_to_dom_tree (invoice_opened_string, &ts));

    maybe_add_timespec (ret, invoice_posted_string,
                        gncInvoiceGetDatePosted (invoice));

    term = gncInvoiceGetTerms (invoice);
    if (term)
        xmlAddChild (ret, guid_to_dom_tree (invoice_terms_string,
                                            qof_instance_get_guid (QOF_INSTANCE (term))));

    maybe_add_string (ret, invoice_billing_id_string,
                      gncInvoiceGetBillingID (invoice));
    maybe_add_string (ret, invoice_notes_string, gncInvoiceGetNotes (invoice));

    xmlAddChild (ret, int_to_dom_tree (invoice_active_string,
                                       gncInvoiceGetActive (invoice)));

    txn = gncInvoiceGetPostedTxn (invoice);
    if (txn)
        xmlAddChild (ret, guid_to_dom_tree (invoice_posttxn_string,
                                            xaccTransGetGUID (txn)));

    lot = gncInvoiceGetPostedLot (invoice);
    if (lot)
        xmlAddChild (ret, guid_to_dom_tree (invoice_postlot_string,
                                            gnc_lot_get_guid (lot)));

    acc = gncInvoiceGetPostedAcc (invoice);
    if (acc)
        xmlAddChild (ret, guid_to_dom_tree (invoice_postacc_string,
                                            qof_instance_get_guid (QOF_INSTANCE (acc))));

    xmlAddChild
    (ret,
     commodity_ref_to_dom_tree (invoice_currency_string,
                                gncInvoiceGetCurrency (invoice)));

    billto = gncInvoiceGetBillTo (invoice);
    if (billto && billto->owner.undefined != NULL)
        xmlAddChild (ret, gnc_owner_to_dom_tree (invoice_billto_string, billto));

    amt = gncInvoiceGetToChargeAmount (invoice);
    if (! gnc_numeric_zero_p (amt))
        xmlAddChild (ret, gnc_numeric_to_dom_tree (invoice_tochargeamt_string, &amt));

    /* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
    xmlAddChild (ret, qof_instance_slots_to_dom_tree (invoice_slots_string,
                                                      QOF_INSTANCE (invoice)));
    return ret;
}
Ejemplo n.º 8
0
/*
 * build_mgmt_response -- sets an XML doc with a root and calls a porper
 *	    routine based on the request.  If the called routine constructed
 *	    the response doc with the result element, this routine fills up
 *	    response buffer with raw XML doc.
 *
 * reponse: ptr to response buffer
 * req: request to be processed.
 * size: ptr to the response doc buffer
 */
static int
build_mgmt_response(xmlChar **response, request_t req, int *size)
{

	int ret;
	xmlDocPtr	doc;
	xmlNodePtr	root;
	xmlXPathContextPtr ctext = NULL;
	xmlChar expr[ISNS_MAX_LABEL_LEN + 13];
	xmlXPathObjectPtr xpath_obj = NULL;

	isnslog(LOG_DEBUG, "build_mgmt_response", "entered");

	doc = xmlNewDoc((uchar_t *)"1.0");
	root = xmlNewNode(NULL, (xmlChar *)ISNSRESPONSE);
	(void) xmlDocSetRootElement(doc, root);
	if (xmlSetProp(root, (xmlChar *)XMLNSATTR, (xmlChar *)XMLNSATTRVAL) ==
	    NULL) {
	    return (ERR_XML_SETPROP_FAILED);
	}

	switch (req.op_info.op) {
	    case get_op:
		switch (req.op_info.obj) {
		    case Node:
			ret = get_node_op(&req, doc);
			break;
		    case DiscoveryDomain:
			ret = get_dd_op(&req, doc);
			break;
		    case DiscoveryDomainSet:
			ret = get_ddset_op(&req, doc);
			break;
		    case ServerConfig:
			ret = get_serverconfig_op(doc);
			break;
		    default:
			ret = ERR_INVALID_MGMT_REQUEST;
		}
		break;
	    case enumerate_op:
		isnslog(LOG_DEBUG, "build_mgmt_response", "enumerate_op");
		switch (req.op_info.obj) {
		    case Node:
			ret = enumerate_node_op(doc);
			break;
		    case DiscoveryDomain:
			ret = enumerate_dd_op(doc);
			break;
		    case DiscoveryDomainSet:
			ret = enumerate_ddset_op(doc);
			break;
		    default:
			ret = ERR_INVALID_MGMT_REQUEST;
		}
		break;
	    case getAssociated_op:
		switch (req.op_info.obj) {
		    case DiscoveryDomainMember:
			if (req.assoc_req == container_to_member) {
			    ret = getAssociated_dd_to_node_op(&req, doc);
			} else {
			    ret = getAssociated_node_to_dd_op(&req, doc);
			}
			break;
		    case DiscoveryDomainSetMember:
			if (req.assoc_req == container_to_member) {
			    ret = getAssociated_ddset_to_dd_op(&req, doc);
			} else {
			    ret = getAssociated_dd_to_ddset_op(&req, doc);
			}
			break;
		    default:
			ret = ERR_INVALID_MGMT_REQUEST;
		}
		break;
	    case createModify_op:
		switch (req.op_info.obj) {
		    case DiscoveryDomain:
		    case DiscoveryDomainSet:
			ret = createModify_dd_ddset_op(&req, doc);
			break;
		    case DiscoveryDomainMember:
		    case DiscoveryDomainSetMember:
			ret = create_ddmember_ddsetmember_op(&req, doc,
			    req.op_info.obj);
			break;
		    default:
			ret = ERR_INVALID_MGMT_REQUEST;
		}
		break;
	    case delete_op:
		switch (req.op_info.obj) {
		    case DiscoveryDomainMember:
		    case DiscoveryDomainSetMember:
			ret = delete_ddmember_ddsetmember_op(&req, doc,
			    req.op_info.obj);
			break;
		    case DiscoveryDomain:
		    case DiscoveryDomainSet:
			ret = delete_dd_ddset_op(&req, doc, req.op_info.obj);
			break;
		    default:
			ret = ERR_INVALID_MGMT_REQUEST;
		}
		break;
	    default:
		ret = ERR_INVALID_MGMT_REQUEST;
	}

	/*
	 * if failed check to see the doc contains the result element.
	 * if not, the response is set with only an error code.
	 */
	if (ret != ISNS_RSP_SUCCESSFUL) {
	    ctext = xmlXPathNewContext(doc);
	    if (ctext != NULL) {
		(void) xmlStrPrintf(expr, ISNS_MAX_LABEL_LEN + 13,
		    XMLSTRING_CAST "%s\"%s\"]", "//*[name()=", RESULT);
		xpath_obj = xmlXPathEvalExpression(expr, ctext);
		if ((xpath_obj == NULL) || (xpath_obj->nodesetval == NULL) ||
		    (xpath_obj->nodesetval->nodeNr <= 0) ||
		    (xpath_obj->nodesetval->nodeTab == NULL)) {
		    isnslog(LOG_DEBUG,
			"build_mgmt_response",
			"returning repsonse only with error code %d\n", ret);
			*response = malloc(sizeof (ret));
			if (*response) **response = ret;
			*size = sizeof (ret);
		} else {
		    xmlDocDumpMemory(doc, response, size);
		}
	    } else {
		/* can't verify the xml doc. dump return the doc anyway. */
		xmlDocDumpMemory(doc, response, size);
	    }
	} else {
	    xmlDocDumpMemory(doc, response, size);
	}

	if (xpath_obj) xmlXPathFreeObject(xpath_obj);
	if (ctext) xmlXPathFreeContext(ctext);
	if (doc) xmlFreeDoc(doc);
	return (ret);
}
Ejemplo n.º 9
0
void loadThesaurus(CIndexer *indexer)
{
  CConnbas_dbox *connbas = indexer->connbas;
  time_t struct_moddate, thesaurus_moddate, cterms_moddate;

  // ----------------------- load structure and thesaurus
  char *xmlstruct;
  char **pxmlstruct = NULL;
  unsigned long  xmlstruct_length;

  char *xmlthesaurus;
  char **pxmlthesaurus = NULL;
  unsigned long  xmlthesaurus_length;

  char *xmlcterms;
  char **pxmlcterms = NULL;
  unsigned long  xmlcterms_length;

  bool struct_changed, thesaurus_changed, cterms_changed;

  std::string cstr;

  char strbuff[1000];

    // read the 3 moddates
	connbas->selectPref_moddates(&struct_moddate, &thesaurus_moddate, &cterms_moddate);

	// what has changed
	struct_changed    = indexer->firstLoad || (struct_moddate    > indexer->current_struct_moddate);
	thesaurus_changed = indexer->firstLoad || (thesaurus_moddate > indexer->current_thesaurus_moddate);
	cterms_changed    = indexer->firstLoad || (cterms_moddate    > indexer->current_cterms_moddate);

	indexer->firstLoad = false;

	if(!struct_changed && !thesaurus_changed && !cterms_changed)
	{
		// nothing changed in the prefs
		return;
	}

	// fix "scout" : when cterms change, links from structure may be corrupted
	if(cterms_changed || thesaurus_changed)
	{
		struct_changed = true;
	}

	if(struct_changed)
	{
		// the structure changed : reload
		pxmlstruct    = &xmlstruct;
	}
	if(thesaurus_changed)
	{
		// the thesaurus changed
		pxmlthesaurus = &xmlthesaurus;
	}
	if(cterms_changed)
	{
		// the cterms changed
		pxmlcterms    = &xmlcterms;
	}

	// read useful fields
	if(connbas->selectPrefs(pxmlstruct, &xmlstruct_length, pxmlthesaurus, &xmlthesaurus_length, pxmlcterms, &xmlcterms_length) != 0)
	{
		// erreur sql
		return;
	}


	// ============================ load thesaurus
	if(thesaurus_changed)
	{
		if(indexer->DocThesaurus)
		{
			xmlFreeDoc(indexer->DocThesaurus);
			indexer->DocThesaurus = NULL;
		}

		if(indexer->XPathCtx_thesaurus)
		{
			xmlXPathFreeContext(indexer->XPathCtx_thesaurus);
			indexer->XPathCtx_thesaurus = NULL;
		}

		// we have the thesaurus, load in libxml
		indexer->DocThesaurus = xmlParseMemory(xmlthesaurus, xmlthesaurus_length);
		if(indexer->DocThesaurus != NULL)
		{
			// Create xpath evaluation context
			indexer->XPathCtx_thesaurus = xmlXPathNewContext(indexer->DocThesaurus);
			if(indexer->XPathCtx_thesaurus != NULL)
			{
			}
		}
		zSyslog._log(CSyslog::LOGL_THESAURUS, CSyslog::LOGC_THESAURUS, "#%ld : thesaurus loaded", connbas->sbas_id);
	}


	// ============================ load cterms
	if(cterms_changed)
	{
		if(indexer->tStructField)
		{
			delete [] (indexer->tStructField);
			indexer->tStructField = NULL;
		}

		if(indexer->DocCterms)
		{
			xmlFreeDoc(indexer->DocCterms);
			indexer->DocCterms = NULL;
		}

		if(indexer->XPathCtx_cterms)
		{
			xmlXPathFreeContext(indexer->XPathCtx_cterms);
			indexer->XPathCtx_cterms = NULL;
		}

		if(indexer->XPathCtx_deleted)
		{
			xmlXPathFreeContext(indexer->XPathCtx_deleted);
			indexer->XPathCtx_deleted = NULL;
		}
		indexer->xmlNodePtr_deleted = NULL;

		// we have the cterms, load in libxml
		indexer->DocCterms = xmlParseMemory(xmlcterms, xmlcterms_length);
		if(indexer->DocCterms != NULL)
		{
			// Create xpath evaluation context
			indexer->XPathCtx_cterms = xmlXPathNewContext(indexer->DocCterms);
			if(indexer->XPathCtx_cterms != NULL)
			{

				xmlXPathObjectPtr  xpathObj_cterms = NULL;

				xpathObj_cterms = xmlXPathEvalExpression((const xmlChar*)("/cterms/te[@delbranch='1']"), indexer->XPathCtx_cterms);
				if(xpathObj_cterms)
				{
					if(xpathObj_cterms->nodesetval)
					{
						xmlNodeSetPtr nodes_cterms = xpathObj_cterms->nodesetval;

						if(nodes_cterms->nodeNr > 0)
						{
							xmlNodePtr node_cterms = nodes_cterms->nodeTab[0];
							indexer->XPathCtx_deleted = xmlXPathNewContext((xmlDocPtr)node_cterms);

							// in the indexer, we keep the node to the deleted
							indexer->xmlNodePtr_deleted = nodes_cterms->nodeTab[0];
						}
					}
					xmlXPathFreeObject(xpathObj_cterms);
				}

			}
		}
		indexer->ctermsChanged = false;

		zSyslog._log(CSyslog::LOGL_THESAURUS, CSyslog::LOGC_THESAURUS, "#%ld : cterms loaded", connbas->sbas_id);
	}


	// ============================ load structure
	if(struct_changed)
	{
		xmlDocPtr          doc_struct;
		xmlXPathContextPtr xpathCtx_struct;
		xmlXPathObjectPtr  xpathObj_struct;

		if(indexer->tStructField)
		{
			delete [] (indexer->tStructField);
			indexer->tStructField = NULL;
		}

		// load in libxml
		doc_struct = xmlParseMemory(xmlstruct, xmlstruct_length);
		if(doc_struct != NULL)
		{
			// Create xpath evaluation context
			xpathCtx_struct = xmlXPathNewContext(doc_struct);
			if(xpathCtx_struct != NULL)
			{
				// ----- search every fields of the structure
				// Evaluate xpath expression
				xpathObj_struct = xmlXPathEvalExpression((const xmlChar*)"/record/description/*", xpathCtx_struct);
				if(xpathObj_struct != NULL)
				{
					if(xpathObj_struct->nodesetval)
					{
						xmlNodeSetPtr nodes_struct = xpathObj_struct->nodesetval;

						indexer->nStructFields = nodes_struct->nodeNr;
						if(indexer->nStructFields > 0)
						{
							// allocate a TABLE of fields
							indexer->tStructField = new CStructField[indexer->nStructFields];
						}

						// ---- scan every nodes of the result on struct
						cstr = "/-------------------------------- Loading structure  -----\n";

						for(int i=0; i<indexer->nStructFields; i++)
						{
							xmlNodePtr node_struct = nodes_struct->nodeTab[i];

							cstr += "|  Field '"+ std::string((const char *)(node_struct->name)) +"'";

							// ---- get attribute 'type' if it exists
							indexer->tStructField[i].type = CStructField::TYPE_NONE;			// default
							xmlChar *type = (xmlChar *)"";
							if( (type = xmlGetProp(node_struct, (const xmlChar *)"type")) )
							{
								if(!isWhite(type))
								{
									if(strcmp((const char *)type, "text")==0)
										indexer->tStructField[i].type = CStructField::TYPE_TEXT;	// <... type="text"

									else if(strcmp((const char *)type, "number")==0)
										indexer->tStructField[i].type = CStructField::TYPE_INT;		// <... type="number"

									else if(strcmp((const char *)type, "float")==0)
										indexer->tStructField[i].type = CStructField::TYPE_FLOAT;	// <... type="float"

									else if(strcmp((const char *)type, "date")==0)
										indexer->tStructField[i].type = CStructField::TYPE_DATE;	// <... type="date"
								}
								snprintf(strbuff, 1000, "{ type='%s' (%d) }", type, indexer->tStructField[i].type);
								cstr += strbuff;
								xmlFree(type);
							}
							else
							{
								snprintf(strbuff, 1000, "{ type='' (%d) }", indexer->tStructField[i].type);
								cstr += strbuff;
							}
							// ---- get attribute 'index' if it exists
							indexer->tStructField[i].index = true;			// default
							xmlChar *index;
							if( (index = xmlGetProp(node_struct, (const xmlChar *)"index")) )
							{
								if(!isWhite(index))
								{
									if( isno((const char *)index) )
										indexer->tStructField[i].index = false;

								}
								xmlFree(index);
							}
							snprintf(strbuff, 1000, " { index=%d }", indexer->tStructField[i].index );
							cstr += strbuff;

							// ---- get attribute 'business' if it exists
							indexer->tStructField[i].business = false;		// default if NO attribute
							xmlChar *business;
							if( (business = xmlGetProp(node_struct, (const xmlChar *)"business")) )
							{
								indexer->tStructField[i].business = true;		// default if attribute exists
								if(!isWhite(business))
								{
									if( isno((const char *)business) )
										indexer->tStructField[i].business = false;

								}
								xmlFree(business);
							}
							snprintf(strbuff, 1000, " { business=%d }", indexer->tStructField[i].business );
							cstr += strbuff;


							// ---- get attribute 'candidates' if it exists
							indexer->tStructField[i].candidatesStrings
								= indexer->tStructField[i].candidatesDates
								= indexer->tStructField[i].candidatesIntegers
								= indexer->tStructField[i].candidatesFirstDigit
								= indexer->tStructField[i].candidatesMultiDigits
								= true;											// default if NO attribute

							xmlChar *candidates;
							if( (candidates = xmlGetProp(node_struct, (const xmlChar *)"candidates")) )
							{
								indexer->tStructField[i].candidatesStrings
									= indexer->tStructField[i].candidatesDates
									= indexer->tStructField[i].candidatesIntegers
									= indexer->tStructField[i].candidatesFirstDigit
									= indexer->tStructField[i].candidatesMultiDigits
									= false;								// default if attribute exists

								if(!isWhite(candidates))
								{
									for(char *p=(char*)candidates; *p; p++)
									{
										switch(*p)
										{
											case 'S':
											case 's':
												indexer->tStructField[i].candidatesStrings = true;
												break;
											case 'D':
											case 'd':
												indexer->tStructField[i].candidatesDates = true;
												break;
											case 'I':
											case 'i':
												indexer->tStructField[i].candidatesIntegers = true;
												break;
											case '0':
												indexer->tStructField[i].candidatesFirstDigit = true;
												break;
											case '9':
												indexer->tStructField[i].candidatesMultiDigits = true;
												break;
										}
									}

								}
								xmlFree(candidates);
							}

							// ---- get attribute 'tbranch' if it exists
							bool hastbranch = false;
							xmlChar *tbranch;
							if( (tbranch = xmlGetProp(node_struct, (const xmlChar *)"tbranch")) )
							{
								if(!isWhite(tbranch))
								{
									// dump "candidates' field attribute only if there is a tbranch
									cstr += " { candidates='";
									if(indexer->tStructField[i].candidatesStrings == true)
										cstr += "S";
									if(indexer->tStructField[i].candidatesDates == true)
										cstr += "D";
									if(indexer->tStructField[i].candidatesIntegers == true)
										cstr += "I";
									if(indexer->tStructField[i].candidatesFirstDigit == true)
										cstr += "0";
									if(indexer->tStructField[i].candidatesMultiDigits == true)
										cstr += "9";
									cstr += "'}\n";

									// --- copy the full path into the field
									indexer->tStructField[i].set("/record/description/", (const char *)(node_struct->name), (const char *)tbranch);
									xmlFree(tbranch);

									if(indexer->tStructField[i].tbranch && indexer->XPathCtx_thesaurus != NULL)
									{
										// this field has a tbranch, it's linked to the thesaurus
										// build links to the thesaurus

										snprintf(strbuff, 1000, "|    searching tbranch ' %s ' in thesaurus \n", indexer->tStructField[i].tbranch);
										cstr += strbuff;

										xmlXPathObjectPtr  xpathObj_thesaurus = NULL;
										xpathObj_thesaurus = xmlXPathEvalExpression((const xmlChar*)(indexer->tStructField[i].tbranch), indexer->XPathCtx_thesaurus);
										if(xpathObj_thesaurus != NULL)
										{
											if(xpathObj_thesaurus->nodesetval)
											{
												xmlNodeSetPtr nodes_thesaurus = xpathObj_thesaurus->nodesetval;

												snprintf(strbuff, 1000, "|    -> found %d node%s \n", nodes_thesaurus->nodeNr, (nodes_thesaurus->nodeNr==1 ? "s":""));
												cstr += strbuff;

												if(nodes_thesaurus->nodeNr > 0)
												{
													hastbranch = true;

													// in this field, allocate an array of xpathcontext
													indexer->tStructField[i].tXPathCtxThesaurus = new xmlXPathContextPtr[nodes_thesaurus->nodeNr];
													// in this field, allocate an array of nodes
													indexer->tStructField[i].tNodesThesaurus = new xmlNodePtr[nodes_thesaurus->nodeNr];

													if(indexer->tStructField[i].tXPathCtxThesaurus && indexer->tStructField[i].tNodesThesaurus)
													{
														indexer->tStructField[i].nXPathCtxThesaurus = nodes_thesaurus->nodeNr;
														indexer->tStructField[i].nNodesThesaurus    = nodes_thesaurus->nodeNr;
														for(int j=0; j<nodes_thesaurus->nodeNr; j++)
														{
															xmlNodePtr node_thesaurus = nodes_thesaurus->nodeTab[j];
															indexer->tStructField[i].tXPathCtxThesaurus[j] = xmlXPathNewContext((xmlDocPtr)node_thesaurus);
															indexer->tStructField[i].tNodesThesaurus[j]    = node_thesaurus;
														}
													}
												}
											}
											xmlXPathFreeObject(xpathObj_thesaurus);
										}
									}

									if(indexer->tStructField[i].cbranch && indexer->XPathCtx_cterms != NULL)
									{
										// build a link to cterms
										snprintf(strbuff, 1000, "|    searching cbranch ' %s ' in cterms \n", indexer->tStructField[i].cbranch);
										cstr += strbuff;

										// check if cterms has a branch '...field='..zfname..'...
										xmlXPathObjectPtr  xpathObj_cterms = NULL;

										xpathObj_cterms = xmlXPathEvalExpression((const xmlChar*)(indexer->tStructField[i].cbranch), indexer->XPathCtx_cterms);
										if(xpathObj_cterms != NULL)
										{
											if(!xpathObj_cterms->nodesetval || xpathObj_cterms->nodesetval->nodeNr == 0)
											{
												// the branch does not exists, create it

												cstr += "|    -> node not found, creating \n";

												xmlNodePtr root = xmlDocGetRootElement(indexer->DocCterms);

												// get nextid
												xmlChar *nextid;
												if( (nextid = xmlGetProp(root, (const xmlChar *)"nextid")) )
												{
													int l = strlen((const char *)nextid);
													if(l > 32)
														l = 32;
													xmlNodePtr te;
													if((te = xmlNewChild(root, NULL, (const xmlChar*)"te", NULL)) != NULL)
													{
														char ibuff[33];

														// prop 'id'
														ibuff[0] = 'C';
														memcpy(ibuff+1, nextid, l+1);
														xmlSetProp(te, (const xmlChar*)"id", (const xmlChar *)ibuff);

														// prop 'field'
														xmlSetProp(te, (const xmlChar*)"field", (const xmlChar *)(indexer->tStructField[i].name));

														// prop 'nextid'
														xmlSetProp(te, (const xmlChar*)"nextid", (const xmlChar *)"0");

														// inc nextid
														sprintf(ibuff, "%d", atoi((const char *)nextid) + 1);
														xmlSetProp(root, (const xmlChar*)"nextid", (const xmlChar *)ibuff );

														// put a xpathcontext into the field
														indexer->tStructField[i].xmlNodeCterms = te;
														indexer->tStructField[i].XPathCtxCterms = xmlXPathNewContext((xmlDocPtr)te);
													}
													xmlFree(nextid);

													time(&cterms_moddate);
												}
											}
											else
											{
												xmlNodeSetPtr nodes_cterms = xpathObj_cterms->nodesetval;

												snprintf(strbuff, 1000, "|    -> found %d node%s (keeping the first) \n", nodes_cterms->nodeNr, (nodes_cterms->nodeNr==1 ? "s":""));
												cstr += strbuff;

												// in the field, keep the first xpathcontext
												indexer->tStructField[i].xmlNodeCterms = nodes_cterms->nodeTab[0];
												indexer->tStructField[i].XPathCtxCterms = xmlXPathNewContext((xmlDocPtr)(nodes_cterms->nodeTab[0]));
											}

											xmlXPathFreeObject(xpathObj_cterms);
										}
									}
								}
								else
								{
									//  'tbranch' is white
									cstr += "'\n";
									indexer->tStructField[i].set("/record/description/", (const char *)(node_struct->name), NULL);
								}
							}
							else
							{
								// no 'tbranch' attribute
								cstr += "'\n";
								indexer->tStructField[i].set("/record/description/", (const char *)(node_struct->name), NULL);
							}
						} // FIN : boucle sur les nodes du result sur struc

						cstr += "\\-------------------------------- structure loaded  ------\n";

					} // FIN : if(xpathObj_struct->nodesetval)

					xmlXPathFreeObject(xpathObj_struct);

				} // FIN : if(xpathObj_struct != NULL)

				xmlXPathFreeContext(xpathCtx_struct);

			} // FIN : if(xpathCtx_struct != NULL)
		}
	}

	zSyslog._log(CSyslog::LOGL_INFO, CSyslog::LOGC_STRUCTURE, (TCHAR *)(cstr.c_str()) );

	cstr.clear();

	// ------------------ end loading structure
	indexer->current_struct_moddate = struct_moddate;
	indexer->current_thesaurus_moddate = thesaurus_moddate;
	indexer->current_cterms_moddate = cterms_moddate;
}
Ejemplo n.º 10
0
/*! @brief Saves the group to disc
 * 
 * Saves the group to disc possibly creating the configdirectory
 * 
 * @param group The group
 * @param error Pointer to an error struct
 * @returns TRUE on success, FALSE otherwise
 * 
 */
osync_bool osync_group_save(OSyncGroup *group, OSyncError **error)
{
  char *filename = NULL;
  int i;
  xmlDocPtr doc;
  char *tmstr = NULL;
  char *version_str = NULL;
	
  osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, group, error);
  osync_assert(group);
  osync_assert(group->configdir);
	
  osync_trace(TRACE_INTERNAL, "Trying to open configdirectory %s to save group %s", group->configdir, group->name);
	
  if (!g_file_test(group->configdir, G_FILE_TEST_IS_DIR)) {
    osync_trace(TRACE_INTERNAL, "Creating group configdirectory %s", group->configdir);
    if (g_mkdir(group->configdir, 0700)) {
      osync_error_set(error, OSYNC_ERROR_IO_ERROR, "Unable to create directory for group %s\n", group->name);
      goto error;
    }
  }
	
  filename = g_strdup_printf ("%s%csyncgroup.conf", group->configdir, G_DIR_SEPARATOR);
  osync_trace(TRACE_INTERNAL, "Saving group to file %s", filename);
	
  doc = xmlNewDoc((xmlChar*)"1.0");
  doc->children = xmlNewDocNode(doc, NULL, (xmlChar*)"syncgroup", NULL);

  version_str = g_strdup_printf("%u.%u", OSYNC_GROUP_MAJOR_VERSION, OSYNC_GROUP_MINOR_VERSION);
  xmlSetProp(doc->children, (const xmlChar*)"version", (const xmlChar *)version_str);	
  g_free(version_str);
	
  // TODO: reimplement the filter!
  //The filters
  /*GList *f;
    for (f = group->filters; f; f = f->next) {
    OSyncFilter *filter = f->data;
    xmlNodePtr child = xmlNewChild(doc->children, NULL, (xmlChar*)"filter", NULL);
		
    if (filter->sourcememberid) {
    char *sourcememberid = g_strdup_printf("%lli", filter->sourcememberid);
    xmlNewChild(child, NULL, (xmlChar*)"sourcemember", (xmlChar*)sourcememberid);
    g_free(sourcememberid);
    }
    if (filter->destmemberid) {
    char *destmemberid = g_strdup_printf("%lli", filter->destmemberid);
    xmlNewChild(child, NULL, (xmlChar*)"destmember", (xmlChar*)destmemberid);
    g_free(destmemberid);
    }
    if (filter->sourceobjtype)
    xmlNewChild(child, NULL, (xmlChar*)"sourceobjtype", (xmlChar*)filter->sourceobjtype);
    if (filter->destobjtype)
    xmlNewChild(child, NULL, (xmlChar*)"destobjtype", (xmlChar*)filter->destobjtype);
    if (filter->detectobjtype)
    xmlNewChild(child, NULL, (xmlChar*)"detectobjtype", (xmlChar*)filter->detectobjtype);
    if (filter->action) {
    char *action = g_strdup_printf("%i", filter->action);
    xmlNewChild(child, NULL, (xmlChar*)"action", (xmlChar*)action);
    g_free(action);
    }
    if (filter->function_name)
    xmlNewChild(child, NULL, (xmlChar*)"function_name", (xmlChar*)filter->function_name);
    if (filter->config)
    xmlNewChild(child, NULL, (xmlChar*)"config", (xmlChar*)filter->config);
    }*/

  xmlNewChild(doc->children, NULL, (xmlChar*)"groupname", (xmlChar*)group->name);

  tmstr = g_strdup_printf("%i", (int)group->last_sync);
  xmlNewChild(doc->children, NULL, (xmlChar*)"last_sync", (xmlChar*)tmstr);
  g_free(tmstr);

  xmlNewChild(doc->children, NULL, (xmlChar*)"merger_enabled", (xmlChar*) (group->merger_enabled ? "true" : "false"));
  xmlNewChild(doc->children, NULL, (xmlChar*)"converter_enabled", (xmlChar*) (group->converter_enabled ? "true" : "false"));


  xmlSaveFormatFile(filename, doc, 1);
  osync_xml_free_doc(doc);
  g_free(filename);

  for (i = 0; i < osync_group_num_members(group); i++) {
    OSyncMember *member = osync_group_nth_member(group, i);
    if (!osync_member_save(member, error))
      goto error;
  }
	
  osync_trace(TRACE_EXIT, "%s", __func__);
  return TRUE;

 error:
  osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
  return FALSE;
}
static void
add_kvp_value_node(xmlNodePtr node, gchar *tag, kvp_value* val)
{
    xmlNodePtr val_node;
    gchar *tmp_str1;
    kvp_value_t kvp_type;

    kvp_type = kvp_value_get_type(val);

    if (kvp_type == KVP_TYPE_STRING)
        val_node = xmlNewTextChild(node, NULL, BAD_CAST tag, BAD_CAST kvp_value_get_string(val));
    else if (kvp_type == KVP_TYPE_TIMESPEC)
        val_node = NULL;
    else if (kvp_type == KVP_TYPE_GDATE)
    {
        GDate d = kvp_value_get_gdate(val);
        val_node = gdate_to_dom_tree(tag, &d);
        xmlAddChild (node, val_node);
    }
    else
        val_node = xmlNewTextChild(node, NULL, BAD_CAST tag, NULL);

    switch (kvp_value_get_type(val))
    {
    case KVP_TYPE_GINT64:
        add_text_to_node(val_node, "integer",
                         g_strdup_printf("%" G_GINT64_FORMAT,
                                         kvp_value_get_gint64(val)));
        break;
    case KVP_TYPE_DOUBLE:
        add_text_to_node(val_node, "double",
                         double_to_string(kvp_value_get_double(val)));
        break;
    case KVP_TYPE_NUMERIC:
        add_text_to_node(val_node, "numeric",
                         gnc_numeric_to_string(kvp_value_get_numeric(val)));
        break;
    case KVP_TYPE_STRING:
        xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "string");
        break;
    case KVP_TYPE_GUID:
        /* THREAD-UNSAFE */
        add_text_to_node(val_node, "guid",
                         g_strdup(guid_to_string(kvp_value_get_guid(val))));
        break;
    case KVP_TYPE_TIMESPEC:
    {
        Timespec ts = kvp_value_get_timespec (val);

        val_node = timespec_to_dom_tree (tag, &ts);
        xmlSetProp (val_node, BAD_CAST "type", BAD_CAST "timespec");
        xmlAddChild (node, val_node);
    }
    break;
    case KVP_TYPE_GDATE:
        xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "gdate");
        break;
    case KVP_TYPE_BINARY:
    {
        guint64 size;
        void *binary_data = kvp_value_get_binary(val, &size);
        xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "binary");
        g_return_if_fail(binary_data);
        tmp_str1 = binary_to_string(binary_data, size);
        xmlNodeSetContent(val_node, BAD_CAST tmp_str1);
        g_free(tmp_str1);
    }
    break;
    case KVP_TYPE_GLIST:
    {
        GList *cursor;

        xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "list");
        for (cursor = kvp_value_get_glist(val); cursor; cursor = cursor->next)
        {
            kvp_value *val = (kvp_value*)cursor->data;
            add_kvp_value_node(val_node, "slot:value", val);
        }
    }

    break;
    case KVP_TYPE_FRAME:
    {
        kvp_frame *frame;

        xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "frame");

        frame = kvp_value_get_frame (val);
        if (!frame || !kvp_frame_get_hash (frame))
            break;

        g_hash_table_foreach_sorted(kvp_frame_get_hash(frame),
                                    add_kvp_slot, val_node, (GCompareFunc)strcmp);
    }
    break;

    }
}
Ejemplo n.º 12
0
/* 
 * renderer methods 
 */ 
static void 
draw_object(DiaRenderer *self,
            DiaObject   *object,
	    DiaMatrix   *matrix)
{
  DrsRenderer *renderer = DRS_RENDERER (self);
  DiaMatrix *m = g_queue_peek_tail (renderer->matrices);
  xmlNodePtr node;

  g_queue_push_tail (renderer->parents, renderer->root);
  renderer->root = node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"object", NULL);
  xmlSetProp(node, (const xmlChar *)"type", (xmlChar *)object->type->name);
  /* if it looks like intdata store it as well */
  if ((int)object->type->default_user_data > 0 && (int)object->type->default_user_data < 0xFF) {
    gchar buffer[30];
    g_snprintf(buffer, sizeof(buffer), "%d", (int)object->type->default_user_data);
    xmlSetProp(node, (const xmlChar *)"intdata", (xmlChar *)buffer);
  }
  if (renderer->save_props) {
    xmlNodePtr props_node;

    props_node = xmlNewChild(node, NULL, (const xmlChar *)"properties", NULL);
    object_save_props (object, props_node, renderer->ctx);
  }
  if (matrix) {
    DiaMatrix *m2 = g_new (DiaMatrix, 1);
    if (m)
      dia_matrix_multiply (m2, matrix, m);
    else
      *m2 = *matrix;
    g_queue_push_tail (renderer->matrices, m2);
    /* lazy creation of our transformer */
    if (!renderer->transformer)
      renderer->transformer = dia_transform_renderer_new (self);
  }
  /* special handling for group objects:
   *  - for the render branch use DiaTransformRenderer, but not it's draw_object,
   *    to see all the children's draw_object ourself
   *  - for the object branch we rely on this draw_object being called so need
   *    to inline group_draw here
   *  - to maintain the correct transform build our own queue of matrices like
   *    the DiaTransformRenderer would do through it's draw_object
   */
  {
    g_queue_push_tail (renderer->parents, renderer->root);
    renderer->root = node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"render", NULL);
    if (renderer->transformer) {
      DiaMatrix *m = g_queue_peek_tail (renderer->matrices);

      if (IS_GROUP (object)) {
	/* reimplementation of group_draw to use this draw_object method */
	GList *list;
	DiaObject *obj;

	list = group_objects (object);
	while (list != NULL) {
	  obj = (DiaObject *) list->data;

	  DIA_RENDERER_GET_CLASS(self)->draw_object(self, obj, m);
	  list = g_list_next(list);
	}
      } else {
	/* just the leaf */
	DIA_RENDERER_GET_CLASS(renderer->transformer)->draw_object(renderer->transformer, object, m);
      }
    } else {
      object->ops->draw(object, DIA_RENDERER (renderer));
    }
    renderer->root = g_queue_pop_tail (renderer->parents);
  }
  renderer->root = g_queue_pop_tail (renderer->parents);

  if (matrix)
    g_queue_pop_tail (renderer->matrices);
  /* one lost demand destruction */
  if (renderer->transformer && g_queue_is_empty (renderer->matrices)) {
    g_object_unref (renderer->transformer);
    renderer->transformer = NULL;
  }
}
Ejemplo n.º 13
0
static int
rest_set_filter(noit_http_rest_closure_t *restc,
                int npats, char **pats) {
  noit_http_session_ctx *ctx = restc->http_ctx;
  xmlDocPtr doc = NULL, indoc = NULL;
  xmlNodePtr node, parent, root, newfilter;
  char xpath[1024];
  int error_code = 500, complete = 0, mask = 0;
  const char *error = "internal error";

  if(npats != 2) goto error;

  indoc = rest_get_xml_upload(restc, &mask, &complete);
  if(!complete) return mask;
  if(indoc == NULL) FAIL("xml parse error");

  snprintf(xpath, sizeof(xpath), "//filtersets%sfilterset[@name=\"%s\"]",
           pats[0], pats[1]);
  node = noit_conf_get_section(NULL, xpath);
  if(!node && noit_filter_exists(pats[1])) {
    /* It's someone else's */
    error_code = 403;
    goto error;
  }

  if((newfilter = validate_filter_post(indoc)) == NULL) goto error;
  xmlSetProp(newfilter, (xmlChar *)"name", (xmlChar *)pats[1]);

  parent = make_conf_path(pats[0]);
  if(!parent) FAIL("invalid path");
  if(node) {
    xmlUnlinkNode(node);
    xmlFreeNode(node);
  }
  xmlUnlinkNode(newfilter);
  xmlAddChild(parent, newfilter);
  CONF_DIRTY(newfilter);

  noit_conf_mark_changed();
  if(noit_conf_write_file(NULL) != 0)
    noitL(noit_error, "local config write failed\n");
  noit_filter_compile_add(newfilter);
  if(restc->call_closure_free) restc->call_closure_free(restc->call_closure);
  restc->call_closure_free = NULL;
  restc->call_closure = NULL;
  restc->fastpath = rest_show_filter;
  return restc->fastpath(restc, restc->nparams, restc->params);

 error:
  noit_http_response_standard(ctx, error_code, "ERROR", "text/html");
  doc = xmlNewDoc((xmlChar *)"1.0");
  root = xmlNewDocNode(doc, NULL, (xmlChar *)"error", NULL);
  xmlDocSetRootElement(doc, root);
  xmlNodeAddContent(root, (xmlChar *)error);
  noit_http_response_xml(ctx, doc);
  noit_http_response_end(ctx);
  goto cleanup;

 cleanup:
  if(doc) xmlFreeDoc(doc);
  return 0;
}
Ejemplo n.º 14
0
/**
 * base_tool_output_data_model_to_string:
 */
gchar *
base_tool_output_data_model_to_string (GdaDataModel *model, ToolOutputFormat format, FILE *stream, GdaSet *options)
{
    if (!GDA_IS_DATA_MODEL (model))
        return NULL;

    if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) {
        gchar *tmp;
        GdaSet *local_options;
        gint width;
        base_tool_input_get_size (&width, NULL);
        local_options = gda_set_new_inline (6, "NAME", G_TYPE_BOOLEAN, TRUE,
                                            "NULL_AS_EMPTY", G_TYPE_BOOLEAN, TRUE,
                                            "MAX_WIDTH", G_TYPE_INT, width,
                                            "COLUMN_SEPARATORS", G_TYPE_BOOLEAN, TRUE,
                                            "SEPARATOR_LINE", G_TYPE_BOOLEAN, TRUE,
                                            "NAMES_ON_FIRST_LINE", G_TYPE_BOOLEAN, TRUE);
        if (options)
            gda_set_merge_with_set (local_options, options);
        tmp = gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_TEXT_TABLE, NULL, 0, NULL, 0,
                                               local_options);
        g_object_unref (local_options);
        if (GDA_IS_DATA_SELECT (model)) {
            gchar *tmp2, *tmp3;
            gdouble etime;
            g_object_get ((GObject*) model, "execution-delay", &etime, NULL);
            tmp2 = g_strdup_printf ("%s: %.03f s", _("Execution delay"), etime);
            tmp3 = g_strdup_printf ("%s\n%s", tmp, tmp2);
            g_free (tmp);
            g_free (tmp2);
            return tmp3;
        }
        else
            return tmp;
    }
    else if (format & BASE_TOOL_OUTPUT_FORMAT_XML)
        return gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_DATA_ARRAY_XML,
                                                NULL, 0,
                                                NULL, 0, NULL);
    else if (format & BASE_TOOL_OUTPUT_FORMAT_CSV) {
        gchar *retval;
        GdaSet *optexp;
        optexp = make_options_set_from_string ("csv", options);
        retval = gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_TEXT_SEPARATED,
                 NULL, 0,
                 NULL, 0, optexp);
        if (optexp)
            g_object_unref (optexp);
        return retval;
    }
    else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
        xmlBufferPtr buffer;
        xmlNodePtr top, div, table, node, row_node, col_node, header, meta;
        gint ncols, nrows, i, j;
        gchar *str;

        top = xmlNewNode (NULL, BAD_CAST "html");
        header = xmlNewChild (top, NULL, BAD_CAST "head", NULL);
        meta = xmlNewChild (header, NULL, BAD_CAST "meta", NULL);
        xmlSetProp (meta, BAD_CAST "http-equiv", BAD_CAST "content-type");
        xmlSetProp (meta, BAD_CAST "content", BAD_CAST "text/html; charset=UTF-8");
        div = xmlNewChild (top, NULL, BAD_CAST "body", NULL);
        table = xmlNewChild (div, NULL, BAD_CAST "table", NULL);
        xmlSetProp (table, BAD_CAST "border", BAD_CAST "1");

        if (g_object_get_data (G_OBJECT (model), "name"))
            xmlNewTextChild (table, NULL, BAD_CAST "caption", g_object_get_data (G_OBJECT (model), "name"));

        ncols = gda_data_model_get_n_columns (model);
        nrows = gda_data_model_get_n_rows (model);

        row_node = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
        for (j = 0; j < ncols; j++) {
            const gchar *cstr;
            cstr = gda_data_model_get_column_title (model, j);
            col_node = xmlNewTextChild (row_node, NULL, BAD_CAST "th", BAD_CAST cstr);
            xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "center");
        }

        for (i = 0; i < nrows; i++) {
            row_node = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
            xmlSetProp (row_node, BAD_CAST "valign", BAD_CAST "top");
            for (j = 0; j < ncols; j++) {
                const GValue *value;
                value = gda_data_model_get_value_at (model, j, i, NULL);
                if (!value) {
                    col_node = xmlNewChild (row_node, NULL, BAD_CAST "td", BAD_CAST "ERROR");
                    xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "left");
                }
                else {
                    str = gda_value_stringify (value);
                    col_node = xmlNewTextChild (row_node, NULL, BAD_CAST "td", BAD_CAST str);
                    xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "left");
                    g_free (str);
                }
            }
        }

        node = xmlNewChild (div, NULL, BAD_CAST "p", NULL);
        str = g_strdup_printf (ngettext ("(%d row)", "(%d rows)", nrows), nrows);
        xmlNodeSetContent (node, BAD_CAST str);
        g_free (str);

        buffer = xmlBufferCreate ();
        xmlNodeDump (buffer, NULL, top, 0, 1);
        str = g_strdup ((gchar *) xmlBufferContent (buffer));
        xmlBufferFree (buffer);
        xmlFreeNode (top);
        return str;
    }
    else
        TO_IMPLEMENT;

    return NULL;
}
Ejemplo n.º 15
0
	xmlNodePtr CGroupModal::serialize( xmlNodePtr parentNode, const char *type ) const
	{
		xmlNodePtr node = CGroupFrame::serialize( parentNode, type );
		if( node == NULL )
			return NULL;

		xmlSetProp( node, BAD_CAST "type", BAD_CAST "modal" );
		xmlSetProp( node, BAD_CAST "mouse_pos", BAD_CAST NLMISC::toString( SpawnOnMousePos ).c_str() );
		xmlSetProp( node, BAD_CAST "exit_click_out", BAD_CAST NLMISC::toString( ExitClickOut ).c_str() );
		xmlSetProp( node, BAD_CAST "exit_click_l", BAD_CAST NLMISC::toString( ExitClickL ).c_str() );
		xmlSetProp( node, BAD_CAST "exit_click_r", BAD_CAST NLMISC::toString( ExitClickR ).c_str() );
		
		if( ExitClickL == ExitClickR )
			xmlSetProp( node, BAD_CAST "exit_click_b", BAD_CAST NLMISC::toString( ExitClickL ).c_str() );

		xmlSetProp( node, BAD_CAST "force_inside_screen", BAD_CAST NLMISC::toString( ForceInsideScreen ).c_str() );
		xmlSetProp( node, BAD_CAST "category", BAD_CAST Category.c_str() );
		xmlSetProp( node, BAD_CAST "onclick_out", BAD_CAST OnClickOut.c_str() );
		xmlSetProp( node, BAD_CAST "onclick_out_params", BAD_CAST OnClickOutParams.c_str() );
		xmlSetProp( node, BAD_CAST "onpostclick_out", BAD_CAST OnPostClickOut.c_str() );
		xmlSetProp( node, BAD_CAST "onpostclick_out_params", BAD_CAST OnPostClickOutParams.c_str() );
		xmlSetProp( node, BAD_CAST "exit_key_pushed", BAD_CAST NLMISC::toString( ExitKeyPushed ).c_str() );

		return node;
	}
static void
noit_capabilities_tobuff(noit_capsvc_closure_t *cl, eventer_func_t curr) {
    char vbuff[128];
    noit_hash_table *lc;
    noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
    const char *k;
    int klen;
    void *data;
    struct timeval now;

    xmlDocPtr xmldoc;
    xmlNodePtr root, cmds;

    /* fill out capabilities */

    /* Create an XML Document */
    xmldoc = xmlNewDoc((xmlChar *)"1.0");
    root = xmlNewDocNode(xmldoc, NULL, (xmlChar *)"noit_capabilities", NULL);
    xmlDocSetRootElement(xmldoc, root);

    /* Fill in the document */
    noit_build_version(vbuff, sizeof(vbuff));
    xmlNewTextChild(root, NULL, (xmlChar *)"version", (xmlChar *)vbuff);

    /* time (poor man's time check) */
    gettimeofday(&now, NULL);
    snprintf(vbuff, sizeof(vbuff), "%llu.%03d", (unsigned long long)now.tv_sec,
             (int)(now.tv_usec / 1000));
    xmlNewTextChild(root, NULL, (xmlChar *)"current_time", (xmlChar *)vbuff);

    cmds = xmlNewNode(NULL, (xmlChar *)"services");
    xmlAddChild(root, cmds);
    lc = noit_listener_commands();
    while(noit_hash_next(lc, &iter, &k, &klen, &data)) {
      xmlNodePtr cnode;
      char hexcode[11];
      const char *name;
      eventer_func_t *f = (eventer_func_t *)k;
      noit_hash_table *sc = (noit_hash_table *)data;
      noit_hash_iter sc_iter = NOIT_HASH_ITER_ZERO;
      const char *sc_k;
      int sc_klen;
      void *sc_data;

      name = eventer_name_for_callback(*f);
      cnode = xmlNewNode(NULL, (xmlChar *)"service");
      xmlSetProp(cnode, (xmlChar *)"name", name ? (xmlChar *)name : NULL);
      if(*f == curr)
        xmlSetProp(cnode, (xmlChar *)"connected", (xmlChar *)"true");
      xmlAddChild(cmds, cnode);
      while(noit_hash_next(sc, &sc_iter, &sc_k, &sc_klen, &sc_data)) {
        xmlNodePtr scnode;
        char *name_copy, *version = NULL;
        eventer_func_t *f = (eventer_func_t *)sc_data;

        snprintf(hexcode, sizeof(hexcode), "0x%08x", *((u_int32_t *)sc_k));
        name = eventer_name_for_callback(*f);
        name_copy = strdup(name ? name : "[[unknown]]");
        version = strchr(name_copy, '/');
        if(version) *version++ = '\0';

        scnode = xmlNewNode(NULL, (xmlChar *)"command");
        xmlSetProp(scnode, (xmlChar *)"name", (xmlChar *)name_copy);
        if(version)
          xmlSetProp(scnode, (xmlChar *)"version", (xmlChar *)version);
        xmlSetProp(scnode, (xmlChar *)"code", (xmlChar *)hexcode);
        xmlAddChild(cnode, scnode);
        free(name_copy);
      }
    }

    /* Write it out to a buffer and copy it for writing */
    cl->buff = noit_xmlSaveToBuffer(xmldoc);
    cl->towrite = strlen(cl->buff);

    /* Clean up after ourselves */
    xmlFreeDoc(xmldoc);
}
Ejemplo n.º 17
0
void Epair_XMLWrite( epair_t *pEpair, xmlNodePtr epair ){
	xmlSetProp( epair, (xmlChar *)"key", (xmlChar *)pEpair->key );
	xmlSetProp( epair, (xmlChar *)"value", (xmlChar *)pEpair->value );
}
Ejemplo n.º 18
0
static void
mtev_capabilities_tobuff(mtev_capsvc_closure_t *cl, eventer_func_t curr) {
    const char **mod_names;
    struct utsname utsn;
    char vbuff[128], bwstr[4];
    mtev_hash_table *lc;
    mtev_hash_iter iter = MTEV_HASH_ITER_ZERO;
    const char *k;
    int klen, i, nmods;
    void *data;
    struct timeval now;
    struct dso_type *t;

    xmlDocPtr xmldoc;
    xmlNodePtr root, cmds, bi, ri, mods, feat;

    /* fill out capabilities */

    /* Create an XML Document */
    xmldoc = xmlNewDoc((xmlChar *)"1.0");
    root = xmlNewDocNode(xmldoc, NULL, (xmlChar *)capabilities_namespace, NULL);
    xmlDocSetRootElement(xmldoc, root);

    /* Fill in the document */
    mtev_build_version(vbuff, sizeof(vbuff));
    xmlNewTextChild(root, NULL, (xmlChar *)"version", (xmlChar *)vbuff);

    snprintf(bwstr, sizeof(bwstr), "%d", (int)sizeof(void *)*8);
    /* Build info */
    bi = xmlNewNode(NULL, (xmlChar *)"unameBuild");
    xmlSetProp(bi, (xmlChar *)"bitwidth", (xmlChar *)bwstr);
    xmlAddChild(root, bi);
    xmlNewTextChild(bi, NULL, (xmlChar *)"sysname", (xmlChar *)UNAME_S);
    xmlNewTextChild(bi, NULL, (xmlChar *)"nodename", (xmlChar *)UNAME_N);
    xmlNewTextChild(bi, NULL, (xmlChar *)"release", (xmlChar *)UNAME_R);
    xmlNewTextChild(bi, NULL, (xmlChar *)"version", (xmlChar *)UNAME_V);
    xmlNewTextChild(bi, NULL, (xmlChar *)"machine", (xmlChar *)UNAME_M);

    /* Run info */
    ri = xmlNewNode(NULL, (xmlChar *)"unameRun");
    xmlSetProp(ri, (xmlChar *)"bitwidth", (xmlChar *)bwstr);
    xmlAddChild(root, ri);
    if(uname(&utsn) < 0) {
      xmlNewTextChild(ri, NULL, (xmlChar *)"error", (xmlChar *)strerror(errno));
    } else {
      xmlNewTextChild(ri, NULL, (xmlChar *)"sysname", (xmlChar *)utsn.sysname);
      xmlNewTextChild(ri, NULL, (xmlChar *)"nodename", (xmlChar *)utsn.nodename);
      xmlNewTextChild(ri, NULL, (xmlChar *)"release", (xmlChar *)utsn.release);
      xmlNewTextChild(ri, NULL, (xmlChar *)"version", (xmlChar *)utsn.version);
      xmlNewTextChild(ri, NULL, (xmlChar *)"machine", (xmlChar *)utsn.machine);
    }

    /* features */
    feat = xmlNewNode(NULL, (xmlChar *)"features");
    xmlAddChild(root, feat);
    if(mtev_hash_size(&features)) {
      mtev_hash_iter iter2 = MTEV_HASH_ITER_ZERO;
      void *vfv;
      const char *f;
      int flen;
      while(mtev_hash_next(&features, &iter2, &f, &flen, &vfv)) {
        xmlNodePtr featnode;
        featnode = xmlNewNode(NULL, (xmlChar *)"feature");
        xmlSetProp(featnode, (xmlChar *)"name", (xmlChar *)f);
        if(vfv) xmlSetProp(featnode, (xmlChar *)"version", (xmlChar *)vfv);
        xmlAddChild(feat, featnode);
      }
    }

    /* time (poor man's time check) */
    gettimeofday(&now, NULL);
    snprintf(vbuff, sizeof(vbuff), "%llu.%03d", (unsigned long long)now.tv_sec,
             (int)(now.tv_usec / 1000));
    xmlNewTextChild(root, NULL, (xmlChar *)"current_time", (xmlChar *)vbuff);

    cmds = xmlNewNode(NULL, (xmlChar *)"services");
    xmlAddChild(root, cmds);
    lc = mtev_listener_commands();
    while(mtev_hash_next(lc, &iter, &k, &klen, &data)) {
      xmlNodePtr cnode;
      char hexcode[11];
      const char *name;
      eventer_func_t *f = (eventer_func_t *)k;
      mtev_hash_table *sc = (mtev_hash_table *)data;
      mtev_hash_iter sc_iter = MTEV_HASH_ITER_ZERO;
      const char *sc_k;
      int sc_klen;
      void *sc_data;

      name = eventer_name_for_callback(*f);
      cnode = xmlNewNode(NULL, (xmlChar *)"service");
      xmlSetProp(cnode, (xmlChar *)"name", name ? (xmlChar *)name : NULL);
      if(*f == curr)
        xmlSetProp(cnode, (xmlChar *)"connected", (xmlChar *)"true");
      xmlAddChild(cmds, cnode);
      while(mtev_hash_next(sc, &sc_iter, &sc_k, &sc_klen, &sc_data)) {
        xmlNodePtr scnode;
        char *name_copy, *version = NULL;
        eventer_func_t *f = (eventer_func_t *)sc_data;

        snprintf(hexcode, sizeof(hexcode), "0x%08x", *((u_int32_t *)sc_k));
        name = eventer_name_for_callback(*f);
        name_copy = strdup(name ? name : "[[unknown]]");
        version = strchr(name_copy, '/');
        if(version) *version++ = '\0';

        scnode = xmlNewNode(NULL, (xmlChar *)"command");
        xmlSetProp(scnode, (xmlChar *)"name", (xmlChar *)name_copy);
        if(version)
          xmlSetProp(scnode, (xmlChar *)"version", (xmlChar *)version);
        xmlSetProp(scnode, (xmlChar *)"code", (xmlChar *)hexcode);
        xmlAddChild(cnode, scnode);
        free(name_copy);
      }
    }

    mods = xmlNewNode(NULL, (xmlChar *)"modules");
    xmlAddChild(root, mods);

#define list_modules(func, name) do { \
    nmods = func(&mod_names); \
    for(i=0; i<nmods; i++) { \
      xmlNodePtr pnode; \
      pnode = xmlNewNode(NULL, (xmlChar *)"module"); \
      xmlSetProp(pnode, (xmlChar *)"type", (xmlChar *)name); \
      xmlSetProp(pnode, (xmlChar *)"name", (xmlChar *)mod_names[i]); \
      xmlAddChild(mods, pnode); \
    } \
    if(mod_names) free(mod_names); \
} while(0)
    for(t = mtev_dso_get_types(); t; t = t->next)
      list_modules(t->list, t->name);

    /* Write it out to a buffer and copy it for writing */
    cl->buff = mtev_xmlSaveToBuffer(xmldoc);
    cl->towrite = strlen(cl->buff);

    /* Clean up after ourselves */
    xmlFreeDoc(xmldoc);
}
Ejemplo n.º 19
0
void ProcessWorldModel( void ){
	int i, s;
	entity_t    *e;
	tree_t      *tree;
	face_t      *faces;
	qboolean ignoreLeaks, leaked;
	xmlNodePtr polyline, leaknode;
	char level[ 2 ], shader[ 1024 ];
	const char  *value;
	int leakStatus;

	/* sets integer blockSize from worldspawn "_blocksize" key if it exists */
	value = ValueForKey( &entities[ 0 ], "_blocksize" );
	if ( value[ 0 ] == '\0' ) {
		value = ValueForKey( &entities[ 0 ], "blocksize" );
	}
	if ( value[ 0 ] == '\0' ) {
		value = ValueForKey( &entities[ 0 ], "chopsize" );  /* sof2 */
	}
	if ( value[ 0 ] != '\0' ) {
		/* scan 3 numbers */
		s = sscanf( value, "%d %d %d", &blockSize[ 0 ], &blockSize[ 1 ], &blockSize[ 2 ] );

		/* handle legacy case */
		if ( s == 1 ) {
			blockSize[ 1 ] = blockSize[ 0 ];
			blockSize[ 2 ] = blockSize[ 0 ];
		}
	}
	Sys_Printf( "block size = { %d %d %d }\n", blockSize[ 0 ], blockSize[ 1 ], blockSize[ 2 ] );

	/* sof2: ignore leaks? */
	value = ValueForKey( &entities[ 0 ], "_ignoreleaks" );  /* ydnar */
	if ( value[ 0 ] == '\0' ) {
		value = ValueForKey( &entities[ 0 ], "ignoreleaks" );
	}
	if ( value[ 0 ] == '1' ) {
		ignoreLeaks = qtrue;
	}
	else{
		ignoreLeaks = qfalse;
	}

	/* begin worldspawn model */
	BeginModel();
	e = &entities[ 0 ];
	e->firstDrawSurf = 0;

	/* ydnar: gs mods */
	ClearMetaTriangles();

	/* check for patches with adjacent edges that need to lod together */
	PatchMapDrawSurfs( e );

	/* build an initial bsp tree using all of the sides of all of the structural brushes */
	faces = MakeStructuralBSPFaceList( entities[ 0 ].brushes );
	tree = FaceBSP( faces );
	MakeTreePortals( tree );
	FilterStructuralBrushesIntoTree( e, tree );

	/* see if the bsp is completely enclosed */
	leakStatus = FloodEntities( tree );
	if ( ignoreLeaks ) {
		if ( leakStatus == FLOODENTITIES_LEAKED ) {
			leakStatus = FLOODENTITIES_GOOD;
		}
	}

	if ( leakStatus == FLOODENTITIES_GOOD ) {
		leaked = qfalse;
	}
	else
	{
		leaked = qtrue;

		Sys_FPrintf( SYS_NOXML, "**********************\n" );
		Sys_FPrintf( SYS_NOXML, "******* leaked *******\n" );
		Sys_FPrintf( SYS_NOXML, "**********************\n" );
		polyline = LeakFile( tree );
		leaknode = xmlNewNode( NULL, (xmlChar*)"message" );
		xmlNodeSetContent( leaknode, (xmlChar*)"MAP LEAKED\n" );
		xmlAddChild( leaknode, polyline );
		level[0] = (int) '0' + SYS_ERR;
		level[1] = 0;
		xmlSetProp( leaknode, (xmlChar*)"level", (xmlChar*) &level );
		xml_SendNode( leaknode );
		if ( leaktest ) {
			Sys_Printf( "--- MAP LEAKED, ABORTING LEAKTEST ---\n" );
			exit( 0 );
		}
	}

	if ( leakStatus != FLOODENTITIES_EMPTY ) { /* if no entities exist, this would accidentally the whole map, and that IS bad */
		/* rebuild a better bsp tree using only the sides that are visible from the inside */
		FillOutside( tree->headnode );

		/* chop the sides to the convex hull of their visible fragments, giving us the smallest polygons */
		ClipSidesIntoTree( e, tree );

		/* build a visible face tree (same thing as the initial bsp tree but after reducing the faces) */
		faces = MakeVisibleBSPFaceList( entities[ 0 ].brushes );
		FreeTree( tree );
		tree = FaceBSP( faces );
		MakeTreePortals( tree );
		FilterStructuralBrushesIntoTree( e, tree );

		/* ydnar: flood again for skybox */
		if ( skyboxPresent ) {
			FloodEntities( tree );
		}
	}

	/* save out information for visibility processing */
	NumberClusters( tree );
	if ( !leaked ) {
		WritePortalFile( tree );
	}

	/* flood from entities */
	FloodAreas( tree );

	/* create drawsurfs for triangle models */
	AddTriangleModels( e );

	/* create drawsurfs for surface models */
	AddEntitySurfaceModels( e );

	/* generate bsp brushes from map brushes */
	EmitBrushes( e->brushes, &e->firstBrush, &e->numBrushes );

	/* add references to the detail brushes */
	FilterDetailBrushesIntoTree( e, tree );

	/* drawsurfs that cross fog boundaries will need to be split along the fog boundary */
	if ( !nofog ) {
		FogDrawSurfaces( e );
	}

	/* subdivide each drawsurf as required by shader tesselation */
	if ( !nosubdivide ) {
		SubdivideFaceSurfaces( e, tree );
	}

	/* add in any vertexes required to fix t-junctions */
	if ( !notjunc ) {
		FixTJunctions( e );
	}

	/* ydnar: classify the surfaces */
	ClassifyEntitySurfaces( e );

	/* ydnar: project decals */
	MakeEntityDecals( e );

	/* ydnar: meta surfaces */
	MakeEntityMetaTriangles( e );
	SmoothMetaTriangles();
	FixMetaTJunctions();
	MergeMetaTriangles();

	/* ydnar: debug portals */
	if ( debugPortals ) {
		MakeDebugPortalSurfs( tree );
	}

	/* ydnar: fog hull */
	value = ValueForKey( &entities[ 0 ], "_foghull" );
	if ( value[ 0 ] != '\0' ) {
		sprintf( shader, "textures/%s", value );
		MakeFogHullSurfs( e, tree, shader );
	}

	/* ydnar: bug 645: do flares for lights */
	for ( i = 0; i < numEntities && emitFlares; i++ )
	{
		entity_t    *light, *target;
		const char  *value, *flareShader;
		vec3_t origin, targetOrigin, normal, color;
		int lightStyle;


		/* get light */
		light = &entities[ i ];
		value = ValueForKey( light, "classname" );
		if ( !strcmp( value, "light" ) ) {
			/* get flare shader */
			flareShader = ValueForKey( light, "_flareshader" );
			value = ValueForKey( light, "_flare" );
			if ( flareShader[ 0 ] != '\0' || value[ 0 ] != '\0' ) {
				/* get specifics */
				GetVectorForKey( light, "origin", origin );
				GetVectorForKey( light, "_color", color );
				lightStyle = IntForKey( light, "_style" );
				if ( lightStyle == 0 ) {
					lightStyle = IntForKey( light, "style" );
				}

				/* handle directional spotlights */
				value = ValueForKey( light, "target" );
				if ( value[ 0 ] != '\0' ) {
					/* get target light */
					target = FindTargetEntity( value );
					if ( target != NULL ) {
						GetVectorForKey( target, "origin", targetOrigin );
						VectorSubtract( targetOrigin, origin, normal );
						VectorNormalize( normal, normal );
					}
				}
				else{
					//%	VectorClear( normal );
					VectorSet( normal, 0, 0, -1 );
				}

				if ( colorsRGB ) {
					color[0] = Image_LinearFloatFromsRGBFloat( color[0] );
					color[1] = Image_LinearFloatFromsRGBFloat( color[1] );
					color[2] = Image_LinearFloatFromsRGBFloat( color[2] );
				}

				/* create the flare surface (note shader defaults automatically) */
				DrawSurfaceForFlare( mapEntityNum, origin, normal, color, flareShader, lightStyle );
			}
		}
	}

	/* add references to the final drawsurfs in the apropriate clusters */
	FilterDrawsurfsIntoTree( e, tree );

	/* match drawsurfaces back to original brushsides (sof2) */
	FixBrushSides( e );

	/* finish */
	EndModel( e, tree->headnode );
	FreeTree( tree );
}
Ejemplo n.º 20
0
static gboolean
report_provider_status (GdaServerProvider *prov, GdaConnection *cnc)
{
	gchar *header_str;
	HtmlFile *file = config->index;
	gboolean is_virt;

	typedef void (*AFunc) (void);
	typedef struct {
		const gchar *name;
		gboolean     should_be;
		void       (*func) (void);
	} ProvFunc;
	GdaServerProviderClass *pclass;

	if (prov && cnc && (prov != gda_connection_get_provider (cnc)))
		/* ignoring connection as it has a different provider */
		return TRUE;
	g_assert (prov || cnc);

	/* section */
	if (cnc)
		header_str = g_strdup_printf ("Report for connection '%s'", gda_connection_get_cnc_string (cnc));
	else
		header_str = g_strdup_printf ("Report for '%s' provider", gda_server_provider_get_name (prov));

	/* provider info */
	if (!prov)
		prov = gda_connection_get_provider (cnc);
	is_virt = GDA_IS_VIRTUAL_PROVIDER (prov);
	pclass = (GdaServerProviderClass*) G_OBJECT_GET_CLASS (prov);
	ProvFunc fa[] = {
		{"get_name", TRUE, (AFunc) pclass->get_name},
		{"get_version", TRUE, (AFunc) pclass->get_version},
		{"get_server_version", TRUE, (AFunc) pclass->get_server_version},
		{"supports_feature", TRUE, (AFunc) pclass->supports_feature},
		{"get_data_handler", TRUE, (AFunc) pclass->get_data_handler},
		{"get_def_dbms_type", TRUE, (AFunc) pclass->get_def_dbms_type},
		{"escape_string", TRUE, (AFunc) pclass->escape_string},
		{"unescape_string", TRUE, (AFunc) pclass->unescape_string},
		{"open_connection", TRUE, (AFunc) pclass->open_connection},
		{"close_connection", TRUE, (AFunc) pclass->close_connection},
		{"supports_operation", is_virt ? FALSE : TRUE, (AFunc) pclass->supports_operation},
		{"create_operation", FALSE, (AFunc) pclass->create_operation},
		{"render_operation", FALSE, (AFunc) pclass->render_operation},
		{"perform_operation", FALSE, (AFunc) pclass->perform_operation},
		{"begin_transaction", FALSE, (AFunc) pclass->begin_transaction},
		{"commit_transaction", FALSE, (AFunc) pclass->commit_transaction},
		{"rollback_transaction", FALSE, (AFunc) pclass->rollback_transaction},
		{"add_savepoint", FALSE, (AFunc) pclass->add_savepoint},
		{"rollback_savepoint", FALSE, (AFunc) pclass->rollback_savepoint},
		{"delete_savepoint", FALSE, (AFunc) pclass->delete_savepoint},
		{"create_parser", FALSE, (AFunc) pclass->create_parser},
		{"statement_to_sql", TRUE, (AFunc) pclass->statement_to_sql},
		{"statement_prepare", TRUE, (AFunc) pclass->statement_prepare},
		{"statement_execute", TRUE, (AFunc) pclass->statement_execute},
		{"identifier_quote", TRUE, (AFunc) pclass->identifier_quote}
	};

	ProvFunc md[] = {
		{"_info", TRUE, (AFunc) pclass->meta_funcs._info},
		{"_btypes", TRUE, (AFunc) pclass->meta_funcs._btypes},
		{"_udt", TRUE, (AFunc) pclass->meta_funcs._udt},
		{"udt", TRUE, (AFunc) pclass->meta_funcs.udt},
		{"_udt_cols", TRUE, (AFunc) pclass->meta_funcs._udt_cols},
		{"udt_cols", TRUE, (AFunc) pclass->meta_funcs.udt_cols},
		{"_enums", TRUE, (AFunc) pclass->meta_funcs._enums},
		{"enums", TRUE, (AFunc) pclass->meta_funcs.enums},
		{"_domains", TRUE, (AFunc) pclass->meta_funcs._domains},
		{"domains", TRUE, (AFunc) pclass->meta_funcs.domains},
		{"_constraints_dom", TRUE, (AFunc) pclass->meta_funcs._constraints_dom},
		{"constraints_dom", TRUE, (AFunc) pclass->meta_funcs.constraints_dom},
		{"_el_types", TRUE, (AFunc) pclass->meta_funcs._el_types},
		{"el_types", TRUE, (AFunc) pclass->meta_funcs.el_types},
		{"_collations", TRUE, (AFunc) pclass->meta_funcs._collations},
		{"collations", TRUE, (AFunc) pclass->meta_funcs.collations},
		{"_character_sets", TRUE, (AFunc) pclass->meta_funcs._character_sets},
		{"character_sets", TRUE, (AFunc) pclass->meta_funcs.character_sets},
		{"_schemata", TRUE, (AFunc) pclass->meta_funcs._schemata},
		{"schemata", TRUE, (AFunc) pclass->meta_funcs.schemata},
		{"_tables_views", TRUE, (AFunc) pclass->meta_funcs._tables_views},
		{"tables_views", TRUE, (AFunc) pclass->meta_funcs.tables_views},
		{"_columns", TRUE, (AFunc) pclass->meta_funcs._columns},
		{"columns", TRUE, (AFunc) pclass->meta_funcs.columns},
		{"_view_cols", TRUE, (AFunc) pclass->meta_funcs._view_cols},
		{"view_cols", TRUE, (AFunc) pclass->meta_funcs.view_cols},
		{"_constraints_tab", TRUE, (AFunc) pclass->meta_funcs._constraints_tab},
		{"constraints_tab", TRUE, (AFunc) pclass->meta_funcs.constraints_tab},
		{"_constraints_ref", TRUE, (AFunc) pclass->meta_funcs._constraints_ref},
		{"constraints_ref", TRUE, (AFunc) pclass->meta_funcs.constraints_ref},
		{"_key_columns", TRUE, (AFunc) pclass->meta_funcs._key_columns},
		{"key_columns", TRUE, (AFunc) pclass->meta_funcs.key_columns},
		{"_check_columns", TRUE, (AFunc) pclass->meta_funcs._check_columns},
		{"check_columns", TRUE, (AFunc) pclass->meta_funcs.check_columns},
		{"_triggers", TRUE, (AFunc) pclass->meta_funcs._triggers},
		{"triggers", TRUE, (AFunc) pclass->meta_funcs.triggers},
		{"_routines", TRUE, (AFunc) pclass->meta_funcs._routines},
		{"routines", TRUE, (AFunc) pclass->meta_funcs.routines},
		{"_routine_col", TRUE, (AFunc) pclass->meta_funcs._routine_col},
		{"routine_col", TRUE, (AFunc) pclass->meta_funcs.routine_col},
		{"_routine_par", TRUE, (AFunc) pclass->meta_funcs._routine_par},
		{"routine_par", TRUE, (AFunc) pclass->meta_funcs.routine_par},
	};
	gboolean has_xa = gda_server_provider_supports_feature (prov, cnc, 
								GDA_CONNECTION_FEATURE_XA_TRANSACTIONS);


	xmlNodePtr table, tr, td, span;
	GdaSqlParser *parser;
	GString *string;
	gsize i;
	GdaProviderInfo *pinfo;

	pinfo = gda_config_get_provider_info (gda_server_provider_get_name (prov));
	g_assert (pinfo);

	table = xmlNewChild (file->body, NULL, BAD_CAST "table", NULL);
	xmlSetProp (table, BAD_CAST "width", BAD_CAST "100%");
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	td = xmlNewTextChild (tr, NULL, BAD_CAST "th", BAD_CAST header_str);
	xmlSetProp (td, BAD_CAST "colspan", BAD_CAST  "4");

	/* line 1 */
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's name:");
	td = xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST gda_server_provider_get_name (prov));
	xmlSetProp (td, BAD_CAST "width", (xmlChar*) "35%");
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider is virtual:");
	td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST (is_virt ? "Yes (uses the SQLite engine)" : "No"));
	xmlSetProp (td, BAD_CAST "width", (xmlChar*) "35%");

	/* line 2 */
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's version:");
	xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST gda_server_provider_get_version (prov));
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's server version:");
	xmlNewTextChild (tr, NULL, BAD_CAST "td",
			 BAD_CAST (cnc ? gda_server_provider_get_server_version (prov, cnc) : "(non connected)"));

	/* line 3 */
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's description:");
	xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST pinfo->description);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Filename:");
	xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST pinfo->location);

	/* line 4 */
	parser = gda_server_provider_create_parser (prov, cnc);
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Creates its own SQL parser:");
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST (parser ? "Yes" : "No"));
	if (parser)
		g_object_unref (parser);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Non implemented base methods:");
	span = NULL;
	td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
	for (i = 0; i < sizeof (fa) / sizeof (ProvFunc); i++) {
		gchar *str;
		ProvFunc *pf = &(fa[i]);

		if (pf->func)
			continue;

		if (span)
			str = g_strdup_printf (", %s()", pf->name);
		else
			str = g_strdup_printf ("%s()", pf->name);
		span = xmlNewTextChild (td, NULL, BAD_CAST "span", BAD_CAST str);
		g_free (str);
		if (pf->should_be)
			xmlSetProp (span, BAD_CAST "class", BAD_CAST "error");
	}
	if (!span)
		xmlNodeSetContent (td, BAD_CAST "---");

	/* line 5 */
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Non implemented meta data methods:");
	span = NULL;
	td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
	for (i = 0; i < sizeof (md) / sizeof (ProvFunc); i++) {
		gchar *str;
		ProvFunc *pf = &(md[i]);

		if (pf->func)
			continue;

		if (span)
			str = g_strdup_printf (", %s()", pf->name);
		else
			str = g_strdup_printf ("%s()", pf->name);
		span = xmlNewTextChild (td, NULL, BAD_CAST "span", BAD_CAST str);
		g_free (str);
		if (pf->should_be)
			xmlSetProp (span, BAD_CAST "class", BAD_CAST "error");
	}
	if (!span)
		xmlNodeSetContent (td, BAD_CAST "---");

	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Non implemented XA transactions:");
	if (pclass->xa_funcs) {
		if (!has_xa) {
			td = xmlNewChild (tr, NULL, BAD_CAST "td", 
					  BAD_CAST "The provider has the 'xa_funcs' part but "
					  "reports that distributed transactions are "
					  "not supported.");
			xmlSetProp (td, BAD_CAST "class", BAD_CAST "warning");
		}
		else {
			ProvFunc dt[] = {
				{"xa_start", TRUE, (AFunc) pclass->xa_funcs->xa_start},
				{"xa_end", FALSE, (AFunc) pclass->xa_funcs->xa_end},
				{"xa_prepare", TRUE, (AFunc) pclass->xa_funcs->xa_prepare},
				{"xa_commit", TRUE, (AFunc) pclass->xa_funcs->xa_commit},
				{"xa_rollback", TRUE, (AFunc) pclass->xa_funcs->xa_rollback},
				{"xa_recover", TRUE, (AFunc) pclass->xa_funcs->xa_recover},
			};
			span = NULL;
			td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
			for (i = 0; i < sizeof (dt) / sizeof (ProvFunc); i++) {
				gchar *str;
				ProvFunc *pf = &(dt[i]);
					
				if (pf->func)
					continue;
					
				if (span)
					str = g_strdup_printf (", %s()", pf->name);
				else
					str = g_strdup_printf ("%s()", pf->name);
				span = xmlNewTextChild (td, NULL, BAD_CAST "span", BAD_CAST str);
				g_free (str);
				if (pf->should_be)
					xmlSetProp (span, BAD_CAST "class", BAD_CAST "error");
			}
			if (!span)
				xmlNodeSetContent (td, BAD_CAST "---");
		}
	}
	else {
		if (has_xa) {
			td = xmlNewTextChild (tr, NULL, BAD_CAST "td",
					   BAD_CAST "The provider does not have the 'xa_funcs' part but "
					  "reports that distributed transactions are "
					  "supported.");
			xmlSetProp (td, BAD_CAST "class", BAD_CAST "warning");
		}
		else
			xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "---");
	}	

	/* line 6 */
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Connection's parameters:");
	if (pinfo->dsn_params && pinfo->dsn_params->holders) {
		GSList *list;
		td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
		for (list = pinfo->dsn_params->holders; list; list = list->next) {
			gchar *str, *descr;
			GdaHolder *holder = GDA_HOLDER (list->data);
			g_object_get (G_OBJECT (holder), "description", &descr, NULL);
			if (descr)
				str = g_strdup_printf ("%s: %s", gda_holder_get_id (holder), descr);
			else
				str = g_strdup (gda_holder_get_id (holder));
			g_free (descr);
			xmlNewTextChild (td, NULL, BAD_CAST "div", BAD_CAST str);
			g_free (str);
		}
	}
	else {
		td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "None provided");
		xmlSetProp (td, BAD_CAST "class", BAD_CAST "error");
	}
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Authentication's parameters:");
	if (pinfo->auth_params) {
		GSList *list;
		if (pinfo->auth_params->holders) {
			td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
			for (list = pinfo->auth_params->holders; list; list = list->next) {
				gchar *str, *descr;
				GdaHolder *holder = GDA_HOLDER (list->data);
				g_object_get (G_OBJECT (holder), "description", &descr, NULL);
				if (descr)
					str = g_strdup_printf ("%s: %s", gda_holder_get_id (holder), descr);
				else
					str = g_strdup (gda_holder_get_id (holder));
				g_free (descr);
				xmlNewTextChild (td, NULL, BAD_CAST "div", BAD_CAST str);
				g_free (str);
			}
		}
		else
			td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "None required");
	}
	else {
		td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "None provided");
		xmlSetProp (td, BAD_CAST "class", BAD_CAST "error");
	}

	/* line 7 */
	GdaConnectionFeature f;
	string = NULL;
	tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Supported features:");
	for (f = 0; f < GDA_CONNECTION_FEATURE_LAST; f++) {
		if (gda_server_provider_supports_feature (prov, cnc, f)) {
			GEnumValue *ev;
			
			ev = g_enum_get_value ((GEnumClass *) g_type_class_ref (GDA_TYPE_CONNECTION_FEATURE), f);
			if (!string)
				string = g_string_new (ev->value_name);
			else
				g_string_append_printf (string, ", %s", ev->value_name);
		}
	}
	if (string) {
		xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST string->str);
		g_string_free (string, TRUE);
	}
	else
		xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "---");

	string = NULL;
	xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Unsupported features:");
	for (f = 0; f < GDA_CONNECTION_FEATURE_LAST; f++) {
		if (!gda_server_provider_supports_feature (prov, cnc, f)) {
			GEnumValue *ev;
			
			ev = g_enum_get_value ((GEnumClass *) g_type_class_ref (GDA_TYPE_CONNECTION_FEATURE), f);
			if (!string)
				string = g_string_new (ev->value_name);
			else
				g_string_append_printf (string, ", %s", ev->value_name);
		}
	}
	if (string) {
		xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST string->str);
		g_string_free (string, TRUE);
	}
	else
		xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "---");
		
	g_free (header_str);

	return TRUE;
}
Ejemplo n.º 21
0
static int
replace_attr(noit_console_closure_t ncct,
             noit_conf_t_userdata_t *info, struct _valid_attr_t *attrinfo,
             const char *value) {
  int i, cnt, rv = -1, active = 0;
  xmlXPathObjectPtr pobj = NULL;
  xmlXPathContextPtr xpath_ctxt = NULL;
  xmlNodePtr node;
  char xpath[1024], *path;

  path = info->path;
  if(!strcmp(path, "/")) path = "";

  noit_conf_xml_xpath(NULL, &xpath_ctxt);
  if(attrinfo->checks_fixate) {
    /* Only if checks will fixate this attribute shall we check for
     * child <check> nodes.
     * NOTE: this return nothing and "seems" okay if we are _in_
     *       a <check> node.  That case is handled below.
     */
    snprintf(xpath, sizeof(xpath), "/noit/%s//check[@uuid]", path);
    pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt);
    if(!pobj || pobj->type != XPATH_NODESET) goto out;
    cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
    for(i=0; i<cnt; i++) {
      uuid_t checkid;
      node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
      if(noit_conf_get_uuid(node, "@uuid", checkid)) {
        noit_check_t *check;
        check = noit_poller_lookup(checkid);
        if(check && NOIT_CHECK_LIVE(check)) active++;
      }
    }
    if(pobj) xmlXPathFreeObject(pobj);
  }
  snprintf(xpath, sizeof(xpath), "/noit/%s", path);
  pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt);
  if(!pobj || pobj->type != XPATH_NODESET) goto out;
  cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
  if(cnt != 1) {
    nc_printf(ncct, "Internal error: context node disappeared\n");
    goto out;
  }
  node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0);
  if(attrinfo->checks_fixate &&
     !strcmp((const char *)node->name, "check")) {
    uuid_t checkid;
    /* Detect if  we are actually a <check> node and attempting to
     * change something we shouldn't.
     * This is the counterpart noted above.
     */
    if(noit_conf_get_uuid(node, "@uuid", checkid)) {
      noit_check_t *check;
      check = noit_poller_lookup(checkid);
      if(check && NOIT_CHECK_LIVE(check)) active++;
    }
  }
  if(active) {
    nc_printf(ncct, "Cannot set '%s', it would effect %d live check(s)\n",
              attrinfo->name, active);
    goto out;
  }
  xmlUnsetProp(node, (xmlChar *)attrinfo->name);
  if(value)
    xmlSetProp(node, (xmlChar *)attrinfo->name, (xmlChar *)value);
  noit_conf_mark_changed();
  rv = 0;
 out:
  if(pobj) xmlXPathFreeObject(pobj);
  return rv;
}
Ejemplo n.º 22
0
/*
 * Set a node's 'name' attribute.  I don't think this is necessary.
 */
int xmlelf_set_name( xmlNodePtr node , char * name )
{
   if( ! node || !name )
      error_ret("null args",-1);
   xmlSetProp(node,"name",name);
}
Ejemplo n.º 23
0
int DEFAULT_CC
send_session(int client, int session_id, char* user)
{
	struct session_item* sess = NULL;
	xmlNodePtr node, node2;
	xmlDocPtr doc;
	xmlChar* version;
	xmlChar* response;
	xmlChar* session;
	xmlChar* id;
	xmlChar* id_value;
	xmlChar* username;
	xmlChar* username_value;
	xmlChar* status;
	xmlChar* status_value;

	log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[send_session]: "
			"request for session\n");

	lock_chain_acquire();
	if (user == NULL || user[0] == '\0')
	{
		sess = session_get_by_display(session_id);
	}
	else
	{
		sess = session_get_bydata(user);
	}
	lock_chain_release();

	if( sess == NULL && session_id != 0)
	{
		log_message(&(g_cfg->log), LOG_LEVEL_DEBUG, "sesman[send_session]: "
				"the session %i did not exist",session_id);

		sess = g_malloc(sizeof(struct session_item), 1);
		sess->display = session_id;
		sess->status = SESMAN_SESSION_STATUS_UNKNOWN;
		g_snprintf(sess->name, sizeof(sess->name), "UNKNOW");
	}
	version = xmlCharStrdup("1.0");
	doc = xmlNewDoc(version);
	if (doc == NULL)
	{
		log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[send_session]: "
				"Unable to create the document");
		if (sess != NULL)
		{
			g_free(sess);
		}
		return 1;
	}
	doc->encoding = xmlCharStrdup("UTF-8");
	response = xmlCharStrdup("response");
	session = xmlCharStrdup("session");
	node = xmlNewNode(NULL, response);
	node2 = xmlNewNode(NULL, session);

	if (sess != NULL)
	{
		char prop[128] = {0};
		g_sprintf(prop, "%i", sess->display);
		id = xmlCharStrdup("id");
		id_value = xmlCharStrdup(prop);
		username = xmlCharStrdup("username");
		username_value = xmlCharStrdup(sess->name);
		status = xmlCharStrdup("status");
		status_value = xmlCharStrdup(session_get_status_string(sess->status));

		xmlSetProp(node2, id, id_value);
		xmlSetProp(node2, username, username_value);
		xmlSetProp(node2, status, status_value );
		xmlAddChild(node, node2);
	}

	xmlDocSetRootElement(doc, node);
	xml_send_info(client, doc);

	xmlFree(response);
	xmlFree(session);
	xmlFree(version);

	xmlFreeDoc(doc);
	if (sess != NULL)
	{
		xmlFree(id);
		xmlFree(id_value);
		xmlFree(username);
		xmlFree(username_value);
		xmlFree(status);
		xmlFree(status_value);
		g_free(sess);
	}
	return 0;
}
Ejemplo n.º 24
0
/**
 * htmlSetMetaEncoding:
 * @doc:  the document
 * @encoding:  the encoding string
 *
 * Sets the current encoding in the Meta tags
 * NOTE: this will not change the document content encoding, just
 * the META flag associated.
 *
 * Returns 0 in case of success and -1 in case of error
 */
int
htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar *encoding) {
    htmlNodePtr cur, meta = NULL, head = NULL;
    const xmlChar *content = NULL;
    char newcontent[100];

    newcontent[0] = 0;

    if (doc == NULL)
	return(-1);

    /* html isn't a real encoding it's just libxml2 way to get entities */
    if (!xmlStrcasecmp(encoding, BAD_CAST "html"))
        return(-1);

    if (encoding != NULL) {
	_snprintf(newcontent, sizeof(newcontent), "text/html; charset=%s",
                (char *)encoding);
	newcontent[sizeof(newcontent) - 1] = 0;
    }

    cur = doc->children;

    /*
     * Search the html
     */
    while (cur != NULL) {
	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
	    if (xmlStrcasecmp(cur->name, BAD_CAST"html") == 0)
		break;
	    if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
		goto found_head;
	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)
		goto found_meta;
	}
	cur = cur->next;
    }
    if (cur == NULL)
	return(-1);
    cur = cur->children;

    /*
     * Search the head
     */
    while (cur != NULL) {
	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
	    if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
		break;
	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
                head = cur->parent;
		goto found_meta;
            }
	}
	cur = cur->next;
    }
    if (cur == NULL)
	return(-1);
found_head:
    head = cur;
    if (cur->children == NULL)
        goto create;
    cur = cur->children;

found_meta:
    /*
     * Search and update all the remaining the meta elements carrying
     * encoding informations
     */
    while (cur != NULL) {
	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
		xmlAttrPtr attr = cur->properties;
		int http;
		const xmlChar *value;

		content = NULL;
		http = 0;
		while (attr != NULL) {
		    if ((attr->children != NULL) &&
		        (attr->children->type == XML_TEXT_NODE) &&
		        (attr->children->next == NULL)) {
			value = attr->children->content;
			if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
			 && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
			    http = 1;
			else
                        {
                           if ((value != NULL) &&
                               (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
			       content = value;
                        }
		        if ((http != 0) && (content != NULL))
			    break;
		    }
		    attr = attr->next;
		}
		if ((http != 0) && (content != NULL)) {
		    meta = cur;
		    break;
		}

	    }
	}
	cur = cur->next;
    }
create:
    if (meta == NULL) {
        if ((encoding != NULL) && (head != NULL)) {
            /*
             * Create a new Meta element with the right attributes
             */

            meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
            if (head->children == NULL)
                xmlAddChild(head, meta);
            else
                xmlAddPrevSibling(head->children, meta);
            xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
            xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
        }
    } else {
        /* remove the meta tag if NULL is passed */
        if (encoding == NULL) {
            xmlUnlinkNode(meta);
            xmlFreeNode(meta);
        }
        /* change the document only if there is a real encoding change */
        else if (xmlStrcasestr(content, encoding) == NULL) {
            xmlSetProp(meta, BAD_CAST"content", BAD_CAST newcontent);
        }
    }


    return(0);
}
Ejemplo n.º 25
0
Archivo: admin.c Proyecto: krattai/AEBL
/* build an XML doc containing information about currently running sources.
 * If a mountpoint is passed then that source will not be added to the XML
 * doc even if the source is running */
xmlDocPtr admin_build_sourcelist (const char *mount)
{
    avl_node *node;
    source_t *source;
    xmlNodePtr xmlnode, srcnode;
    xmlDocPtr doc;
    char buf[22];
    time_t now = time(NULL);

    doc = xmlNewDoc (XMLSTR("1.0"));
    xmlnode = xmlNewDocNode (doc, NULL, XMLSTR("icestats"), NULL);
    xmlDocSetRootElement(doc, xmlnode);

    if (mount) {
        xmlNewChild (xmlnode, NULL, XMLSTR("current_source"), XMLSTR(mount));
    }

    node = avl_get_first(global.source_tree);
    while(node) {
        source = (source_t *)node->key;
        if (mount && strcmp (mount, source->mount) == 0)
        {
            node = avl_get_next (node);
            continue;
        }

        if (source->running || source->on_demand)
        {
            ice_config_t *config;
            mount_proxy *mountinfo;

            srcnode = xmlNewChild(xmlnode, NULL, XMLSTR("source"), NULL);
            xmlSetProp(srcnode, XMLSTR("mount"), XMLSTR(source->mount));

            xmlNewChild(srcnode, NULL, XMLSTR("fallback"), 
                    (source->fallback_mount != NULL)?
                    XMLSTR(source->fallback_mount):XMLSTR(""));
            snprintf (buf, sizeof(buf), "%lu", source->listeners);
            xmlNewChild(srcnode, NULL, XMLSTR("listeners"), XMLSTR(buf));

            config = config_get_config();
            mountinfo = config_find_mount (config, source->mount);
            if (mountinfo && mountinfo->auth)
            {
                xmlNewChild(srcnode, NULL, XMLSTR("authenticator"),
                        XMLSTR(mountinfo->auth->type));
            }
            config_release_config();

            if (source->running)
            {
                if (source->client) 
                {
                    snprintf (buf, sizeof(buf), "%lu",
                            (unsigned long)(now - source->con->con_time));
                    xmlNewChild (srcnode, NULL, XMLSTR("Connected"), XMLSTR(buf));
                }
                xmlNewChild (srcnode, NULL, XMLSTR("content-type"), 
                        XMLSTR(source->format->contenttype));
            }
        }
        node = avl_get_next(node);
    }
    return(doc);
}
Ejemplo n.º 26
0
void Settings::save()
{
	XOJ_CHECK_TYPE(Settings);

	if (this->timeoutId)
	{
		g_source_remove(this->timeoutId);
		this->timeoutId = 0;
	}

	xmlDocPtr doc;
	xmlNodePtr root;
	xmlNodePtr xmlNode;

	xmlIndentTreeOutput = TRUE;

	doc = xmlNewDoc((const xmlChar*) "1.0");
	if (doc == NULL)
	{
		return;
	}

	saveButtonConfig();

	/* Create metadata root */
	root = xmlNewDocNode(doc, NULL, (const xmlChar*) "settings", NULL);
	xmlDocSetRootElement(doc, root);
	xmlNodePtr com = xmlNewComment((const xmlChar*)
	                               "The Xournal++ settings file. Do not edit this file! "
	                               "The most settings are available in the Settings dialog, "
	                               "the others are commented in this file, but handle with care!");
	xmlAddPrevSibling(root, com);

	WRITE_BOOL_PROP(useXinput);
	WRITE_BOOL_PROP(presureSensitivity);
	WRITE_BOOL_PROP(ignoreCoreEvents);

	WRITE_STRING_PROP(selectedToolbar);
	WRITE_STRING_PROP(lastSavePath);
	WRITE_STRING_PROP(lastImagePath);

	WRITE_INT_PROP(displayDpi);
	WRITE_INT_PROP(mainWndWidth);
	WRITE_INT_PROP(mainWndHeight);
	WRITE_BOOL_PROP(maximized);

	WRITE_BOOL_PROP(showSidebar);
	WRITE_INT_PROP(sidebarWidth);

	WRITE_BOOL_PROP(sidebarOnRight);
	WRITE_BOOL_PROP(scrollbarOnLeft);
	WRITE_BOOL_PROP(showTwoPages);
	WRITE_BOOL_PROP(presentationMode);

	WRITE_STRING_PROP(fullscreenHideElements);
	WRITE_COMMENT("Which gui elements are hidden if you are in Fullscreen mode, separated by a colon (,)");

	WRITE_STRING_PROP(presentationHideElements);
	WRITE_COMMENT("Which gui elements are hidden if you are in Presentation mode, separated by a colon (,)");

	WRITE_BOOL_PROP(showBigCursor);

	if (this->scrollbarHideType == SCROLLBAR_HIDE_BOTH)
	{
		saveProperty((const char*) "scrollbarHideType", "both", root);
	}
	else if (this->scrollbarHideType == SCROLLBAR_HIDE_HORIZONTAL)
	{
		saveProperty((const char*) "scrollbarHideType", "horizontal", root);
	}
	else if (this->scrollbarHideType == SCROLLBAR_HIDE_VERTICAL)
	{
		saveProperty((const char*) "scrollbarHideType", "vertical", root);
	}
	else
	{
		saveProperty((const char*) "scrollbarHideType", "none", root);
	}


	WRITE_BOOL_PROP(autoloadPdfXoj);
	WRITE_COMMENT("Hides scroolbars in the main window, allowed values: \"none\", \"horizontal\", \"vertical\", \"both\"");

	WRITE_STRING_PROP(defaultSaveName);

	WRITE_STRING_PROP(visiblePageFormats);
	WRITE_COMMENT("This paper format is visible in the paper format dialog, separated by a colon");

	WRITE_BOOL_PROP(autosaveEnabled);
	WRITE_INT_PROP(autosaveTimeout);

	WRITE_BOOL_PROP(addHorizontalSpace);
	WRITE_BOOL_PROP(addVerticalSpace);

	WRITE_BOOL_PROP(fixXinput);

	WRITE_BOOL_PROP(enableLeafEnterWorkaround);
	WRITE_COMMENT("If Xournal crashes if you e.g. unplug your mouse set this to true. If you have input problems, you can turn it of with false.");

	String pageInsertType = pageInsertTypeToString(this->pageInsertType);
	WRITE_STRING_PROP(pageInsertType);

	WRITE_INT_PROP(pageBackgroundColor);
	WRITE_INT_PROP(selectionColor);

	WRITE_INT_PROP(pdfPageCacheSize);
	WRITE_COMMENT("The count of rendered PDF pages which will be cached.");

	WRITE_DOUBLE_PROP(widthMinimumMultiplier);
	WRITE_COMMENT("The multiplier for the pressure sensitivity of the pen");
	WRITE_DOUBLE_PROP(widthMaximumMultiplier);
	WRITE_COMMENT("The multiplier for the pressure sensitivity of the pen");

	xmlNodePtr xmlFont;
	xmlFont = xmlNewChild(root, NULL, (const xmlChar*) "property", NULL);
	xmlSetProp(xmlFont, (const xmlChar*) "name", (const xmlChar*) "font");
	xmlSetProp(xmlFont, (const xmlChar*) "font",
	           (const xmlChar*) this->font.getName().c_str());
	gchar* sSize = g_strdup_printf("%0.1lf", this->font.getSize());
	xmlSetProp(xmlFont, (const xmlChar*) "size", (const xmlChar*) sSize);
	g_free(sSize);

	std::map<String, SElement>::iterator it;
	for (it = data.begin(); it != data.end(); it++)
	{
		saveData(root, (*it).first, (*it).second);
	}

	xmlSaveFormatFile(filename.c_str(), doc, 1);
	xmlFreeDoc(doc);
}
Ejemplo n.º 27
0
static DiaSvgRenderer *
new_shape_renderer(DiagramData *data, const char *filename)
{
  ShapeRenderer *shape_renderer;
  DiaSvgRenderer *renderer;
  char *point;
  xmlNodePtr xml_node_ptr;
  gint i;
  gchar *png_filename;
  char *shapename, *dirname, *fullname;
  char *sheetname;
  char *basename;

  shape_renderer = g_object_new(SHAPE_TYPE_RENDERER, NULL);
  renderer = DIA_SVG_RENDERER (shape_renderer);

  renderer->filename = g_strdup(filename);

  renderer->dash_length = 1.0;
  renderer->dot_length = 0.2;
  renderer->saved_line_style = LINESTYLE_SOLID;
  /* keep everything unscaled, i.e. in Dia's scale default */
  renderer->scale = 1.0;

  /* set up the root node */
  renderer->doc = xmlNewDoc((const xmlChar *)"1.0");
  renderer->doc->encoding = xmlStrdup((const xmlChar *)"UTF-8");
  renderer->root = xmlNewDocNode(renderer->doc, NULL, (const xmlChar *)"shape", NULL);
  xmlNewNs(renderer->root,
                        (const xmlChar *)"http://www.daa.com.au/~james/dia-shape-ns", NULL);

  renderer->svg_name_space = xmlNewNs(renderer->root,
                                      (const xmlChar *)"http://www.w3.org/2000/svg", (const xmlChar *)"svg");
  xmlNewNs(renderer->root, (const xmlChar *)"http://www.w3.org/1999/xlink", (const xmlChar *)"xlink");
  renderer->doc->xmlRootNode = renderer->root;

  dirname = g_path_get_dirname(filename);
  sheetname = g_path_get_basename(dirname);
  basename = g_path_get_basename(filename);
  shapename = g_strndup(basename, strlen(basename)-6);
  g_free(basename);
  fullname = g_strdup_printf ("%s - %s", sheetname, shapename);
  g_free(dirname);
  g_free(sheetname);
  g_free(shapename);

  xmlNewChild(renderer->root, NULL, (const xmlChar *)"name", (xmlChar *) fullname);
  g_free(fullname);
  point = strrchr(filename, '.');
  i = (int)(point-filename);
  point = g_strndup(filename, i);
  png_filename = g_strdup_printf("%s.png",point);
  g_free(point);
  basename = g_path_get_basename(png_filename);
  xmlNewChild(renderer->root, NULL, (const xmlChar *)"icon", (xmlChar *) basename);
  g_free(basename);
  g_free(png_filename);
  shape_renderer->connection_root = xmlNewChild(renderer->root, NULL, (const xmlChar *)"connections", NULL);
  shape_renderer->design_connection = FALSE;
  xml_node_ptr = xmlNewChild(renderer->root, NULL, (const xmlChar *)"aspectratio",NULL);
  xmlSetProp(xml_node_ptr, (const xmlChar *)"type", (const xmlChar *)"fixed");
  renderer->root = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"svg", NULL);
    
  return renderer;
}
Ejemplo n.º 28
0
void Settings::saveData(xmlNodePtr root, String name, SElement& elem)
{
	XOJ_CHECK_TYPE(Settings);

	xmlNodePtr xmlNode = xmlNewChild(root, NULL, (const xmlChar*) "data", NULL);

	xmlSetProp(xmlNode, (const xmlChar*) "name", (const xmlChar*) name.c_str());

	std::map<String, SAttribute>::iterator it;
	for (it = elem.attributes().begin(); it != elem.attributes().end(); it++)
	{
		String aname = (*it).first;
		SAttribute& attrib = (*it).second;

		XOJ_CHECK_TYPE_OBJ(&attrib, SAttribute);

		String type;
		String value;

		if (attrib.type == ATTRIBUTE_TYPE_BOOLEAN)
		{
			type = "boolean";

			if (attrib.iValue)
			{
				value = "true";
			}
			else
			{
				value = "false";
			}
		}
		else if (attrib.type == ATTRIBUTE_TYPE_INT)
		{
			type = "int";

			char* tmp = g_strdup_printf("%i", attrib.iValue);
			value = tmp;
			g_free(tmp);
		}
		else if (attrib.type == ATTRIBUTE_TYPE_DOUBLE)
		{
			type = "double";

			char* tmp = g_strdup_printf("%lf", attrib.dValue);
			value = tmp;
			g_free(tmp);
		}
		else if (attrib.type == ATTRIBUTE_TYPE_INT_HEX)
		{
			type = "hex";

			char* tmp = g_strdup_printf("%06x", attrib.iValue);
			value = tmp;
			g_free(tmp);
		}
		else if (attrib.type == ATTRIBUTE_TYPE_STRING)
		{
			type = "string";
			value = attrib.sValue;
		}
		else
		{
			// Unknown type or empty attribute
			continue;
		}

		xmlNodePtr at;
		at = xmlNewChild(xmlNode, NULL, (const xmlChar*) "attribute", NULL);

		xmlSetProp(at, (const xmlChar*) "name", (const xmlChar*) aname.c_str());
		xmlSetProp(at, (const xmlChar*) "type", (const xmlChar*) type.c_str());
		xmlSetProp(at, (const xmlChar*) "value", (const xmlChar*) value.c_str());

		if (!attrib.comment.isEmpty())
		{
			xmlNodePtr com = xmlNewComment((const xmlChar*) attrib.comment.c_str());
			xmlAddPrevSibling(xmlNode, com);
		}
	}

	std::map<String, SElement>::iterator i;
	for (i = elem.children().begin(); i != elem.children().end(); i++)
	{
		saveData(xmlNode, (*i).first, (*i).second);
	}
}
Ejemplo n.º 29
0
void XmlNode::property(std::string n, long v)
{
    std::ostringstream s;
    s << v;
    xmlSetProp(node_, (xmlChar*) n.c_str(), (xmlChar*) s.str().c_str());
}
Ejemplo n.º 30
0
static xmlNodePtr
entry_dom_tree_create (GncEntry *entry)
{
    xmlNodePtr ret;
    Timespec ts;
    Account *acc;
    GncTaxTable *taxtable;
    GncOrder *order;
    GncInvoice *invoice;
    kvp_frame *kf;

    ret = xmlNewNode(NULL, BAD_CAST gnc_entry_string);
    xmlSetProp(ret, BAD_CAST "version", BAD_CAST entry_version_string);

    xmlAddChild(ret, guid_to_dom_tree(entry_guid_string,
                                      qof_instance_get_guid(QOF_INSTANCE(entry))));

    ts = gncEntryGetDate (entry);
    xmlAddChild(ret, timespec_to_dom_tree (entry_date_string, &ts));

    ts = gncEntryGetDateEntered (entry);
    xmlAddChild(ret, timespec_to_dom_tree (entry_dateentered_string, &ts));

    maybe_add_string (ret, entry_description_string,
                      gncEntryGetDescription (entry));
    maybe_add_string (ret, entry_action_string, gncEntryGetAction (entry));
    maybe_add_string (ret, entry_notes_string, gncEntryGetNotes (entry));

    maybe_add_numeric (ret, entry_qty_string, gncEntryGetQuantity (entry));

    /* cust invoice */

    acc = gncEntryGetInvAccount (entry);
    if (acc)
        xmlAddChild (ret, guid_to_dom_tree (entry_invacct_string,
                                            qof_instance_get_guid(QOF_INSTANCE(acc))));

    maybe_add_numeric (ret, entry_iprice_string, gncEntryGetInvPrice (entry));

    maybe_add_numeric (ret, entry_idiscount_string, gncEntryGetInvDiscount (entry));

    invoice = gncEntryGetInvoice (entry);
    if (invoice)
    {
        xmlAddChild (ret, guid_to_dom_tree (entry_invoice_string,
                                            qof_instance_get_guid(QOF_INSTANCE(invoice))));

        xmlAddChild(ret, text_to_dom_tree(entry_idisctype_string,
                                          gncAmountTypeToString (
                                              gncEntryGetInvDiscountType (entry))));
        xmlAddChild(ret, text_to_dom_tree(entry_idischow_string,
                                          gncEntryDiscountHowToString (
                                              gncEntryGetInvDiscountHow (entry))));

        xmlAddChild(ret, int_to_dom_tree(entry_itaxable_string,
                                         gncEntryGetInvTaxable (entry)));
        xmlAddChild(ret, int_to_dom_tree(entry_itaxincluded_string,
                                         gncEntryGetInvTaxIncluded (entry)));
    }

    taxtable = gncEntryGetInvTaxTable (entry);
    if (taxtable)
        xmlAddChild (ret, guid_to_dom_tree (entry_itaxtable_string,
                                            qof_instance_get_guid (QOF_INSTANCE(taxtable))));

    /* vendor bills */

    acc = gncEntryGetBillAccount (entry);
    if (acc)
        xmlAddChild (ret, guid_to_dom_tree (entry_billacct_string,
                                            qof_instance_get_guid (QOF_INSTANCE(acc))));

    maybe_add_numeric (ret, entry_bprice_string, gncEntryGetBillPrice (entry));

    invoice = gncEntryGetBill (entry);
    if (invoice)
    {
        GncOwner *owner;
        xmlAddChild (ret, guid_to_dom_tree (entry_bill_string,
                                            qof_instance_get_guid(QOF_INSTANCE(invoice))));
        xmlAddChild(ret, int_to_dom_tree(entry_billable_string,
                                         gncEntryGetBillable (entry)));
        owner = gncEntryGetBillTo (entry);
        if (owner && owner->owner.undefined != NULL)
            xmlAddChild (ret, gnc_owner_to_dom_tree (entry_billto_string, owner));

        xmlAddChild(ret, int_to_dom_tree(entry_btaxable_string,
                                         gncEntryGetBillTaxable (entry)));
        xmlAddChild(ret, int_to_dom_tree(entry_btaxincluded_string,
                                         gncEntryGetBillTaxIncluded (entry)));
        maybe_add_string (ret, entry_billpayment_string,
                          gncEntryPaymentTypeToString (gncEntryGetBillPayment (entry)));
    }

    taxtable = gncEntryGetBillTaxTable (entry);
    if (taxtable)
        xmlAddChild (ret, guid_to_dom_tree (entry_btaxtable_string,
                                            qof_instance_get_guid (QOF_INSTANCE(taxtable))));

    /* Other stuff */

    order = gncEntryGetOrder (entry);
    if (order)
        xmlAddChild (ret, guid_to_dom_tree (entry_order_string,
                                            qof_instance_get_guid(QOF_INSTANCE (order))));

    kf = qof_instance_get_slots (QOF_INSTANCE(entry));
    if (kf)
    {
        xmlNodePtr kvpnode = kvp_frame_to_dom_tree(entry_slots_string, kf);
        if (kvpnode)
        {
            xmlAddChild(ret, kvpnode);
        }
    }

    return ret;
}