mxml_node_t *nftnl_mxml_build_tree(const void *data, const char *treename,
struct nftnl_parse_err *err, enum nftnl_parse_input input)
{
mxml_node_t *tree;
switch (input) {
case NFTNL_PARSE_BUFFER:
tree = mxmlLoadString(NULL, data, MXML_OPAQUE_CALLBACK);
break;
case NFTNL_PARSE_FILE:
tree = mxmlLoadFile(NULL, (FILE *)data, MXML_OPAQUE_CALLBACK);
break;
default:
goto err;
}
if (tree == NULL) {
err->error = NFTNL_PARSE_EBADINPUT;
goto err;
}
if (tree->value.opaque != NULL &&
strcmp(tree->value.opaque, treename) == 0)
return tree;
err->error = NFTNL_PARSE_EMISSINGNODE;
err->node_name = treename;
mxmlDelete(tree);
err:
err->line = 0;
err->column = 0;
errno = EINVAL;
return NULL;
}
BOOL
main_parse_motd(CHAR *motd)
{
mxml_node_t *tree, *node;
INT day, month, year;
CHAR *text = NULL;
if (motd == NULL)
return RES_FAIL;
tree = mxmlLoadString(NULL, motd, MXML_OPAQUE_CALLBACK);
if (tree == NULL)
{
dialog_set_status("main_parse_motd: mxmlLoadString() выполнена с ошибкой");
return RES_FAIL;
}
for (node = mxmlFindElement(tree, tree, "entry", NULL, NULL, MXML_DESCEND);
node != NULL;
node = mxmlFindElement(node, tree, "entry", NULL, NULL, MXML_DESCEND))
{
day = atoi((CHAR *)mxmlElementGetAttr(node, "day"));
month = atoi((CHAR *)mxmlElementGetAttr(node, "month"));
year = atoi((CHAR *)mxmlElementGetAttr(node, "year"));
text = node->child->value.opaque;
}
if (text != NULL)
dialog_set_motd(text, day, month, year);
return RES_OK;
}
int XMLwrapper::loadXMLfile(const char *filename){
if (tree!=NULL) mxmlDelete(tree);
tree=NULL;
ZERO(&parentstack,(int)sizeof(parentstack));
ZERO(&values,(int)sizeof(values));
stackpos=0;
char *xmldata=doloadfile(filename);
if (xmldata==NULL) return(-1);//the file could not be loaded or uncompressed
printf("%s\n",xmldata);
root=tree=mxmlLoadString(NULL,xmldata,MXML_OPAQUE_CALLBACK);
delete []xmldata;
if (tree==NULL) return(-2);//this is not XML
node=root=mxmlFindElement(tree,tree,"paulstretch-data",NULL,NULL,MXML_DESCEND);
if (root==NULL) return(-3);//the XML doesnt embbed required data
push(root);
values.xml_version.major=str2int(mxmlElementGetAttr(root,"version-major"));
values.xml_version.minor=str2int(mxmlElementGetAttr(root,"version-minor"));
return(0);
};
void StreamlineSetup::handleRequest(char* xml) {
mxml_node_t *tree, *node;
const char * attr = NULL;
tree = mxmlLoadString(NULL, xml, MXML_NO_CALLBACK);
node = mxmlFindElement(tree, tree, TAG_REQUEST, ATTR_TYPE, NULL, MXML_DESCEND_FIRST);
if (node) {
attr = mxmlElementGetAttr(node, ATTR_TYPE);
}
if (attr && strcmp(attr, VALUE_EVENTS) == 0) {
sendEvents();
logg.logMessage("Sent events xml response");
} else if (attr && strcmp(attr, VALUE_CONFIGURATION) == 0) {
sendConfiguration();
logg.logMessage("Sent configuration xml response");
} else if (attr && strcmp(attr, VALUE_COUNTERS) == 0) {
sendCounters();
logg.logMessage("Sent counters xml response");
} else if (attr && strcmp(attr, VALUE_CAPTURED) == 0) {
CapturedXML capturedXML;
char* capturedText = capturedXML.getXML(false);
sendData(capturedText, strlen(capturedText), RESPONSE_XML);
free(capturedText);
logg.logMessage("Sent captured xml response");
} else if (attr && strcmp(attr, VALUE_DEFAULTS) == 0) {
sendDefaults();
logg.logMessage("Sent default configuration xml response");
} else {
char error[] = "Unknown request";
sendData(error, strlen(error), RESPONSE_NAK);
logg.logMessage("Received unknown request:\n%s", xml);
}
mxmlDelete(tree);
}
int parseSearch(std::string &xmlstr, struct t_tweet ** dest){
mxml_node_t *xml;
mxml_node_t *unit;
struct t_tweet * tweets = (struct t_tweet *)mem2_calloc(MAXUNITS, sizeof(struct t_tweet), MEM2_OTHER);
if(!tweets){
return 0;
}
size_t pos = 0;
while(1){
pos = xmlstr.find("&", pos);
if(pos == std::string::npos) break;
xmlstr.replace(pos, 9, "&");
}
xml = mxmlLoadString(NULL, xmlstr.c_str(), MXML_OPAQUE_CALLBACK);
if(!xml){
mem2_free(tweets, MEM2_OTHER);
return 0;
}
int t=0;
for(unit = mxmlFindElement(xml, xml, "entry", NULL, NULL, MXML_DESCEND); unit && t < MAXUNITS; unit = mxmlFindElement(unit, xml, "entry", NULL, NULL, MXML_DESCEND)){
parseSearchEntry(unit, &tweets[t++]);
}
mxmlDelete(xml);
if(t < MAXUNITS){ //Free unused memory
tweets = (struct t_tweet *)mem2_realloc(tweets, t*sizeof(struct t_tweet), MEM2_OTHER);
}
*dest = tweets;
return t;
}
int parseUsers(std::string &xmlstr, struct t_user ** dest){
mxml_node_t *xml;
mxml_node_t *unit;
struct t_user * users = (struct t_user *)mem2_calloc(MAXUNITS, sizeof(struct t_user), MEM2_OTHER);
if(!users){
return 0;
}
size_t pos = 0;
while(1){
pos = xmlstr.find("&amp;", pos);
if(pos == std::string::npos) break;
xmlstr.replace(pos, 9, "&");
}
xml = mxmlLoadString(NULL, xmlstr.c_str(), MXML_OPAQUE_CALLBACK);
if(!xml){
mem2_free(users, MEM2_OTHER);
return 0;
}
int t=0;
for(unit = mxmlFindElement(xml, xml, "user", NULL, NULL, MXML_DESCEND); unit; unit = mxmlFindElement(unit, xml, "user", NULL, NULL, MXML_DESCEND)){
parseUser(unit, &users[t++]);
}
mxmlDelete(xml);
if(t < MAXUNITS){ //Free unused memory
users = (struct t_user *)mem2_realloc(users, t*sizeof(struct t_user), MEM2_OTHER);
}
*dest = users;
return t;
}
int ConfigurationXML::parse(const char* configurationXML) {
mxml_node_t *tree, *node;
int ret;
tree = mxmlLoadString(NULL, configurationXML, MXML_NO_CALLBACK);
node = mxmlGetFirstChild(tree);
while (node && mxmlGetType(node) != MXML_ELEMENT)
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
ret = configurationsTag(node);
node = mxmlGetFirstChild(node);
while (node) {
if (mxmlGetType(node) != MXML_ELEMENT) {
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
continue;
}
configurationTag(node);
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
}
mxmlDelete(tree);
return ret;
}
int ConfigurationXML::parse(const char* configurationXML) {
mxml_node_t *tree, *node;
int ret;
// clear counter overflow
gSessionData->mCounterOverflow = 0;
mIndex = 0;
// disable all counters prior to parsing the configuration xml
for (int i = 0; i < MAX_PERFORMANCE_COUNTERS; i++) {
gSessionData->mCounters[i].setEnabled(false);
}
tree = mxmlLoadString(NULL, configurationXML, MXML_NO_CALLBACK);
node = mxmlGetFirstChild(tree);
while (node && mxmlGetType(node) != MXML_ELEMENT)
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
ret = configurationsTag(node);
node = mxmlGetFirstChild(node);
while (node) {
if (mxmlGetType(node) != MXML_ELEMENT) {
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
continue;
}
configurationTag(node);
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
}
mxmlDelete(tree);
return ret;
}
/**
* Returns the string of the value extracted from the XML value
*
* @param _xml_value The XML formatted value
*
* @return The string of the value or NULL if failed
*/
char*
get_value_from_xml_value(char* xml_value)
{
mxml_node_t *xml;
mxml_node_t *node;
xml = mxmlLoadString(NULL, xml_value, MXML_TEXT_CALLBACK);
if(xml == NULL)
{
printf("XML value format uncompatible with HomePort\n");
return NULL;
}
node = mxmlFindElement(xml, xml, "value", NULL, NULL, MXML_DESCEND);
if(node == NULL || node-> child == NULL || node->child->value.text.string == NULL)
{
mxmlDelete(xml);
printf("No \"value\" in the XML file\n");
return NULL;
}
char *return_value = malloc(sizeof(char)*(strlen(node->child->value.text.string)+1));
strcpy(return_value, node->child->value.text.string);
mxmlDelete(xml);
return return_value;
}
bool UpdateCheck()
{
bool ret = 0;
// we only check for an update if we have internet
if(!networkInit)
return 0;
ShowAction("Checking for updates...");
class twitCurl twitterObj;
std::string tmp("392315277"); // @WiiTwiity userid
if( twitterObj.userGet(tmp, 1) ){
tmp.clear();
twitterObj.getLastWebResponse(tmp);
}else{
CancelAction();
return 0;
}
mxml_node_t *xml;
mxml_node_t *item;
xml = mxmlLoadString(NULL, tmp.c_str(), MXML_OPAQUE_CALLBACK);
if(!xml){
CancelAction();
return 0;
}
item = mxmlFindElement(xml, xml, "text", NULL, NULL, MXML_DESCEND);
if(item) // Tweet found!
{
const char * tweet = item->child->value.opaque;
int verMajor, verMinor, verPoint;
if(sscanf(tweet, "WiiTweet %d.%d.%d released! SHA-1: %s", &verMajor, &verMinor, &verPoint, updateHash) == 4)
{
int curMajor = APPVERSION[0] - '0';
int curMinor = APPVERSION[2] - '0';
int curPoint = APPVERSION[4] - '0';
// check that the versioning is valid and is a newer version
if((verMajor >= 0 && verMajor <= 9 &&
verMinor >= 0 && verMinor <= 9 &&
verPoint >= 0 && verPoint <= 9) &&
(verMajor > curMajor ||
(verMajor == curMajor && verMinor > curMinor) ||
(verMajor == curMajor && verMinor == curMinor && verPoint > curPoint)))
{
snprintf(updateURL, 128, "http://wiitweet.googlecode.com/files/wiitweet%%20%d.%d.%d.zip", verMajor, verMinor, verPoint);
ret = 1;
}
}
}
mxmlDelete(xml);
CancelAction();
return ret;
}
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;
}
int main(int argc,char** argv)
{
mxml_node_t *poXmlDoc = NULL;
char inXml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><c><u>уехЩ</u></c>";
//char inXml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><user_name>zhang</user_name>";
//poXmlDoc = mxmlLoadString(NULL, inXml,MXML_NO_CALLBACK );
poXmlDoc = mxmlLoadString(NULL, inXml,MXML_TEXT_CALLBACK );
return 0;
}
/****************************************************************************
* decodePrefsData
*
* Decodes preferences - parses XML and loads preferences into the variables
***************************************************************************/
static bool decodePrefsData() {
bool result = false;
xml = mxmlLoadString(NULL, (char*) savebuffer, MXML_TEXT_CALLBACK);
if (xml) {
// check settings version
item = mxmlFindElement(xml, xml, "file", "version", NULL, MXML_DESCEND);
result = true;
// if (item) // a version entry exists
// {
// const char * version = mxmlElementGetAttr(item, "version");
//
// if (version && strlen(version) == 5) {
// // this code assumes version in format X.X.X
// // XX.X.X, X.XX.X, or X.X.XX will NOT work
// int verMajor = version[0] - '0';
// int verMinor = version[2] - '0';
// int verPoint = version[4] - '0';
// int curMajor = APPVERSION[0] - '0';
// int curMinor = APPVERSION[2] - '0';
// int curPoint = APPVERSION[4] - '0';
//
// // first we'll check that the versioning is valid
// if (!(verMajor >= 0 && verMajor <= 9 &&
// verMinor >= 0 && verMinor <= 9 &&
// verPoint >= 0 && verPoint <= 9))
// result = false;
// else if (verMajor < 4) // less than version 4.0.0
// result = false; // reset settings
// else if (verMajor == 4 && verMinor == 0 && verPoint < 2) // anything less than 4.0.2
// result = false; // reset settings
// else if ((verMajor * 100 + verMinor * 10 + verPoint) >
// (curMajor * 100 + curMinor * 10 + curPoint)) // some future version
// result = false; // reset settings
// else
// result = true;
// }
// }
if (result) {
// Menu Settings
loadXMLSetting(&XMPlayerCfg.exit_action, "ExitAction");
loadXMLSetting(&XMPlayerCfg.language, "language");
loadXMLSetting(&XMPlayerCfg.sort_order, "sort_order");
}
mxmlDelete(xml);
printf("XMPlayerCfg.language : %d\n",XMPlayerCfg.language);
}
printf("[decodePrefsData] xml: %s result: %s\n", (xml)?"true":"false", (result)?"true":"false");
return result;
}
mxml_node_t *backup_tree_init(void)
{
mxml_node_t *xml;
backup_tree = mxmlLoadString(NULL, "<backup_file/>", MXML_NO_CALLBACK);
if (!backup_tree) return NULL;
xml = mxmlNewElement(backup_tree, "cwmp");
if (!xml) return NULL;
return xml;
}
static bool game_data_init(const char *fname, bool from_update)
{
static bool initialized = false;
if(initialized){
return true;
}
if(!decrypt_file(fname, from_update)){
printf("Error decrypting file!\n");
return false;
}
xml = mxmlNewXML("1.0");
tree = mxmlLoadString(xml, decoded, MXML_TEXT_CALLBACK);
return (tree != NULL);
}
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;
}
int uitsVerify (void)
{
FILE *payloadFP;
char *uitsPayloadXMLString;
mxml_node_t *xml;
vprintf("Verify UITS payload ...\n");
/* make sure that all required parameters are non-null */
uitsCheckRequiredParams("verify");
/* initialize the payload xml by either reading it from a standalone payload or
* extracting from an audio file. If both standalone and audio file are specified,
* standalone takes precedence.
*/
if (payloadFileName) { /* verify standalone payload */
vprintf("About to verify payload in file %s ...\n", payloadFileName);
uitsPayloadXMLString = uitsReadFile(payloadFileName);
} else {
vprintf("About to verify payload in file %s ...\n", audioFileName);
uitsPayloadXMLString = uitsAudioExtractPayload (audioFileName);
uitsHandleErrorPTR(payloadModuleName, "uitsVerify", uitsPayloadXMLString, ERR_PAYLOAD,
"Couldn't extract payload XML from audio file\n");
}
/* convert the XML string to an mxml tree */
xml = mxmlLoadString (NULL, uitsPayloadXMLString, MXML_OPAQUE_CALLBACK);
uitsHandleErrorPTR(payloadModuleName, "uitsVerify", xml, ERR_PAYLOAD,
"Couldn't convert payload XML to xml tree\n");
err = uitsVerifyPayloadXML (xml,
uitsPayloadXMLString,
XSDFileName,
mediaHashNoVerifyFlag,
uitsSignatureDesc);
uitsHandleErrorINT(payloadModuleName, "uitsVerifyPayloadFile", err, 0, ERR_VERIFY,
"Error: Payload failed validation\n");
vprintf("Payload verified!\n");
return (OK);
}
int verify_findMD5Sum(const char * md5orig, int disc_type) {
print_gecko("Looking for MD5 [%s]\r\n", md5orig);
char *xmlPointer = (disc_type == IS_NGC_DISC) ? ngcDAT : wiiDAT;
if(xmlPointer) {
mxml_node_t *pointer = (disc_type == IS_NGC_DISC) ? ngcXML : wiiXML;
pointer = mxmlLoadString(NULL, xmlPointer, MXML_TEXT_CALLBACK);
print_gecko("Looking in the %s XML\r\n", pointer == ngcXML ? "GameCube" : "Wii");
if (pointer) {
// open the <datafile>
mxml_node_t *item = mxmlFindElement(pointer, pointer, "datafile", NULL,
NULL, MXML_DESCEND);
print_gecko("DataFile Pointer OK\r\n");
if (item) {
mxml_index_t *iterator = mxmlIndexNew(item, "game", NULL);
mxml_node_t *gameElem = NULL;
//print_gecko("Item Pointer OK\r\n");
// iterate over all the <game> entries
while ((gameElem = mxmlIndexEnum(iterator)) != NULL) {
// get the md5 and compare it
mxml_node_t *md5Elem = mxmlFindElement(gameElem, gameElem,
NULL, "md5", NULL, MXML_DESCEND);
// get the name too
mxml_node_t *nameElem = mxmlFindElement(gameElem, gameElem,
NULL, "name", NULL, MXML_DESCEND);
char md5[64];
memset(&md5[0], 0, 64);
strncpy(&md5[0], mxmlElementGetAttr(md5Elem, "md5"), 32);
//print_gecko("Comparing game [%s] and md5 [%s]\r\n",mxmlElementGetAttr(nameElem, "name"),mxmlElementGetAttr(md5Elem, "md5"));
if (!strnicmp(&md5[0], md5orig, 32)) {
snprintf(&gameName[0], 128, "%s", mxmlElementGetAttr(
nameElem, "name"));
print_gecko("Found a match!\r\n");
return 1;
}
}
}
}
}
return 0;
}
XmlNode::XmlNode( const char * filename )
{
_parent = NULL;
_data = NULL;
Utils::FileStream fs;
if(!fs.Open(filename))
return;
uint size = (uint)fs.Size();
if(size == 0)
return;
std::string buf;
buf.resize(size);
fs.Read(&buf[0], size);
fs.Close();
mxml_node_t * root = mxmlLoadString(NULL, &buf[0], NULL);
_data = root;
}
BOOL
main_parse_patches_list(CHAR *list)
{
mxml_node_t *tree, *node;
if (list == NULL)
return RES_FAIL;
tree = mxmlLoadString(NULL, list, MXML_TEXT_CALLBACK);
if (tree == NULL)
{
dialog_set_status("main_parse_patches_list: mxmlLoadString() выполнена с ошибкой");
return RES_FAIL;
}
for (node = mxmlFindElement(tree, tree, "patch", NULL, NULL, MXML_DESCEND);
node != NULL;
node = mxmlFindElement(node, tree, "patch", NULL, NULL, MXML_DESCEND))
{
CHAR *number, *grf, *action, *patch_file, *target;
number = (CHAR *)mxmlElementGetAttr(node, "number");
grf = (CHAR *)mxmlElementGetAttr(node, "grf");
action = (CHAR *)mxmlElementGetAttr(node, "action");
target = (CHAR *)mxmlElementGetAttr(node, "target");
if (number &&
node->child &&
node->child->type == MXML_TEXT)
{
if (atoi(number) <= options.last_patch)
continue;
patch_file = node->child->value.text.string;
if (main_perform_patch(patch_file, action, grf, target))
return RES_FAIL;
options.last_patch = atoi(number);
options_save_last_patch();
}
}
return RES_OK;
}
bool XMLwrapper::checkfileinformation(char *filename){
stackpos=0;
ZERO(&parentstack,(int)sizeof(parentstack));
if (tree!=NULL) mxmlDelete(tree);tree=NULL;
char *xmldata=doloadfile(filename);
if (xmldata==NULL) return(-1);//the file could not be loaded or uncompressed
char *start=strstr(xmldata,"<INFORMATION>");
char *end=strstr(xmldata,"</INFORMATION>");
if ((start==NULL)||(end==NULL)||(start>end)) {
delete []xmldata;
return(false);
};
end+=strlen("</INFORMATION>");
end[0]='\0';
tree=mxmlNewElement(MXML_NO_PARENT,"?xml");
node=root=mxmlLoadString(tree,xmldata,MXML_OPAQUE_CALLBACK);
if (root==NULL) {
delete []xmldata;
mxmlDelete(tree);
node=root=tree=NULL;
return(false);
};
root=mxmlFindElement(tree,tree,"INFORMATION",NULL,NULL,MXML_DESCEND);
push(root);
if (root==NULL){
delete []xmldata;
mxmlDelete(tree);
node=root=tree=NULL;
return(false);
};
exitbranch();
if (tree!=NULL) mxmlDelete(tree);
delete []xmldata;
node=root=tree=NULL;
return(true);
};
message* message_factory(const string& in)
{
mxml_node_t* xml = mxmlLoadString(NULL,in.c_str(),MXML_TEXT_CALLBACK);
if(xml == NULL)
{
throw malformed_xml("Received malformed XML from the server");
}
mxml_node_t* node = mxmlFindElement(xml,xml,"type",NULL,NULL,MXML_DESCEND);
if(node == NULL || node->child == NULL)
throw malformed_xml("Recieved malformed XML from server (no type)");
string tcode = string(node->child->value.text.string);
if(tcode == string("2"))
{
return new init_reply_msg(xml);
}
else if(tcode == string("6"))
{
cerr << "Got error message" << endl;
}
else if(tcode == string("5"))
{
return new update_reply_msg(xml);
}
else if(tcode == string("15"))
{
//log_error("Got peer offer");
return new peer_offer_msg(xml);
}
else if(tcode == string("20"))
{
//log_error("Got offer accept");
return new offer_accept_msg(xml);
}
else if(tcode == string("25"))
{
//log_error("Got offer holdoff");
return new offer_holdoff_msg(xml);
}
}
char *parse_xml_cmd_by_mxml(const char *xml_buf, char cmd_buf[], size_t size)
{
mxml_node_t *mxml_node_tree = NULL;
mxml_node_t *mxml_node_node = NULL;
mxml_attr_t *mxml_attr = NULL;
if (NULL == xml_buf)
{
printf("xml_buf NULL.\n");
return NULL;
}
if (NULL == (mxml_node_tree = mxmlLoadString(NULL, xml_buf, MXML_TEXT_CALLBACK)))
{
printf("mxmlLoadString error.\n");
return NULL;
}
mxml_node_node = mxmlFindElement(mxml_node_tree, mxml_node_tree,
NULL, NULL, NULL, MXML_DESCEND_FIRST);
if (NULL != mxml_node_node)
{
if (0 == strcmp(mxml_node_node->value.element.name, MESSAGE_STR))
{
if (0 < mxml_node_node->value.element.num_attrs)
{
mxml_attr = mxml_node_node->value.element.attrs;
if (0 == strcmp(mxml_attr->name, MESSAGE_TYPE_STR))
{
snprintf(cmd_buf, size, "%s", mxml_attr->value);
mxmlDelete(mxml_node_tree);
return cmd_buf;
}
}
}
}
mxmlDelete(mxml_node_tree);
return NULL;
}
bool XMLwrapper::putXMLdata(char *xmldata){
if (tree!=NULL) mxmlDelete(tree);
tree=NULL;
ZERO(&parentstack,(int)sizeof(parentstack));
ZERO(&values,(int)sizeof(values));
stackpos=0;
if (xmldata==NULL) return (false);
root=tree=mxmlLoadString(NULL,xmldata,MXML_OPAQUE_CALLBACK);
if (tree==NULL) return(false);
node=root=mxmlFindElement(tree,tree,"paulstretch-data",NULL,NULL,MXML_DESCEND);
if (root==NULL) return (false);;
push(root);
return(true);
};
int addSignature(
char *unsignedMessage,
char *signature,
char *signedMessage,
int size)
{
mxml_node_t *xDoc;
mxml_node_t *messageNode;
mxml_node_t *innerNode;
xDoc = mxmlLoadString( NULL, unsignedMessage, MXML_NO_CALLBACK);
messageNode = mxmlGetFirstChild(xDoc);
innerNode = mxmlNewElement(messageNode, "signature");
mxmlNewText(innerNode, 0, signature); //por em base64
---PROVOCARE ERRO ____ base64
mxmlSaveString (xDoc, message, size, MXML_NO_CALLBACK);
mxmlDelete(xDoc);
}
void StreamlineSetup::handleDeliver(char* xml) {
mxml_node_t *tree;
// Determine xml type
tree = mxmlLoadString(NULL, xml, MXML_NO_CALLBACK);
if (mxmlFindElement(tree, tree, TAG_SESSION, NULL, NULL, MXML_DESCEND_FIRST)) {
// Session XML
gSessionData.parseSessionXML(xml);
sendData(NULL, 0, RESPONSE_ACK);
logg.logMessage("Received session xml");
} else if (mxmlFindElement(tree, tree, TAG_CONFIGURATIONS, NULL, NULL, MXML_DESCEND_FIRST)) {
// Configuration XML
writeConfiguration(xml);
sendData(NULL, 0, RESPONSE_ACK);
logg.logMessage("Received configuration xml");
} else {
// Unknown XML
logg.logMessage("Received unknown XML delivery type");
sendData(NULL, 0, RESPONSE_NAK);
}
mxmlDelete(tree);
}
void getUserInfo (std::string &xmlstr, struct t_login * dest){
mxml_node_t *xml;
mxml_node_t *value;
size_t pos = 0;
while(1){
pos = xmlstr.find("&amp;", pos);
if(pos == std::string::npos) break;
xmlstr.replace(pos, 9, "&");
}
xml = mxmlLoadString(NULL, xmlstr.c_str(), MXML_OPAQUE_CALLBACK);
if(!xml){
return;
}
value = mxmlFindElement(xml, xml, "id", NULL, NULL, MXML_DESCEND);
sscanf(value->child->value.opaque, "%llu", &(dest->userid));
value = mxmlFindElement(xml, xml, "profile_image_url", NULL, NULL, MXML_DESCEND);
strncpy(dest->imageurl, value->child->value.opaque, 255);
mxmlDelete(xml);
}
void
parseCMD(int *clntSocket, char *buffer)
{
mxml_node_t *tree;
printf("The xml was: %s\n", (char *) buffer);
tree = mxmlLoadString(NULL, buffer, MXML_NO_CALLBACK);
mxml_node_t *node = mxmlFindElement(tree, tree, "cmd", NULL, NULL,
MXML_DESCEND);
mxml_node_t *n_node = mxmlFindElement(node, tree, "name", NULL, NULL,
MXML_DESCEND);
mxml_node_t *arg1_node = mxmlFindElement(node, tree, "arg1", NULL, NULL,
MXML_DESCEND);
char * cmd = mxmlGetText(n_node, 0);
char * arg = mxmlGetText(arg1_node, 0);
printf("The cmd was: %s and has argument: %s\n", cmd, arg);
int key = keyfromstring(cmd);
switch (key)
{
case PULL: /* ... */
downloadFileCMD();
break;
case PUSH: /* ... */
break;
case MSG: /* ... */
break;
case QUIT: /* ... */
break;
default:
printf("The cmd was %s", (char *)cmd);
break;
}
//char *newMsg = "";
//send(*clntSocket, newMsg, strlen(newMsg), 0);
}
static bool
decodePalsData ()
{
bool result = false;
xml = mxmlLoadString(NULL, (char *) savebuffer, MXML_TEXT_CALLBACK);
if (xml)
{
// count number of palettes in file
loadedPalettes = 0;
item = mxmlFindElement(xml, xml, "palette", NULL, NULL, MXML_DESCEND);
for (section = mxmlFindElement(item, xml, "game", NULL, NULL,
MXML_DESCEND); section; section = mxmlFindElement(section, xml,
"game", NULL, NULL, MXML_NO_DESCEND))
{
loadedPalettes++;
}
// Allocate enough memory for all palettes in file, plus all hardcoded palettes,
// plus one new palette
if (palettes)
free(palettes);
palettes = (gamePalette *)malloc(sizeof(gamePalette)*loadedPalettes);
// Load all palettes in file, hardcoded palettes are added later
int i = 0;
for (section = mxmlFindElement(item, xml, "game", NULL, NULL,
MXML_DESCEND); section; section = mxmlFindElement(section, xml,
"game", NULL, NULL, MXML_NO_DESCEND))
{
loadXMLPaletteFromSection(palettes[i]);
i++;
}
mxmlDelete(xml);
}
return result;
}
