/**
* Extracts the device XML description given its internal structure
*
* @param device_to_extract The Device that we want to extract
*
* @return The XML description of the device or NULL if failed
*/
char *
extract_device_xml(Device *device_to_extract)
{
if(device_is_in_xml_file (device_to_extract) == HPD_NO)
return NULL;
mxml_node_t *xml;
xml = mxmlNewXML("1.0");
mxml_node_t *new_device;
new_device = mxmlNewElement(xml, "device");
if(device_to_extract->description != NULL) mxmlElementSetAttr(new_device, "desc", device_to_extract->description);
if(device_to_extract->ID != NULL) mxmlElementSetAttr(new_device, "id", device_to_extract->ID);
if(device_to_extract->vendorID != NULL) mxmlElementSetAttr(new_device, "vendorID", device_to_extract->vendorID);
if(device_to_extract->productID != NULL) mxmlElementSetAttr(new_device, "productID", device_to_extract->productID);
if(device_to_extract->version != NULL) mxmlElementSetAttr(new_device, "version", device_to_extract->version);
if(device_to_extract->IP != NULL) mxmlElementSetAttr(new_device, "ip", device_to_extract->IP);
if(device_to_extract->port != NULL) mxmlElementSetAttr(new_device, "port", device_to_extract->port);
if(device_to_extract->location != NULL) mxmlElementSetAttr(new_device, "location", device_to_extract->location);
if(device_to_extract->type != NULL) mxmlElementSetAttr(new_device, "type", device_to_extract->type);
char* return_string = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
mxmlDelete(xml);
return return_string;
}
void StreamlineSetup::sendCounters() {
mxml_node_t *xml;
mxml_node_t *counters;
xml = mxmlNewXML("1.0");
counters = mxmlNewElement(xml, "counters");
int count = 0;
for (Driver *driver = Driver::getHead(); driver != NULL; driver = driver->getNext()) {
count += driver->writeCounters(counters);
}
mxml_node_t *setup = mxmlNewElement(counters, "setup_warnings");
mxmlNewText(setup, 0, logg.getSetup());
if (count == 0) {
logg.logError("No counters found, this could be because /dev/gator/events can not be read or because perf is not working correctly");
handleException();
}
char* string = mxmlSaveAllocString(xml, mxmlWhitespaceCB);
sendString(string, RESPONSE_XML);
free(string);
mxmlDelete(xml);
}
char* CapturedXML::getXML(bool includeTime) {
char* xml_string;
mxml_node_t *xml = getTree(includeTime);
xml_string = mxmlSaveAllocString(xml, mxmlWhitespaceCB);
mxmlDelete(xml);
return xml_string;
}
int backup_extract_transfer_complete( mxml_node_t *node, char **msg_out, int *method_id)
{
mxml_node_t *tree_m, *b, *n;
tree_m = mxmlLoadString(NULL, CWMP_TRANSFER_COMPLETE_MESSAGE, MXML_NO_CALLBACK);
if (!tree_m) goto error;
b = mxmlFindElement(node, node, "command_key", NULL, NULL, MXML_DESCEND);
if (!b) goto error;
n = mxmlFindElement(tree_m, tree_m, "CommandKey", NULL, NULL, MXML_DESCEND);
if (!n) goto error;
n = mxmlNewText(n, 0, b->child->value.text.string);
if (!n) goto error;
b = mxmlFindElement(node, node, "fault_code", NULL, NULL, MXML_DESCEND);
if (!b) goto error;
n = mxmlFindElement(tree_m, tree_m, "FaultCode", NULL, NULL, MXML_DESCEND);
if (!n) goto error;
n = mxmlNewText(n, 0, b->child->value.text.string);
if (!n) goto error;
b = mxmlFindElement(node, node, "fault_string", NULL, NULL, MXML_DESCEND);
if (!b) goto error;
if (b->child && b->child->type == MXML_TEXT && b->child->value.text.string) {
n = mxmlFindElement(tree_m, tree_m, "FaultString", NULL, NULL, MXML_DESCEND);
if (!n) goto error;
char *c = xml_get_value_with_whitespace(b->child);
n = mxmlNewText(n, 0, c);
free(c);
if (!n) goto error;
}
b = mxmlFindElement(node, node, "start_time", NULL, NULL, MXML_DESCEND);
if (!b) goto error;
n = mxmlFindElement(tree_m, tree_m, "StartTime", NULL, NULL, MXML_DESCEND);
if (!n) goto error;
n = mxmlNewText(n, 0, b->child->value.text.string);
if (!n) goto error;
b = mxmlFindElement(node, node, "complete_time", NULL, NULL, MXML_DESCEND);
if (!b) goto error;
n = mxmlFindElement(tree_m, tree_m, "CompleteTime", NULL, NULL, MXML_DESCEND);
if (!n) goto error;
n = mxmlNewText(n, 0, b->child->value.text.string);
if (!n) goto error;
b = mxmlFindElement(node, node, "method_id", NULL, NULL, MXML_DESCEND);
if (!b) goto error;
*method_id = atoi(b->child->value.text.string);
*msg_out = mxmlSaveAllocString(tree_m, xml_format_cb);
mxmlDelete(tree_m);
return 0;
error:
mxmlDelete(tree_m);
return -1;
}
/**
* Returns the entire xml device list
*
* @return The XML device list
*/
char *
get_xml_device_list()
{
char *return_value = mxmlSaveAllocString(service_xml_file->xml_tree, MXML_NO_CALLBACK);
return return_value;
}
/**
* Extracts the service XML description given its internal structure
*
* @param _service_to_extract The Service that we want to extract
*
* @return The XML description of the service or NULL if failed
*/
char *
extract_service_xml(Service *_service_to_extract)
{
if(service_is_in_xml_file (_service_to_extract) == HPD_NO)
return NULL;
mxml_node_t *xml;
xml = mxmlNewXML("1.0");
mxml_node_t *new_service;
mxml_node_t *new_device;
mxml_node_t *new_parameter;
new_service = mxmlNewElement(xml, "service");
if(_service_to_extract->description != NULL) mxmlElementSetAttr(new_service, "desc", _service_to_extract->description);
if(_service_to_extract->ID != NULL) mxmlElementSetAttr(new_service, "id", _service_to_extract->ID);
mxmlElementSetAttr(new_service, "isActuator", _service_to_extract->isActuator ? "1" : "0");
if(_service_to_extract->value_url != NULL) mxmlElementSetAttr(new_service, "value_url", _service_to_extract->value_url);
if(_service_to_extract->type != NULL) mxmlElementSetAttr(new_service, "type", _service_to_extract->type);
if(_service_to_extract->unit != NULL) mxmlElementSetAttr(new_service, "unit", _service_to_extract->unit);
new_device = mxmlNewElement(new_service, "device");
if(_service_to_extract->device->description != NULL) mxmlElementSetAttr(new_device, "desc", _service_to_extract->device->description);
if(_service_to_extract->device->ID != NULL) mxmlElementSetAttr(new_device, "id", _service_to_extract->device->ID);
if(_service_to_extract->device->vendorID != NULL) mxmlElementSetAttr(new_device, "vendorid", _service_to_extract->device->vendorID);
if(_service_to_extract->device->productID != NULL) mxmlElementSetAttr(new_device, "productid", _service_to_extract->device->productID);
if(_service_to_extract->device->version != NULL) mxmlElementSetAttr(new_device, "version", _service_to_extract->device->version);
if(_service_to_extract->device->IP != NULL) mxmlElementSetAttr(new_device, "ip", _service_to_extract->device->IP);
if(_service_to_extract->device->port != NULL) mxmlElementSetAttr(new_device, "port", _service_to_extract->device->port);
if(_service_to_extract->device->location != NULL) mxmlElementSetAttr(new_device, "location", _service_to_extract->device->location);
if(_service_to_extract->device->type != NULL) mxmlElementSetAttr(new_device, "type", _service_to_extract->device->type);
Parameter *iterator = _service_to_extract->parameter;
if(iterator != NULL)
{
new_parameter = mxmlNewElement(new_service, "parameter");
if(iterator->ID != NULL) mxmlElementSetAttr(new_parameter, "id", iterator->ID);
if(iterator->max != NULL) mxmlElementSetAttr(new_parameter, "max", iterator->max);
if(iterator->min != NULL) mxmlElementSetAttr(new_parameter, "min", iterator->min);
if(iterator->scale != NULL) mxmlElementSetAttr(new_parameter, "scale", iterator->scale);
if(iterator->step != NULL) mxmlElementSetAttr(new_parameter, "step", iterator->step);
if(iterator->type != NULL) mxmlElementSetAttr(new_parameter, "type", iterator->type);
if(iterator->unit != NULL) mxmlElementSetAttr(new_parameter, "unit", iterator->unit);
if(iterator->values != NULL) mxmlElementSetAttr(new_parameter, "values", iterator->values);
}
char* return_string = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
mxmlDelete(xml);
return return_string;
}
char *XMLwrapper::getXMLdata(){
xml_k=0;
ZERO(tabs,STACKSIZE+2);
mxml_node_t *oldnode=node;
node=info;
//Info storing
node=oldnode;
char *xmldata=mxmlSaveAllocString(tree,XMLwrapper_whitespace_callback);
return(xmldata);
};
const char* set_keyvalue(const char* xmlstr, const char* catelog_name, const char* key_name, const char* value)
{
if ((!catelog_name) || (!key_name) || (!value))
{
DbgPrint("get_keyvalue input parameter error");
return (NULL);
}
mxml_node_t *xml;
if (xmlstr == NULL)
{
xml = mxmlNewXML("1.0");
}
else
{
xml = mxmlLoadString(NULL, xmlstr, MXML_TEXT_CALLBACK);
}
if (xml == NULL)
{
DbgPrint("xml load err: %s", xmlstr);
return (NULL);
}
mxml_node_t *catelog = mxmlFindElement(xml, xml, catelog_name, NULL, NULL, MXML_DESCEND);
if (catelog == NULL)
{
catelog = mxmlNewElement(xml, catelog_name);
}
mxml_node_t *node = mxmlFindElement(catelog,catelog,key_name,NULL,NULL,MXML_DESCEND);
if (node)
{
mxmlSetText(node, 0, value);
}
else
{
node = mxmlNewElement(catelog, key_name);
mxmlNewText(node, 0, value);
}
mxmlSetWrapMargin(2);
char* system_xmlstr = strdup_tls(mxmlSaveAllocString(xml, MXML_TEXT_CALLBACK));
mxmlDelete(xml);
return (system_xmlstr);
}
struct nftnl_expr *nftnl_mxml_expr_parse(mxml_node_t *node,
struct nftnl_parse_err *err,
struct nftnl_set_list *set_list)
{
mxml_node_t *tree;
struct nftnl_expr *e;
const char *expr_name;
char *xml_text;
uint32_t set_id;
int ret;
expr_name = mxmlElementGetAttr(node, "type");
if (expr_name == NULL) {
err->node_name = "type";
err->error = NFTNL_PARSE_EMISSINGNODE;
goto err;
}
e = nftnl_expr_alloc(expr_name);
if (e == NULL)
goto err;
xml_text = mxmlSaveAllocString(node, MXML_NO_CALLBACK);
if (xml_text == NULL)
goto err_expr;
tree = mxmlLoadString(NULL, xml_text, MXML_OPAQUE_CALLBACK);
xfree(xml_text);
if (tree == NULL)
goto err_expr;
ret = e->ops->xml_parse(e, tree, err);
mxmlDelete(tree);
if (set_list != NULL &&
strcmp(expr_name, "lookup") == 0 &&
nftnl_set_lookup_id(e, set_list, &set_id))
nftnl_expr_set_u32(e, NFTNL_EXPR_LOOKUP_SET_ID, set_id);
return ret < 0 ? NULL : e;
err_expr:
nftnl_expr_free(e);
err:
mxmlDelete(tree);
errno = EINVAL;
return NULL;
}
/**
* Returns an internal char* of a value under the form of :
* "<?xml version="1.0" encoding="UTF-8"?><value timestamp = xxxxxx >desired_value</value>"
*
* @param value The string of the value desired
*
* @return Returns the char* corresponding
*/
char *
get_xml_value(char* value)
{
mxml_node_t *xml;
mxml_node_t *xml_value;
xml = mxmlNewXML("1.0");
xml_value = mxmlNewElement(xml, "value");
mxmlElementSetAttr(xml_value, "timestamp", timestamp());
mxmlNewText(xml_value, 0, value);
char* return_value = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
mxmlDelete(xml);
return return_value;
}
std::unique_ptr<char, void(*)(void*)> getXML(lib::Span<const Driver * const> drivers, lib::Span<const GatorCpu> clusters)
{
const auto xml = getTree(clusters);
// Add dynamic events from the drivers
mxml_node_t *events = mxmlFindElement(xml.get(), xml.get(), TAG_EVENTS, NULL, NULL, MXML_DESCEND);
if (!events) {
logg.logError("Unable to find <events> node in the events.xml, please ensure the first two lines of events XML are:\n"
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<events>");
handleException();
}
for (const Driver *driver : drivers) {
driver->writeEvents(events);
}
return {mxmlSaveAllocString(xml.get(), mxmlWhitespaceCB), &free};
}
char *EventsXML::getXML() {
mxml_node_t *xml = getTree();
// Add dynamic events from the drivers
mxml_node_t *events = mxmlFindElement(xml, xml, "events", NULL, NULL, MXML_DESCEND);
if (!events) {
logg->logError("Unable to find <events> node in the events.xml, please ensure the first two lines of events XML are:\n"
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<events>");
handleException();
}
for (Driver *driver = Driver::getHead(); driver != NULL; driver = driver->getNext()) {
driver->writeEvents(events);
}
char *string = mxmlSaveAllocString(xml, mxmlWhitespaceCB);
mxmlDelete(xml);
return string;
}
void StreamlineSetup::sendCounters() {
mxml_node_t *xml;
mxml_node_t *counters;
xml = mxmlNewXML("1.0");
counters = mxmlNewElement(xml, "counters");
int count = 0;
for (Driver *driver = Driver::getHead(); driver != NULL; driver = driver->getNext()) {
count += driver->writeCounters(counters);
}
if (count == 0) {
logg.logError("No counters found, this could be because /dev/gator/events can not be read or because perf is not working correctly");
handleException();
}
mxml_node_t *setup = mxmlNewElement(counters, "setup_warnings");
mxmlNewText(setup, 0, logg.getSetup());
if (gSessionData.mSharedData->mClustersAccurate) {
for (int cluster = 0; cluster < gSessionData.mSharedData->mClusterCount; ++cluster) {
mxml_node_t *node = mxmlNewElement(counters, "cluster");
mxmlElementSetAttrf(node, "id", "%i", cluster);
mxmlElementSetAttr(node, "name", gSessionData.mSharedData->mClusters[cluster]->getPmncName());
}
for (int cpu = 0; cpu < gSessionData.mCores; ++cpu) {
if (gSessionData.mSharedData->mClusterIds[cpu] >= 0) {
mxml_node_t *node = mxmlNewElement(counters, "cpu");
mxmlElementSetAttrf(node, "id", "%i", cpu);
mxmlElementSetAttrf(node, "cluster", "%i", gSessionData.mSharedData->mClusterIds[cpu]);
}
}
}
char* string = mxmlSaveAllocString(xml, mxmlWhitespaceCB);
mxmlDelete(xml);
sendString(string, RESPONSE_XML);
free(string);
}
static struct evbuffer *
mxml_to_evbuf(mxml_node_t *tree)
{
struct evbuffer *evbuf;
char *xml;
int ret;
evbuf = evbuffer_new();
if (!evbuf)
{
DPRINTF(E_LOG, L_RSP, "Could not create evbuffer for RSP reply\n");
return NULL;
}
xml = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
if (!xml)
{
DPRINTF(E_LOG, L_RSP, "Could not finalize RSP reply\n");
evbuffer_free(evbuf);
return NULL;
}
ret = evbuffer_add(evbuf, xml, strlen(xml));
free(xml);
if (ret < 0)
{
DPRINTF(E_LOG, L_RSP, "Could not load evbuffer for RSP reply\n");
evbuffer_free(evbuf);
return NULL;
}
return evbuf;
}
char *complete_part_xml;
aos_string_t xml_doc;
mxml_node_t *doc;
mxml_node_t *root_node;
oss_complete_part_content_t *content;
doc = mxmlNewXML("1.0");
root_node = mxmlNewElement(doc, "CompleteMultipartUpload");
aos_list_for_each_entry(content, bc, node) {
mxml_node_t *part_node = mxmlNewElement(root_node, "Part");
mxml_node_t *part_number_node = mxmlNewElement(part_node, "PartNumber");
mxmlNewText(part_number_node, 0, content->part_number.data);
mxml_node_t *etag_node = mxmlNewElement(part_node, "ETag");
mxmlNewText(etag_node, 0, content->etag.data);
}
xml_buff = mxmlSaveAllocString(doc, MXML_NO_CALLBACK);
aos_str_set(&xml_doc, xml_buff);
complete_part_xml = aos_pstrdup(p, &xml_doc);
free(xml_buff);
mxmlDelete(doc);
return complete_part_xml;
}
void build_complete_multipart_upload_body(aos_pool_t *p, aos_list_t *part_list, aos_list_t *body)
{
char *complete_multipart_upload_xml;
aos_buf_t *b;
complete_multipart_upload_xml = build_complete_multipart_upload_xml(p, part_list);
int parse_opt(int argc, char *argv[])
{
char cmd[4] = {0};
char key[128] = {0};
char val[128] = {0};
char file[128] = {0};
int num = 0;
int flag = 0;
int c;
while (1) {
int option_index = 0;
/*
* name; has_arg; flag; val;
* {"quiet", 0, 0, 0}
*
* ATTENTION:
* when has_arg set to 1, a ':' add in "hc:k:f:v:" accordingly
* on cmdline: -q a <==> -qa
*/
static struct option long_options[] = {
{"help" , 0, 0, 'h'},
{"inner", 0, 0, 'i'},
{"cmd" , 1, 0, 'c'},
{"file" , 1, 0, 'f'},
{"key" , 1, 0, 'k'},
{"val" , 1, 0, 'v'},
{"num" , 1, 0, 'n'},
{0 , 0, 0, 0 }
};
c = getopt_long(argc, argv, "hic:k:f:v:n:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'c':
flag |= FLAG_CMD;
strncpy(cmd, optarg, 1);
if (cmd[0] != 'a' && cmd[0] != 'd' && cmd[0] != 'w' && cmd[0] != 'r') {
pritnt_usage(argv, __LINE__);
}
break;
case 'f':
flag |= FLAG_FILE;
strncpy(file, optarg, sizeof(file));
break;
case 'k':
flag |= FLAG_KEY;
strncpy(key, optarg, sizeof(key));
break;
case 'v':
flag |= FLAG_VAL;
strncpy(val, optarg, sizeof(val));
break;
case 'n':
flag |= FLAG_NUM;
num = atoi(optarg);
break;
case 'i':
flag |= FLAG_INNER;
break;
case 'h':
pritnt_usage(argv, 0);
default:
pritnt_usage(argv, __LINE__);
}
}
if (!(flag & FLAG_CMD)) {
pritnt_usage(argv, __LINE__);
}
if ((flag & FLAG_NUM) && num < 1) {
pritnt_usage(argv, __LINE__);
}
// xml-file needed
if (optind == (argc-1)) {
if (0 != access(argv[optind], R_OK)) {
eprintf("file %s is not readable\n", argv[optind]);
exit(1);
}
} else {
fprintf(stderr, "optind:%d argc-1:%d\n", optind, argc-1);
pritnt_usage(argv, __LINE__);
}
int ret;
const char *xmlfile = argv[optind];
FILE *fp_xml = fopen(xmlfile, "r");
return_val_if_fail(fp_xml != NULL, FAILURE);
mxml_node_t *tree = NULL;
if (cmd[0] == 'r') {
tree = mxmlLoadFile(NULL, fp_xml, MXML_OPAQUE_CALLBACK);
return_val_if_fail(tree != NULL, FAILURE);
} else {
tree = mxmlLoadFile(NULL, fp_xml, MXML_TEXT_CALLBACK);
return_val_if_fail(tree != NULL, FAILURE);
}
fclose(fp_xml);
if (flag & FLAG_FILE) {
int match;
FILE *fp;
char *line = NULL;
size_t len = 0;
fp = fopen(file, "r");
if (fp == NULL) {
exit(1);
}
while ((getline(&line, &len, fp)) != -1) {
match = sscanf(line, "%d%s%*[ ]%[^\n]", &num, key, val);
if ((match == 3 && (cmd[0] == 'a' || cmd[0] == 'w')) ||
(match == 2 && (cmd[0] == 'd' || cmd[0] == 'r'))) {
ret = node_process(cmd[0], tree, key, val, num);
if (ret != 0) {
pritnt_usage(argv, ret);
}
} else {
eprintf("Retrieved error format line %s\n", line);
}
}
free(line);
fclose(fp);
} else {
ret = node_process(cmd[0], tree, key, val, num);
if (ret != 0) {
pritnt_usage(argv, ret);
}
}
if (cmd[0] != 'r') {
if (flag&FLAG_INNER) {
FILE *fp = fopen(argv[optind], "w");
mxmlSaveFile(tree, fp, xml_format_write);
} else {
char *ptr = mxmlSaveAllocString(tree, xml_format_write);
printf("%s\n", ptr);
}
}
return 0;
}
int main_2(int argc, const char * argv[])
{
mxml_node_t * xml; /*<?xml ... ?>*/
mxml_node_t * data; /*<data>*/
mxml_node_t * node; /*<node>*/
mxml_node_t * group; /*group*/
/*xml*/
xml = mxmlNewXML("1.0");
/*data*/
data = mxmlNewElement(xml, "data");
/*3个node*/
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val1");
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val2");
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val3");
/*group*/
group = mxmlNewElement(data, "group");
/*group 下的三个node*/
node = mxmlNewElement(group, "node");
mxmlNewText(node, 0, "val4");
node = mxmlNewElement(group, "node");
mxmlNewText(node, 0, "val5");
node = mxmlNewElement(group, "node");
mxmlNewText(node, 0, "val6");
/*2个node*/
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val7");
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val8");
/*自动折行控制------似乎不顶用！！！！！！*/
mxmlSetWrapMargin(100);/*设置100列折行*/
mxmlSetWrapMargin(0);/*取消自动折行*/
/*保存*/
/*保存到文件*/
FILE * fp;
fp = fopen("/Users/zhangliang/Desktop/Project/C/Mini-XML/Mini-XML/testxml2.xml", "w");
mxmlSaveFile(xml, fp, MXML_NO_CALLBACK);
fclose(fp);
/*保存到字符串中*/
char buffer[4096];
char * ptr;
mxmlSaveString(xml, buffer, sizeof(buffer), MXML_NO_CALLBACK);
ptr = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
printf("buffer: %s\n", buffer);
printf("alloc : %s\n", ptr);
free(ptr);
return 0;
}
