/** * 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; } }
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"); }
void XmlNode::property(std::string n, std::string v) { ::cleanXml( n ); ::cleanXml( v ); xmlSetProp(node_, (xmlChar*) n.c_str(), (xmlChar*) v.c_str()); }
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; }
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; }
void XmlNodo::setPropiedad(const std::string& nombre, const std::string& valor) { xmlSetProp(nodo, (const xmlChar*) nombre.c_str(), (const xmlChar*) valor.c_str()); }
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; }
/* * 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); }
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; }
/*! @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; } }
/* * 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; } }
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; }
/** * 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; }
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); }
void Epair_XMLWrite( epair_t *pEpair, xmlNodePtr epair ){ xmlSetProp( epair, (xmlChar *)"key", (xmlChar *)pEpair->key ); xmlSetProp( epair, (xmlChar *)"value", (xmlChar *)pEpair->value ); }
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); }
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 ); }
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; }
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; }
/* * 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); }
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; }
/** * 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); }
/* 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); }
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); }
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; }
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); } }
void XmlNode::property(std::string n, long v) { std::ostringstream s; s << v; xmlSetProp(node_, (xmlChar*) n.c_str(), (xmlChar*) s.str().c_str()); }
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; }