JFW DH PS3 Custom Firmware Status Update and CFW Pics Arrive

//XML PARSER BY BLIPI
//Feel free to distribute and use it on any plattform and projects

#ifndef XMLPARSER_H
#define XMLPARSER_H

#include
#include
#include
#include

typedef struct xml_node_attr{
char *name;
char *value;

struct xml_node_attr *next;
}xml_node_attr;

typedef struct xml_node{
char *name;
char *value;
int level;
long start_pos;
long end_pos;
char closed;


struct xml_node_attr *attrs;
struct xml_node *next;
struct xml_node *last;
struct xml_node *child;
struct xml_node *parent;
}xml_node;

int XML_Open(char *path);

struct xml_node *XML_ParseAll();
struct xml_node *XML_SearchNodeFrom(char *name, struct xml_node *start);
struct xml_node *XML_SearchNode(char *name);
struct xml_node *XML_GetChild(struct xml_node *node);
struct xml_node *XML_GetNextNode(struct xml_node *node);

struct xml_node_attr *XML_GetNodeAttr(struct xml_node *node, char *name);
char *XML_GetNodeValue(struct xml_node *node);

void XML_EndParse(char free_tree);

#endif

#include "xmlparser.h"


// ----- DEFINES ----- //
#define XML_UNKNOW -1
#define XML_DUNNOHANDLE -2
#define XML_OPEN_NODE 1
#define XML_CLOSE_NODE 2
#define XML_NODE_NAME 3
#define XML_SPECIAL_NODE 4
#define XML_NAME_DELIMITER 5
#define XML_ATTR_START 6
#define XML_ATTR_DELIMITER 7
#define XML_NODE_END 8
#define XML_CLOSE_END_NODE 9


// ----- STRUCTS ----- //
typedef struct xml_reader_{
char reading_tag;
char quote_read;
char node_ending;

int lvl;

long cur_pos;

char read_buffer[1024];
char name_buffer[1024];
}xml_reader_;

xml_reader_ xml_reader = {0};

typedef struct ret_{
int ret;
char ch;
}ret_;


// ----- PROTOTYPES ----- //
void XML_FreeList( void );
struct ret_ XML_GetChar( void );
struct xml_node *XML_RecursiveSearchNode(char *name, struct xml_node *node);


// ----- VARIABLES -----//
char xml_path[1024];

char *xml_buffer = NULL;
long xml_size = 0;


struct xml_node *main_tree = NULL;
struct xml_node *current_node = NULL;

// ----- CODE ----- //

//! Abrir el archivo para parsear posteriormente
//! path: Ruta relativa o hard coded hacia el xml
//TODO: No guardar en buffer, leer char a char!
int XML_Open(char *path){
FILE *fp = fopen(path, "r");
if(!fp)
return -1;

strcpy(xml_path, path);

fseek(fp, 0, SEEK_END);
xml_size = ftell(fp);
rewind(fp);

xml_buffer = (char*)malloc(xml_size+1);
if(!xml_buffer)
return -2;

fread(xml_buffer, 1, xml_size, fp);

fclose(fp);

return 0;
}


struct ret_ XML_GetChar(){
char ch = xml_buffer[xml_reader.cur_pos++];
struct ret_ ret;
ret.ch = ch;

if(xml_reader.quote_read == 1 && ch != '"'){
ret.ret = XML_NODE_NAME;
goto endfunc;
}
if(xml_reader.reading_tag == 0){
switch(ch){
case '':
xml_reader.reading_tag = 0;
if(xml_buffer[xml_reader.cur_pos-2] == '/')
ret.ret = XML_CLOSE_END_NODE;
else
ret.ret = XML_CLOSE_NODE;
goto endfunc;
case '?':
ret.ret = XML_SPECIAL_NODE;
goto endfunc;
case ' ':
ret.ret = XML_NAME_DELIMITER;
goto endfunc;
case '=':
ret.ret = XML_ATTR_START;
goto endfunc;
case '"':
xml_reader.quote_read = !xml_reader.quote_read;
ret.ret = XML_ATTR_DELIMITER;
goto endfunc;
}
}
}


endfunc:
return ret;
}

