void bg_nle_media_list_save(bg_nle_media_list_t * list, xmlNodePtr node) { char * tmp_string; int i; xmlNodePtr child; xmlNodePtr grandchild; if(list->open_path) { child = xmlNewTextChild(node, (xmlNsPtr)0, (xmlChar*)open_path_name, NULL); xmlAddChild(child, BG_XML_NEW_TEXT(list->open_path)); } if(list->num_files) { child = xmlNewTextChild(node, (xmlNsPtr)0, (xmlChar*)files_name, NULL); tmp_string = bg_sprintf("%d", list->num_files); BG_XML_SET_PROP(child, "num", tmp_string); free(tmp_string); for(i = 0; i < list->num_files; i++) { grandchild = xmlNewTextChild(child, (xmlNsPtr)0, (xmlChar*)file_name, NULL); bg_nle_file_save(grandchild, list->files[i]); } } }
static void save_audio_stream(xmlNodePtr node, bg_nle_audio_stream_t * s) { xmlNodePtr child; char * tmp_string; /* Timescale */ tmp_string = bg_sprintf("%d", s->timescale); BG_XML_SET_PROP(node, "scale", tmp_string); free(tmp_string); /* Offset */ child = xmlNewTextChild(node, (xmlNsPtr)0, (xmlChar*)start_time_name, NULL); tmp_string = bg_sprintf("%"PRId64, s->start_time); xmlAddChild(child, BG_XML_NEW_TEXT(tmp_string)); free(tmp_string); /* Duration */ child = xmlNewTextChild(node, (xmlNsPtr)0, (xmlChar*)duration_name, NULL); tmp_string = bg_sprintf("%"PRId64, s->duration); xmlAddChild(child, BG_XML_NEW_TEXT(tmp_string)); free(tmp_string); }
static void save_video_stream(xmlNodePtr node, bg_nle_video_stream_t * s) { char * tmp_string; xmlNodePtr child; /* Timescale */ tmp_string = bg_sprintf("%d", s->timescale); BG_XML_SET_PROP(node, "scale", tmp_string); free(tmp_string); if(s->tc_format.int_framerate) { child = xmlNewTextChild(node, (xmlNsPtr)0, (xmlChar*)tc_rate_name, NULL); tmp_string = bg_sprintf("%d", s->tc_format.int_framerate); xmlAddChild(child, BG_XML_NEW_TEXT(tmp_string)); free(tmp_string); } if(s->tc_format.flags) { child = xmlNewTextChild(node, (xmlNsPtr)0, (xmlChar*)tc_flags_name, NULL); tmp_string = bg_sprintf("%d", s->tc_format.flags); xmlAddChild(child, BG_XML_NEW_TEXT(tmp_string)); free(tmp_string); } }
int main (int argc, char **argv) { xmlDocPtr pdoc = NULL; xmlNodePtr proot_node = NULL,pnode = NULL,pnode1 = NULL; // 创建一个新文档并设置 root 节点 // 一个 XML 文件只有一个 root 节点 pdoc = xmlNewDoc (BAD_CAST "1.0"); proot_node = xmlNewNode (NULL, BAD_CAST "根节点"); xmlNewProp (proot_node, BAD_CAST "版本", BAD_CAST "1.0"); xmlDocSetRootElement (pdoc, proot_node); pnode = xmlNewNode (NULL, BAD_CAST "子节点1"); // 创建上面 pnode 的子节点 xmlNewChild (pnode, NULL, BAD_CAST "子子节点1", BAD_CAST "信息"); // 添加子节点到 root 节点 xmlAddChild (proot_node, pnode); pnode1 = xmlNewNode (NULL, BAD_CAST "子子节点1"); xmlAddChild (pnode, pnode1); xmlAddChild (pnode1,xmlNewText (BAD_CAST "这是更低的节点,子子子节点1")); // 还可以这样直接创建一个子节点到 root 节点上 xmlNewTextChild (proot_node, NULL, BAD_CAST "子节点2", BAD_CAST "子节点2的内容"); xmlNewTextChild (proot_node, NULL, BAD_CAST "子节点3", BAD_CAST "子节点3的内容"); // 保存 xml 为文件,如果没有给出文件名参数,就输出到标准输出 xmlSaveFormatFileEnc (argc > 1 ? argv[1]:"-", pdoc, "UTF-8", 1); // 释放资源 xmlFreeDoc (pdoc); xmlCleanupParser (); xmlMemoryDump (); return 0; }
static void xml_subprocess_output(pcmk__output_t *out, int exit_status, const char *proc_stdout, const char *proc_stderr) { xmlNodePtr node, child_node; char *rc_as_str = NULL; xml_private_t *priv = out->priv; CRM_ASSERT(priv != NULL); rc_as_str = crm_itoa(exit_status); node = xmlNewNode(g_queue_peek_tail(priv->parent_q), (pcmkXmlStr) "command"); xmlSetProp(node, (pcmkXmlStr) "code", (pcmkXmlStr) rc_as_str); if (proc_stdout != NULL) { child_node = xmlNewTextChild(node, NULL, (pcmkXmlStr) "output", (pcmkXmlStr) proc_stdout); xmlSetProp(child_node, (pcmkXmlStr) "source", (pcmkXmlStr) "stdout"); } if (proc_stderr != NULL) { child_node = xmlNewTextChild(node, NULL, (pcmkXmlStr) "output", (pcmkXmlStr) proc_stderr); xmlSetProp(node, (pcmkXmlStr) "source", (pcmkXmlStr) "stderr"); } pcmk__xml_add_node(out, node); free(rc_as_str); }
void save_languages_to_xml (language * languages, int size) { xmlDocPtr doc; xmlNodePtr parent, child; xmlXPathContextPtr xpathCtx; xmlXPathObjectPtr xpathObj; int i; xmlKeepBlanksDefault(0); doc = xmlNewDoc (BAD_CAST "1.0"); parent = xmlNewNode(NULL, "languages"); xmlDocSetRootElement(doc, parent); for(i=0; i<size; i++) { child = xmlNewTextChild (parent, NULL, "lang", NULL); xmlNewTextChild (child, NULL, "name", languages->name); xmlNewTextChild (child, NULL, "code", languages->code); xmlNewTextChild (child, NULL, "flag", languages->flag); languages++; } xmlSaveFormatFile ("src/config/languages.xml", doc, 1); xmlFreeDoc(doc); }
static void battmon_write_config(Control *ctrl, xmlNodePtr parent) { xmlNodePtr root; char value[MAXSTRLEN + 1]; t_battmon *battmon = (t_battmon *) ctrl->data; root = xmlNewTextChild(parent, NULL, "BatteryMonitor", NULL); /* Display Percentage */ g_snprintf(value, 2, "%d", battmon->options.display_percentage); xmlSetProp(root, "display_percentage", value); /* Display Percentage in Tooltip */ g_snprintf(value, 2, "%d", battmon->options.tooltip_display_percentage); xmlSetProp(root, "tooltip_display_percentage", value); /* Display Time in Tooltip */ g_snprintf(value, 2, "%d", battmon->options.tooltip_display_time); xmlSetProp(root, "tooltip_display_time", value); /* Low Percentage */ g_snprintf(value, 4, "%d", battmon->options.low_percentage); xmlSetProp(root, "low_percentage", value); /* Critical Percentage */ g_snprintf(value, 4, "%d", battmon->options.critical_percentage); xmlSetProp(root, "critical_percentage", value); /* Action on Low */ g_snprintf(value, 2, "%d", battmon->options.action_on_low); xmlSetProp(root, "action_on_low", value); /* Action on Critical */ g_snprintf(value, 2, "%d", battmon->options.action_on_critical); xmlSetProp(root, "action_on_critical", value); /* Command on Low */ xmlNewTextChild(root, NULL, "command_on_low", battmon->options.command_on_low); /* Command on Critical */ xmlNewTextChild(root, NULL, "command_on_critical", battmon->options.command_on_critical); }
xmlNodePtr playlist_render_xspf(playlist_t *playlist) { xmlNodePtr rootnode, tracklist, tracknode; playlist_track_t *track; if (!playlist) return NULL; rootnode = xmlNewNode(NULL, XMLSTR("playlist")); xmlSetProp(rootnode, XMLSTR("version"), XMLSTR("1")); xmlSetProp(rootnode, XMLSTR("xmlns"), XMLSTR("http://xspf.org/ns/0/")); tracklist = xmlNewNode(NULL, XMLSTR("trackList")); xmlAddChild(rootnode, tracklist); track = playlist->first; while (track) { tracknode = xmlNewNode(NULL, XMLSTR("track")); xmlAddChild(tracklist, tracknode); /* TODO: Handle meta data */ if (track->title) xmlNewTextChild(tracknode, NULL, XMLSTR("title"), XMLSTR(track->title)); if (track->creator) xmlNewTextChild(tracknode, NULL, XMLSTR("creator"), XMLSTR(track->creator)); if (track->album) xmlNewTextChild(tracknode, NULL, XMLSTR("album"), XMLSTR(track->album)); if (track->trackNum) xmlNewTextChild(tracknode, NULL, XMLSTR("trackNum"), XMLSTR(track->trackNum)); track = track->next; } return rootnode; }
static xmlNodePtr organization_to_xmlnode (GDataEntryOrganization *organization) { xmlNodePtr organization_node; organization_node = xmlNewNode(NULL, (xmlChar *)"organization"); xmlSetNs (organization_node, xmlNewNs (organization_node, NULL, (xmlChar *)"gd")); if (organization->rel) xmlSetProp (organization_node, (xmlChar *)"rel", (xmlChar *)organization->rel); if (organization->label) xmlSetProp (organization_node, (xmlChar *)"label", (xmlChar *)organization->label); if (organization->primary) xmlSetProp (organization_node, (xmlChar *)"primary", (xmlChar *)"true"); if (organization->name) xmlNewTextChild (organization_node, NULL, (xmlChar *)"orgName", (xmlChar *)organization->name); if (organization->title) xmlNewTextChild (organization_node, NULL, (xmlChar *)"orgTitle", (xmlChar *)organization->title); return organization_node; }
static void monitor_write_config(Control *ctrl, xmlNodePtr parent) { xmlNodePtr root; char value[20]; t_global_monitor *global; global = (t_global_monitor *)ctrl->data; root = xmlNewTextChild(parent, NULL, MONITOR_ROOT, NULL); g_snprintf(value, 2, "%d", global->monitor->options.use_label); xmlSetProp(root, "Use_Label", value); g_snprintf(value, 8, "#%02X%02X%02X", (guint)global->monitor->options.color[IN].red >> 8, (guint)global->monitor->options.color[IN].green >> 8, (guint)global->monitor->options.color[IN].blue >> 8); xmlSetProp(root, "Color_In", value); g_snprintf(value, 8, "#%02X%02X%02X", (guint)global->monitor->options.color[OUT].red >> 8, (guint)global->monitor->options.color[OUT].green >> 8, (guint)global->monitor->options.color[OUT].blue >> 8); xmlSetProp(root, "Color_Out", value); if (global->monitor->options.label_text) { xmlSetProp(root, "Text", global->monitor->options.label_text); } else { xmlSetProp(root, "Text", DEFAULT_TEXT); } if (global->monitor->options.network_device) { xmlSetProp(root, "Network_Device", global->monitor->options.network_device); } else { xmlSetProp(root, "Network_Device", DEFAULT_DEVICE); } g_snprintf(value, 20, "%lu", global->monitor->options.max[IN]); xmlSetProp(root, "Max_In", value); g_snprintf(value, 20, "%lu", global->monitor->options.max[OUT]); xmlSetProp(root, "Max_Out", value); g_snprintf(value, 2, "%d", global->monitor->options.auto_max); xmlSetProp(root, "Auto_Max", value); g_snprintf(value, 20, "%d", global->monitor->options.update_interval); xmlSetProp(root, "Update_Interval", value); root = xmlNewTextChild(parent, NULL, MONITOR_ROOT, NULL); }
void bg_upnp_device_description_add_icon(xmlDocPtr ptr, const char * mimetype, int width, int height, int depth, const char * url) { char * tmp_string; xmlNodePtr iconlist; xmlNodePtr icon; xmlNodePtr node = get_device_node(ptr); iconlist = bg_xml_find_node_child(node, "iconList"); if(!iconlist) iconlist = xmlNewTextChild(node, NULL, (xmlChar*)"iconList", NULL); icon = xmlNewTextChild(iconlist, NULL, (xmlChar*)"icon", NULL); bg_xml_append_child_node(icon, "mimetype", mimetype); tmp_string = bg_sprintf("%d", width); bg_xml_append_child_node(icon, "width", tmp_string); free(tmp_string); tmp_string = bg_sprintf("%d", height); bg_xml_append_child_node(icon, "height", tmp_string); free(tmp_string); tmp_string = bg_sprintf("%d", depth); bg_xml_append_child_node(icon, "depth", tmp_string); free(tmp_string); bg_xml_append_child_node(icon, "url", url); }
static xmlNodePtr add_group (GPInstructLessonElementGroup *group, xmlNodePtr parent_node) { GPInstructLessonElement *curr_lesson_element; GList *lesson_elements; GList *curr_lesson_elements; xmlNodePtr current_node = xmlNewTextChild (parent_node, NULL, BAD_CAST "group", NULL); xmlSetProp (current_node, BAD_CAST "title", BAD_CAST gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (group))); xmlSetProp (current_node, BAD_CAST "single-score", gpinstruct_lesson_element_group_get_single_score (group)?BAD_CAST "true":BAD_CAST "false"); xmlSetProp (current_node, BAD_CAST "single-directions", gpinstruct_lesson_element_group_get_single_directions (group)?BAD_CAST "true":BAD_CAST "false"); xmlNewTextChild (current_node, NULL, BAD_CAST "directions", BAD_CAST gpinstruct_lesson_element_group_get_directions (group)); lesson_elements = gpinstruct_lesson_element_group_get_lesson_elements (group); curr_lesson_elements = lesson_elements; while (curr_lesson_elements) { curr_lesson_element = GPINSTRUCT_LESSON_ELEMENT (curr_lesson_elements->data); if (GPINSTRUCT_IS_LESSON_DISCUSSION (curr_lesson_element)) add_discussion (GPINSTRUCT_LESSON_DISCUSSION (curr_lesson_element), current_node); else if (GPINSTRUCT_IS_LESSON_READING (curr_lesson_element)) add_reading (GPINSTRUCT_LESSON_READING (curr_lesson_element), current_node); else if (GPINSTRUCT_IS_LESSON_TEST_MULTI_CHOICE (curr_lesson_element)) add_multi_choice_test (GPINSTRUCT_LESSON_TEST_MULTI_CHOICE (curr_lesson_element), current_node); else if (GPINSTRUCT_IS_LESSON_TEST_WORD_POOL (curr_lesson_element)) add_word_pool_test (GPINSTRUCT_LESSON_TEST_WORD_POOL (curr_lesson_element), current_node); else if (GPINSTRUCT_IS_LESSON_TEST_ORDER (curr_lesson_element)) add_order_test (GPINSTRUCT_LESSON_TEST_ORDER (curr_lesson_element), current_node); else if (GPINSTRUCT_IS_LESSON_TEST_TEXT (curr_lesson_element)) add_text_test (GPINSTRUCT_LESSON_TEST_TEXT (curr_lesson_element), current_node); else if (GPINSTRUCT_IS_LESSON_TEST_SCRAMBLED (curr_lesson_element)) add_scrambled_test (GPINSTRUCT_LESSON_TEST_SCRAMBLED (curr_lesson_element), current_node); curr_lesson_elements = curr_lesson_elements->next; } g_list_free (lesson_elements); return current_node; }
static gboolean chatroom_manager_file_save (EmpathyChatroomManager *manager) { EmpathyChatroomManagerPriv *priv; xmlDocPtr doc; xmlNodePtr root; GList *l; priv = GET_PRIV (manager); priv->writing = TRUE; doc = xmlNewDoc ((const xmlChar *) "1.0"); root = xmlNewNode (NULL, (const xmlChar *) "chatrooms"); xmlDocSetRootElement (doc, root); for (l = priv->chatrooms; l; l = l->next) { EmpathyChatroom *chatroom; xmlNodePtr node; const gchar *account_id; chatroom = l->data; if (!empathy_chatroom_is_favorite (chatroom)) continue; account_id = tp_proxy_get_object_path (empathy_chatroom_get_account ( chatroom)); node = xmlNewChild (root, NULL, (const xmlChar *) "chatroom", NULL); xmlNewTextChild (node, NULL, (const xmlChar *) "name", (const xmlChar *) empathy_chatroom_get_name (chatroom)); xmlNewTextChild (node, NULL, (const xmlChar *) "room", (const xmlChar *) empathy_chatroom_get_room (chatroom)); xmlNewTextChild (node, NULL, (const xmlChar *) "account", (const xmlChar *) account_id); xmlNewTextChild (node, NULL, (const xmlChar *) "auto_connect", empathy_chatroom_get_auto_connect (chatroom) ? (const xmlChar *) "yes" : (const xmlChar *) "no"); xmlNewTextChild (node, NULL, (const xmlChar *) "always_urgent", empathy_chatroom_is_always_urgent (chatroom) ? (const xmlChar *) "yes" : (const xmlChar *) "no"); } /* Make sure the XML is indented properly */ xmlIndentTreeOutput = 1; DEBUG ("Saving file:'%s'", priv->file); xmlSaveFormatFileEnc (priv->file, doc, "utf-8", 1); xmlFreeDoc (doc); xmlMemoryDump (); priv->writing = FALSE; return TRUE; }
static void uwsgi_webdav_add_a_prop(xmlNode *node, char *opt, xmlNode *req_prop, int type, char *force_name) { char *first_space = strchr(opt, ' '); if (!first_space) return; *first_space = 0; char *second_space = strchr(first_space + 1, ' '); xmlNode *new_node = NULL; char *ns = opt; if (!force_name) force_name = first_space + 1; else { ns = "DAV:"; } if (second_space) { *second_space = 0; if (!uwsgi_webdav_prop_requested(req_prop, ns, force_name)) { *first_space = ' '; *second_space = ' '; return; } // href if (type == 1) { new_node = xmlNewChild(node, NULL, BAD_CAST first_space + 1, NULL); xmlNewTextChild(new_node, NULL, BAD_CAST "href", BAD_CAST second_space + 1); } // comp else if (type == 2) { new_node = xmlNewChild(node, NULL, BAD_CAST first_space + 1, NULL); char *comps = uwsgi_str(second_space + 1); char *p = strtok(comps, ","); while(p) { xmlNode *comp = xmlNewChild(new_node, NULL, BAD_CAST "comp", NULL); xmlNewProp(comp, BAD_CAST "name", BAD_CAST p); p = strtok(NULL, ","); } free(comps); } else { if (!uwsgi_webdav_prop_requested(req_prop, ns, first_space + 1)) { *first_space = ' '; *second_space = ' '; return; } new_node = xmlNewTextChild(node, NULL, BAD_CAST first_space + 1, BAD_CAST second_space + 1); } *second_space = ' '; } else { if (!uwsgi_webdav_prop_requested(req_prop, ns, force_name)) { *first_space = ' '; return; } new_node = xmlNewChild(node, NULL, BAD_CAST first_space + 1, NULL); } xmlNsPtr x_ns = xmlNewNs(new_node, BAD_CAST opt, NULL); xmlSetNs(new_node, x_ns); *first_space = ' '; }
static int build_key (pskc_key_t * kp, xmlNodePtr keyp) { const char *id = pskc_get_key_id (kp); const char *alg = pskc_get_key_algorithm (kp); const char *issuer = pskc_get_key_issuer (kp); const char *userid = pskc_get_key_userid (kp); const char *keyprofileid = pskc_get_key_profileid (kp); const char *keyreference = pskc_get_key_reference (kp); const char *friendlyname = pskc_get_key_friendlyname (kp); xmlNodePtr key; int rc; key = xmlNewChild (keyp, NULL, BAD_CAST "Key", NULL); if (id && xmlNewProp (key, BAD_CAST "Id", BAD_CAST id) == NULL) return PSKC_XML_ERROR; if (alg && xmlNewProp (key, BAD_CAST "Algorithm", BAD_CAST alg) == NULL) return PSKC_XML_ERROR; if (issuer && xmlNewTextChild (key, NULL, BAD_CAST "Issuer", BAD_CAST issuer) == NULL) return PSKC_XML_ERROR; rc = build_algparm (kp, key); if (rc != PSKC_OK) return rc; if (keyprofileid && xmlNewTextChild (key, NULL, BAD_CAST "KeyProfileId", BAD_CAST keyprofileid) == NULL) return PSKC_XML_ERROR; if (keyreference && xmlNewTextChild (key, NULL, BAD_CAST "KeyReference", BAD_CAST keyreference) == NULL) return PSKC_XML_ERROR; if (friendlyname && xmlNewTextChild (key, NULL, BAD_CAST "FriendlyName", BAD_CAST friendlyname) == NULL) return PSKC_XML_ERROR; rc = build_data (kp, key); if (rc != PSKC_OK) return rc; if (userid && xmlNewTextChild (key, NULL, BAD_CAST "UserId", BAD_CAST userid) == NULL) return PSKC_XML_ERROR; rc = build_policy (kp, key); if (rc != PSKC_OK) return rc; return PSKC_OK; }
int LocalPackage::injectFile() { if (!dialogMode && verbose) say(string(_("Injecting file") + filename + "\n").c_str()); internal=true; // Injecting data from file! // If any of functions fails (e.g. return!=0) - break process and return failure code (!=0); //int ret=0; //mDebug("local_package.cpp: injectFile(): start"); //mDebug("get_xml"); if (get_xml()!=0) { //mDebug("local_package.cpp: injectFile(): get_xml FAILED"); return -3; } if (getExtension(filename)=="spkg") { //printf("Source package detected, adding to XML\n"); xmlNewTextChild(_packageXMLNode, NULL, (const xmlChar *)"type", (const xmlChar *)"source"); data.set_type(PKGTYPE_SOURCE); } if (getExtension(filename)=="tgz" || getExtension(filename) == "txz" || getExtension(filename) == "tlz" ||getExtension(filename) == "tbz" ) { xmlNewTextChild(_packageXMLNode, NULL, (const xmlChar *)"type", (const xmlChar *)"binary"); data.set_type(PKGTYPE_BINARY); } //mDebug("get_size()\n"); if (get_size()!=0) { mDebug("local_package.cpp: injectFile(): get_size() FAILED"); return -1; } //mDebug("create_md5\n"); if (create_md5()!=0) { mDebug("local_package.cpp: injectFile(): create_md5 FAILED"); return -2; } //mDebug("set_additional_data\n"); //mDebug("local_packaige.cpp: injectFile(): filename is "+ filename); data.set_filename(filename); if (set_additional_data()!=0) { mDebug("local_package.cpp: injectFile(): set_additional_data FAILED"); return -6; } delete_tmp_files(); //mDebug("local_package.cpp: injectFile(): end"); return 0; }
int messageCreateClientAuthentication( unsigned char *masterkeySignature, int signatureSize, char *name, int nameSize, char *numBI, int numBISize, char *userName, int userNameSize, char *hostName, int hostNameSize, char *message, int messageMaxSize) { xmlChar *s; xmlDocPtr doc = NULL; /* document pointer */ xmlNodePtr root_node = NULL;/* node pointers */ int result; int messageSize; char *sigBase64; sigBase64 = b64encode(masterkeySignature, signatureSize); LIBXML_TEST_VERSION; doc = xmlNewDoc(BAD_CAST "1.0"); root_node = xmlNewNode(NULL, BAD_CAST "authentication"); xmlDocSetRootElement(doc, root_node); xmlSetProp(root_node, BAD_CAST "type", BAD_CAST "clientAuthentication"); xmlNewChild(root_node, NULL, BAD_CAST "secretSignature",BAD_CAST sigBase64); root_node = xmlNewChild(root_node, NULL,BAD_CAST "clientInfo", NULL); xmlNewTextChild(root_node, NULL, BAD_CAST "nBI",BAD_CAST numBI); xmlNewTextChild(root_node, NULL, BAD_CAST "name",BAD_CAST name); xmlNewTextChild(root_node, NULL, BAD_CAST "userName",BAD_CAST userName); xmlNewTextChild(root_node, NULL, BAD_CAST "hostName",BAD_CAST hostName); xmlDocDumpMemory(doc, &s, &messageSize); if( messageSize + 1 <= messageMaxSize) { strcpy((char *) message, (char *) s); result = messageSize + 1; } else result = -1; free(sigBase64); xmlFree(s); xmlFreeDoc(doc); xmlCleanupParser(); return result; }
void subscription_to_xml (subscriptionPtr subscription, xmlNodePtr xml) { gchar *tmp; xmlNewTextChild (xml, NULL, "feedSource", subscription_get_source (subscription)); xmlNewTextChild (xml, NULL, "feedOrigSource", subscription_get_orig_source (subscription)); tmp = g_strdup_printf ("%d", subscription_get_default_update_interval (subscription)); xmlNewTextChild (xml, NULL, "feedUpdateInterval", tmp); g_free (tmp); tmp = g_strdup_printf ("%d", subscription->discontinued?1:0); xmlNewTextChild (xml, NULL, "feedDiscontinued", tmp); g_free (tmp); if (subscription->updateError) xmlNewTextChild (xml, NULL, "updateError", subscription->updateError); if (subscription->httpError) { xmlNewTextChild (xml, NULL, "httpError", subscription->httpError); tmp = g_strdup_printf ("%d", subscription->httpErrorCode); xmlNewTextChild (xml, NULL, "httpErrorCode", tmp); g_free (tmp); } if (subscription->filterError) xmlNewTextChild (xml, NULL, "filterError", subscription->filterError); metadata_add_xml_nodes (subscription->metadata, xml); }
int LocalPackage::get_size() { string csize, isize; struct stat fstat; stat(filename.c_str(), &fstat); isize = getExtractedSize(filename); data.set_installed_size(isize); csize = IntToStr(fstat.st_size); data.set_compressed_size(csize); xmlNewTextChild(_packageXMLNode, NULL, (const xmlChar *)"compressed_size", (const xmlChar *)csize.c_str()); xmlNewTextChild(_packageXMLNode, NULL, (const xmlChar *)"installed_size", (const xmlChar *)isize.c_str()); return 0; }
xmlNodePtr gnc_transaction_dom_tree_create(Transaction *trn) { xmlNodePtr ret; gchar *str = NULL; ret = xmlNewNode(NULL, BAD_CAST "gnc:transaction"); xmlSetProp(ret, BAD_CAST "version", BAD_CAST transaction_version_string); xmlAddChild(ret, guid_to_dom_tree("trn:id", xaccTransGetGUID(trn))); xmlAddChild(ret, commodity_ref_to_dom_tree("trn:currency", xaccTransGetCurrency(trn))); str = g_strdup (xaccTransGetNum(trn)); if (str && (g_strcmp0(str, "") != 0)) { xmlNewTextChild(ret, NULL, BAD_CAST "trn:num", checked_char_cast (str)); } g_free (str); add_timespec(ret, "trn:date-posted", xaccTransRetDatePostedTS(trn), TRUE); add_timespec(ret, "trn:date-entered", xaccTransRetDateEnteredTS(trn), TRUE); str = g_strdup (xaccTransGetDescription(trn)); if (str) { xmlNewTextChild(ret, NULL, BAD_CAST "trn:description", checked_char_cast (str)); } g_free (str); { xmlNodePtr kvpnode = kvp_frame_to_dom_tree("trn:slots", xaccTransGetSlots(trn)); if (kvpnode) { xmlAddChild(ret, kvpnode); } } add_trans_splits(ret, trn); return ret; }
void oval_sysent_to_dom(struct oval_sysent *sysent, xmlDoc * doc, xmlNode * parent) { struct oval_record_field_iterator *rf_itr; xmlNsPtr ent_ns = parent->ns; xmlNodePtr root_node = xmlDocGetRootElement(doc); xmlNode *sysent_tag = NULL; char *tagname = oval_sysent_get_name(sysent); char *content = oval_sysent_get_value(sysent); bool mask = oval_sysent_get_mask(sysent); /* omit the value in oval_results if mask=true */ if (mask && !xmlStrcmp(root_node->name, BAD_CAST OVAL_ROOT_ELM_RESULTS)) { sysent_tag = xmlNewTextChild(parent, ent_ns, BAD_CAST tagname, BAD_CAST ""); } else { sysent_tag = xmlNewTextChild(parent, ent_ns, BAD_CAST tagname, BAD_CAST content); } if (mask) { xmlNewProp(sysent_tag, BAD_CAST "mask", BAD_CAST "true"); } oval_datatype_t datatype_index = oval_sysent_get_datatype(sysent); if (datatype_index != OVAL_DATATYPE_STRING) { xmlNewProp(sysent_tag, BAD_CAST "datatype", BAD_CAST oval_datatype_get_text(datatype_index)); } oval_syschar_status_t status_index = oval_sysent_get_status(sysent); if (status_index != SYSCHAR_STATUS_EXISTS) { xmlNewProp(sysent_tag, BAD_CAST "status", BAD_CAST oval_syschar_status_get_text(status_index)); } rf_itr = oval_sysent_get_record_fields(sysent); if (oval_record_field_iterator_has_more(rf_itr)) { xmlNsPtr field_ns = xmlSearchNsByHref(doc, xmlDocGetRootElement(doc), OVAL_SYSCHAR_NAMESPACE); if (field_ns == NULL) { field_ns = xmlNewNs(xmlDocGetRootElement(doc), OVAL_SYSCHAR_NAMESPACE, NULL); } while (oval_record_field_iterator_has_more(rf_itr)) { struct oval_record_field *rf; rf = oval_record_field_iterator_next(rf_itr); oval_record_field_to_dom(rf, mask, doc, sysent_tag, field_ns); } } oval_record_field_iterator_free(rf_itr); }
PKI_CONFIG_ELEMENT *PKI_CONFIG_ELEMENT_add_child ( PKI_CONFIG *doc, PKI_CONFIG_ELEMENT *node, char *name, char *value ) { PKI_CONFIG_ELEMENT *ret = NULL; // PKI_log_debug ( "add_child():: name=%s, value=%s", name, value ); if(!node || !name ) return NULL; // snprintf(buf, sizeof(buf), "%s:%s", PKI_NAMESPACE_PREFIX, name ); // ns = xmlNewNs ( node, NULL, PKI_NAMESPACE_PREFIX); // PKI_log_debug ( "add_child():: New Name::%s", name); if((ret = xmlNewTextChild( node, NULL, BAD_CAST name, BAD_CAST value )) == NULL ) { // PKI_log_debug("add_child()::Failed!"); } // xmlFreeNs ( ns ); // if(doc) _pki_update_config( &doc ); return ( ret ); }
xmlNodePtr cr_xmlNewTextChild(xmlNodePtr parent, xmlNsPtr ns, const xmlChar *name, const xmlChar *orig_content) { int free_content = 0; xmlChar *content; xmlNodePtr child; if (!orig_content) { content = BAD_CAST ""; } else if (xmlCheckUTF8(orig_content)) { content = (xmlChar *) orig_content; } else { size_t len = strlen((const char *) orig_content); content = malloc(sizeof(xmlChar)*len*2 + 1); cr_latin1_to_utf8(orig_content, content); free_content = 1; } child = xmlNewTextChild(parent, ns, name, content); if (free_content) free(content); return child; }
/** * Retourne un nouveau noeud correspondant à un produit (NULL en cas d'erreur) **/ xmlNodePtr creer_produit(const char *reference, const char *intitule, const char *prix) { xmlNodePtr noeud_produit; xmlNodePtr noeud_intitule; // Création du noeud "produit" if ((noeud_produit = xmlNewNode(NULL, BAD_CAST "produit")) == NULL) { return NULL; } // Ajout de son attribut "reference" if (xmlSetProp(noeud_produit, BAD_CAST "reference", BAD_CAST reference) == NULL) { xmlFreeNode(noeud_produit); return NULL; } // Création du noeud intitule if ((noeud_intitule = xmlNewNode(NULL, BAD_CAST "intitule")) == NULL) { xmlFreeNode(noeud_produit); return NULL; } xmlNodeSetContent(noeud_intitule, BAD_CAST intitule); // Ajout du noeud (intitule) à son père (produit) if (xmlAddChild(noeud_produit, noeud_intitule) == NULL) { xmlFreeNode(noeud_produit); xmlFreeNode(noeud_intitule); return NULL; } // Equivalent plus rapide par rapport au noeud intitule // Création du noeud "prix" et ajout à son père (produit) if (xmlNewTextChild(noeud_produit, NULL, BAD_CAST "prix", BAD_CAST prix) == NULL) { xmlFreeNode(noeud_produit); return NULL; } return noeud_produit; }
static void xml_finish(pcmk__output_t *out, crm_exit_t exit_status) { xmlNodePtr node; char *rc_as_str = NULL; char *buf = NULL; xml_private_t *priv = out->priv; /* If root is NULL, xml_init failed and we are being called from pcmk__output_free * in the pcmk__output_new path. */ if (priv->root == NULL) { return; } rc_as_str = crm_itoa(exit_status); node = xmlNewTextChild(priv->root, NULL, (pcmkXmlStr) "status", (pcmkXmlStr) crm_exit_str(exit_status)); xmlSetProp(node, (pcmkXmlStr) "code", (pcmkXmlStr) rc_as_str); buf = dump_xml_formatted_with_text(priv->root); fprintf(out->dest, "%s", buf); free(rc_as_str); free(buf); }
OSyncXMLField *osync_xmlfield_new(OSyncXMLFormat *xmlformat, const char *name, OSyncError **error) { xmlNodePtr node = NULL; OSyncXMLField *xmlfield = NULL; osync_trace(TRACE_ENTRY, "%s(%p, %s, %p)", __func__, xmlformat, name, error); osync_assert(xmlformat); osync_assert(name); node = xmlNewTextChild(xmlDocGetRootElement(xmlformat->doc), NULL, BAD_CAST name, NULL); xmlfield = osync_xmlfield_new_node(xmlformat, node, error); if(!xmlfield) { xmlUnlinkNode(node); xmlFreeNode(node); osync_trace(TRACE_EXIT_ERROR, "%s: %s" , __func__, osync_error_print(error)); return NULL; } /* XMLFormat entry got added - not sure if it is still sorted */ osync_xmlformat_set_unsorted(xmlformat); /* This XMLField has no keys, so it's for sure it's sorted */ xmlfield->sorted = TRUE; osync_trace(TRACE_EXIT, "%s: %p", __func__, xmlfield); return xmlfield; }
void bg_chapter_list_2_xml(gavl_chapter_list_t * list, xmlNodePtr xml_list) { char * tmp_string; int i; xmlNodePtr xml_chapter; tmp_string = bg_sprintf("%d", list->timescale); BG_XML_SET_PROP(xml_list, "timescale", tmp_string); free(tmp_string); xmlAddChild(xml_list, BG_XML_NEW_TEXT("\n")); for(i = 0; i < list->num_chapters; i++) { xml_chapter = xmlNewTextChild(xml_list, NULL, (xmlChar*)CHAPTER_KEY, NULL); if(list->chapters[i].name) BG_XML_SET_PROP(xml_chapter, NAME_KEY, list->chapters[i].name); tmp_string = bg_sprintf("%" PRId64, list->chapters[i].time); xmlAddChild(xml_chapter, BG_XML_NEW_TEXT(tmp_string)); free(tmp_string); xmlAddChild(xml_list, BG_XML_NEW_TEXT("\n")); } }
static void sload_write_config(Control *ctrl, xmlNodePtr parent) { xmlNodePtr root; char value[10]; t_sload *sload; sload = (t_sload *)ctrl->data; root = xmlNewTextChild(parent, NULL, SLOAD_ROOT, NULL); g_snprintf(value, 2, "%d", sload->options.use_label); xmlSetProp(root, "Use_Label", value); g_snprintf(value, 8, "#%02X%02X%02X", (guint)sload->options.color.red >> 8, (guint)sload->options.color.green >> 8, (guint)sload->options.color.blue >> 8); xmlSetProp(root, "Color", value); if (sload->options.label_text) { xmlSetProp(root, "Text", sload->options.label_text); } else { xmlSetProp(root, "Text", DEFAULTTEXT); } }
static void plugin_write_config (Control * p_poCtrl, xmlNodePtr p_poParent) /* Plugin API */ /* Write plugin configuration into xml file */ { struct plugin_t *poPlugin = (plugin_t *) p_poCtrl->data; struct param_t *poConf = &(poPlugin->oConf.oParam); xmlNodePtr poRoot; char acBuffer[16]; TRACE ("plugin_write_config()\n"); poRoot = xmlNewTextChild (p_poParent, NULL, PLUGIN_NAME, NULL); xmlSetProp (poRoot, CONF_CMD, poConf->acCmd); sprintf (acBuffer, "%d", poConf->fTitleDisplayed); xmlSetProp (poRoot, CONF_USE_LABEL, acBuffer); xmlSetProp (poRoot, CONF_LABEL_TEXT, poConf->acTitle); sprintf (acBuffer, "%d", poConf->iPeriod_ms); xmlSetProp (poRoot, CONF_UPDATE_PERIOD, acBuffer); xmlSetProp (poRoot, CONF_FONT, poConf->acFont); } /* plugin_write_config() */
/** * Add an entry to the HTML tree for saving. * * The node must contain a sequence of node_elements in the following order: * * \param entry hotlist entry to add * \param node node to add li to * \return true on success, false on memory exhaustion */ static bool tree_url_save_entry(struct node *entry, xmlNode *node) { xmlNode *li, *a; xmlAttr *href; const char *text; li = xmlNewChild(node, NULL, (const xmlChar *) "li", NULL); if (li == NULL) return false; text = tree_url_node_get_title(entry); if (text == NULL) return false; a = xmlNewTextChild(li, NULL, (const xmlChar *) "a", (const xmlChar *) text); if (a == NULL) return false; text = tree_url_node_get_url(entry); if (text == NULL) return false; href = xmlNewProp(a, (const xmlChar *) "href", (const xmlChar *) text); if (href == NULL) return false; return true; }