struct xml_node *XML_ParseAll(){
char action = 0;
char ignore = 0;
int buffer_pos = 0;

memset(xml_reader.read_buffer, 0, 1024);
memset(xml_reader.name_buffer, 0, 1024);
xml_reader.reading_tag = 0;
xml_reader.quote_read = 0;

struct xml_node_attr *last_attr = NULL;
struct xml_node_attr *first_attr = NULL;

while(xml_reader.cur_pos < xml_size){
struct ret_ ret = XML_GetChar();

if(ignore && ret.ret != XML_SPECIAL_NODE)
continue;

switch(ret.ret){
case XML_SPECIAL_NODE:
ignore = !ignore;
break;
case XML_OPEN_NODE:

if(!main_tree){
main_tree = current_node = (struct xml_node*)malloc(sizeof(struct xml_node));
memset(current_node, 0, sizeof(struct xml_node));
}else if(current_node->closed){
current_node->next = (struct xml_node*)malloc(sizeof(struct xml_node));
memset(current_node->next, 0, sizeof(struct xml_node));
current_node->next->parent = current_node->parent;
current_node->next->last = current_node;
current_node = current_node->next;
}else{
current_node->child = (struct xml_node*)malloc(sizeof(struct xml_node));
memset(current_node->child, 0, sizeof(struct xml_node));
current_node->child->parent = current_node;
current_node = current_node->child;
}

action = 0;
break;
case XML_NODE_NAME:
xml_reader.read_buffer[buffer_pos++] = ret.ch;
break;
case XML_NAME_DELIMITER:{
if(buffer_pos > 0){

if(action == 0)
strcpy(xml_reader.name_buffer, xml_reader.read_buffer);

memset(xml_reader.read_buffer, 0, 1024);
buffer_pos = 0;

}
}break;

case XML_ATTR_START:{
struct xml_node_attr *temp_attr = (struct xml_node_attr*)malloc(sizeof(struct xml_node_attr));
memset(temp_attr, 0, sizeof(struct xml_node_attr));

temp_attr->name = (char*)malloc(buffer_pos);
strcpy(temp_attr->name, xml_reader.read_buffer);

if(last_attr != NULL)
last_attr->next = temp_attr;
last_attr = temp_attr;

if(first_attr == NULL)
first_attr = last_attr;

memset(xml_reader.read_buffer, 0, 1024);
buffer_pos = 0;
}break;

case XML_ATTR_DELIMITER:
if(xml_reader.quote_read == 0){

last_attr->value = (char*)malloc(buffer_pos);
strcpy(last_attr->value, xml_reader.read_buffer);

memset(xml_reader.read_buffer, 0, 1024);
buffer_pos = 0;
}
break;

case XML_CLOSE_END_NODE:
case XML_CLOSE_NODE:
if(xml_reader.node_ending == 0){
current_node->name = (char*)malloc(buffer_pos);
if(strlen(xml_reader.name_buffer) > 0)
strcpy(current_node->name, xml_reader.name_buffer);
else
strcpy(current_node->name, xml_reader.read_buffer);

current_node->level = xml_reader.lvl;
current_node->attrs = first_attr;
current_node->start_pos = xml_reader.cur_pos;
}

memset(xml_reader.name_buffer, 0, 1024);
memset(xml_reader.read_buffer, 0, 1024);
buffer_pos = 0;

first_attr = NULL;
last_attr = NULL;

if(ret.ret == XML_CLOSE_END_NODE){
current_node->closed = 1;
current_node->end_pos = xml_reader.cur_pos;
}

break;

case XML_NODE_END:
while(current_node->closed == 1)
current_node = current_node->parent;

current_node->closed = 1;
current_node->end_pos = xml_reader.cur_pos;

memset(xml_reader.name_buffer, 0, 1024);
memset(xml_reader.read_buffer, 0, 1024);
buffer_pos = 0;

break;

default:
break;
}
}

return main_tree;
}

struct xml_node *XML_RecursiveSearchNode(char *name, struct xml_node *node){
if(strcmp(name, node->name) == 0)
return node;

struct xml_node *ret = NULL;

if(node->child)
ret = XML_RecursiveSearchNode(name, node->child);

if(ret)
return ret;

if(node->next)
ret = XML_RecursiveSearchNode(name, node->next);

if(ret)
return ret;

return NULL;
}

struct xml_node *XML_SearchNodeFrom(char *name, struct xml_node *start){
return XML_RecursiveSearchNode(name, start);
}
struct xml_node *XML_SearchNode(char *name){
return XML_RecursiveSearchNode(name, main_tree);
}

struct xml_node *XML_GetChild(struct xml_node *node){
return node->child;
}

struct xml_node *XML_GetNextNode(struct xml_node *node){
return node->next;
}

struct xml_node_attr *XML_GetNodeAttr(struct xml_node *node, char *name){
struct xml_node_attr *iterator = node->attrs;
while(iterator != NULL){
if(strcmp(iterator->name, name) == 0)
return iterator;
iterator = iterator->next;
}

return NULL;
}

char *XML_GetNodeValue(struct xml_node *node){
if(node->value == NULL){
int len = node->end_pos - node->start_pos - 1;
char *buffer =(char*)malloc(len);
memcpy(buffer, &xml_buffer[node->start_pos], len);
buffer[len] = '\0';
node->value = buffer;
}
return node->value;
}

void XML_RecursiveFreeNode(xml_node *node){
if(node->child)
XML_RecursiveFreeNode(node->child);

if(node->next)
XML_RecursiveFreeNode(node->next);

free(node);
node = NULL;
}

//! Liberar la memoria ocupada por xml_buffer
void XML_EndParse(char free_tree){
free(xml_buffer);

if(free_tree)
XML_RecursiveFreeNode(main_tree);

main_tree = current_node = NULL;
}