/* returns a HTML string containing the text and attributes of the outline */
static GString *
getOutlineContents (xmlNodePtr cur)
{
GString *buffer;
gchar *value;
buffer = g_string_new (NULL);
value = xml_get_attribute (cur, "text");
if (value) {
g_string_append (buffer, value);
g_free (value);
}
value = xml_get_attribute (cur, "url");
if (value) {
g_string_append_printf (buffer, " <a href=\"%s\">%s</a>", value, value);
g_free (value);
}
value = xml_get_attribute (cur, "htmlUrl");
if (value) {
g_string_append_printf (buffer, " (<a href=\"%s\">HTML</a>)", value);
g_free (value);
}
value = xml_get_attribute (cur, "xmlUrl");
if (value) {
g_string_append_printf (buffer, " (<a href=\"%s\">XML</a>)", value);
g_free (value);
}
return buffer;
}
static void node_image(xml_data_node *node, messtest_command_type_t command)
{
xml_attribute_node *attr_node;
int preload;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = command;
/* 'preload' attribute */
attr_node = xml_get_attribute(node, "preload");
preload = attr_node ? atoi(attr_node->value) : 0;
if (preload)
new_command.command_type = (messtest_command_type_t) (new_command.command_type + 2);
/* 'filename' attribute */
attr_node = xml_get_attribute(node, "filename");
new_command.u.image_args.filename = attr_node ? attr_node->value : NULL;
/* 'tag', 'type', 'slot' attributes */
if (!get_device_identity_tags(node, &new_command.u.image_args.device_ident))
return;
/* 'format' attribute */
attr_node = xml_get_attribute(node, "format");
new_command.u.image_args.format = attr_node ? attr_node->value : NULL;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void get_file_params(xml_data_node *node, const char **filename, const char **fork,
filter_getinfoproc *filter)
{
xml_attribute_node *attr_node;
*filename = NULL;
*fork = NULL;
*filter = NULL;
attr_node = xml_get_attribute(node, "name");
if (!attr_node)
{
error_missingattribute("name");
return;
}
*filename = attr_node->value;
attr_node = xml_get_attribute(node, "fork");
if (attr_node)
*fork = attr_node->value;
attr_node = xml_get_attribute(node, "filter");
if (attr_node)
{
*filter = filter_lookup(attr_node->value);
if (!*filter)
report_message(MSG_FAILURE, "Cannot find filter '%s'", attr_node->value);
}
}
static void node_memverify(xml_data_node *node)
{
xml_attribute_node *attr_node;
const char *s1;
const char *s2;
const char *s3;
int region;
void *new_buffer;
mess_pile pile;
/* <memverify> - verifies that a range of memory contains specific data */
attr_node = xml_get_attribute(node, "start");
s1 = attr_node ? attr_node->value : NULL;
if (!s1)
{
error_missingattribute("start");
return;
}
attr_node = xml_get_attribute(node, "end");
s2 = attr_node ? attr_node->value : NULL;
if (!s2)
s2 = "0";
attr_node = xml_get_attribute(node, "region");
s3 = attr_node ? attr_node->value : NULL;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_VERIFY_MEMORY;
new_command.u.verify_args.start = parse_offset(s1);
new_command.u.verify_args.end = parse_offset(s2);
if (s3)
{
region = memory_region_from_string(s3);
if (region == REGION_INVALID)
error_invalidmemregion(s3);
new_command.u.verify_args.mem_region = region;
}
pile_init(&pile);
messtest_get_data(node, &pile);
new_buffer = pool_malloc(&command_pool, pile_size(&pile));
memcpy(new_buffer, pile_getptr(&pile), pile_size(&pile));
new_command.u.verify_args.verify_data = new_buffer;
new_command.u.verify_args.verify_data_size = pile_size(&pile);
pile_delete(&pile);
if (!append_command())
{
error_outofmemory();
return;
}
}
cheat_parameter::cheat_parameter(cheat_manager &manager, symbol_table &symbols, const char *filename, xml_data_node ¶mnode)
: m_value(0)
{
// read the core attributes
m_minval = number_and_format(xml_get_attribute_int(¶mnode, "min", 0), xml_get_attribute_int_format(¶mnode, "min"));
m_maxval = number_and_format(xml_get_attribute_int(¶mnode, "max", 0), xml_get_attribute_int_format(¶mnode, "max"));
m_stepval = number_and_format(xml_get_attribute_int(¶mnode, "step", 1), xml_get_attribute_int_format(¶mnode, "step"));
// iterate over items
for (xml_data_node *itemnode = xml_get_sibling(paramnode.child, "item"); itemnode != NULL; itemnode = xml_get_sibling(itemnode->next, "item"))
{
// check for NULL text
if (itemnode->value == NULL || itemnode->value[0] == 0)
throw emu_fatalerror("%s.xml(%d): item is missing text\n", filename, itemnode->line);
// check for non-existant value
if (xml_get_attribute(itemnode, "value") == NULL)
throw emu_fatalerror("%s.xml(%d): item is value\n", filename, itemnode->line);
// extract the parameters
UINT64 value = xml_get_attribute_int(itemnode, "value", 0);
int format = xml_get_attribute_int_format(itemnode, "value");
// allocate and append a new item
item &curitem = m_itemlist.append(*global_alloc(item(itemnode->value, value, format)));
// ensure the maximum expands to suit
m_maxval = MAX(m_maxval, curitem.value());
}
// add a variable to the symbol table for our value
symbols.add("param", symbol_table::READ_ONLY, &m_value);
}
static void node_deletedirectory(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err;
xml_attribute_node *attr_node;
if (!state->m_partition)
{
state->m_failed = 1;
report_message(MSG_FAILURE, "Partition not loaded");
return;
}
attr_node = xml_get_attribute(node, "path");
if (!attr_node)
{
state->m_failed = 1;
error_missingattribute("path");
return;
}
err = imgtool_partition_delete_directory(state->m_partition, attr_node->value);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
return;
}
}
static void node_setattr(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err;
xml_attribute_node *attr_node;
UINT32 attribute;
imgtool_attribute value;
attr_node = xml_get_attribute(node, "path");
if (!attr_node)
{
state->m_failed = 1;
error_missingattribute("path");
return;
}
attribute = identify_attribute(state, node, &value);
if (!attribute)
return;
err = imgtool_partition_put_file_attribute(state->m_partition, attr_node->value, attribute, value);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
return;
}
}
static UINT32 identify_attribute(struct imgtooltest_state *state, xml_data_node *node, imgtool_attribute *value)
{
xml_attribute_node *attr_node;
UINT32 attribute;
attr_node = xml_get_attribute(node, "name");
if (!attr_node)
{
state->m_failed = 1;
error_missingattribute("name");
return 0;
}
if (!strcmp(attr_node->value, "mac_file_type"))
attribute = IMGTOOLATTR_INT_MAC_TYPE;
else if (!strcmp(attr_node->value, "mac_file_creator"))
attribute = IMGTOOLATTR_INT_MAC_CREATOR;
else
{
error_missingattribute("name");
return 0;
}
attr_node = xml_get_attribute(node, "value");
if (!attr_node)
{
state->m_failed = 1;
error_missingattribute("value");
return 0;
}
switch(attribute)
{
case IMGTOOLATTR_INT_MAC_TYPE:
case IMGTOOLATTR_INT_MAC_CREATOR:
if (strlen(attr_node->value) != 4)
{
state->m_failed = 1;
error_missingattribute("value");
return 0;
}
value->i = pick_integer_be(attr_node->value, 0, 4);
break;
}
return attribute;
}
void node_testimgtool(xml_data_node *node)
{
xml_data_node *child_node;
xml_attribute_node *attr_node;
struct imgtooltest_state state;
imgtool_init(FALSE, messtest_warn);
attr_node = xml_get_attribute(node, "name");
report_testcase_begin(attr_node ? attr_node->value : NULL);
memset(&state, 0, sizeof(state));
for (child_node = node->child; child_node; child_node = child_node->next)
{
if (!strcmp(child_node->name, "createimage"))
node_createimage(&state, child_node);
else if (!strcmp(child_node->name, "checkfile"))
node_checkfile(&state, child_node);
else if (!strcmp(child_node->name, "checkdirectory"))
node_checkdirectory(&state, child_node);
else if (!strcmp(child_node->name, "putfile"))
node_putfile(&state, child_node);
else if (!strcmp(child_node->name, "deletefile"))
node_deletefile(&state, child_node);
else if (!strcmp(child_node->name, "createdirectory"))
node_createdirectory(&state, child_node);
else if (!strcmp(child_node->name, "deletedirectory"))
node_deletedirectory(&state, child_node);
else if (!strcmp(child_node->name, "recordfreespace"))
node_recordfreespace(&state, child_node);
else if (!strcmp(child_node->name, "checkfreespace"))
node_checkfreespace(&state, child_node);
else if (!strcmp(child_node->name, "setattr"))
node_setattr(&state, child_node);
else if (!strcmp(child_node->name, "checkattr"))
node_checkattr(&state, child_node);
}
report_testcase_ran(state.failed);
/* close out any existing partition */
if (state.partition)
{
imgtool_partition_close(state.partition);
state.partition = NULL;
}
/* close out any existing image */
if (state.image)
{
imgtool_image_close(state.image);
state.image = NULL;
}
imgtool_exit();
}
static void
parse_channel_tag (feedParserCtxtPtr ctxt, xmlNodePtr cur)
{
gchar *value;
value = xml_get_attribute (cur, "resource");
if (!xmlStrcmp (BAD_CAST "errorReportsTo", cur->name))
metadata_list_set (&(ctxt->subscription->metadata), "errorReportsTo", value);
else if (!xmlStrcmp (BAD_CAST "generatorAgent", cur->name))
metadata_list_set (&(ctxt->subscription->metadata), "feedgeneratorUri", value);
g_free (value);
}
static int get_device_identity_tags(xml_data_node *node, messtest_device_identity *ident)
{
xml_attribute_node *attr_node;
const char *s2;
/* clear out the result */
memset(ident, 0, sizeof(*ident));
/* 'type' attribute */
attr_node = xml_get_attribute(node, "type");
if (attr_node != NULL)
{
s2 = attr_node->value;
ident->type = device_config_image_interface::device_typeid(s2);
if (ident->type <= IO_UNKNOWN)
{
error_baddevicetype(s2);
return FALSE;
}
}
else
{
/* the device type was unspecified */
ident->type = IO_UNKNOWN;
}
/* 'slot' attribute */
attr_node = xml_get_attribute(node, "slot");
ident->slot = (attr_node != NULL) ? atoi(attr_node->value) : 0;
/* 'tag' attribute */
attr_node = xml_get_attribute(node, "tag");
ident->tag = (attr_node != NULL) ? attr_node->value : NULL;
return TRUE;
}
static void node_switch(xml_data_node *node)
{
xml_attribute_node *attr_node;
const char *s1;
const char *s2;
/* <switch> - switches a DIP switch/config setting */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_SWITCH;
/* 'name' attribute */
attr_node = xml_get_attribute(node, "name");
if (!attr_node)
{
error_missingattribute("name");
return;
}
s1 = attr_node->value;
/* 'value' attribute */
attr_node = xml_get_attribute(node, "value");
if (!attr_node)
{
error_missingattribute("value");
return;
}
s2 = attr_node->value;
new_command.u.switch_args.name = s1;
new_command.u.switch_args.value = s2;
if (!append_command())
{
error_outofmemory();
return;
}
}
xml_data_node *xml_find_matching_sibling(xml_data_node *node, const char *name, const char *attribute, const char *matchval)
{
/* loop over siblings and find a matching attribute */
for ( ; node; node = node->next)
{
/* can pass nullptr as a wildcard for the node name */
if (name == nullptr || strcmp(name, node->name) == 0)
{
/* find a matching attribute */
xml_attribute_node *attr = xml_get_attribute(node, attribute);
if (attr != nullptr && strcmp(attr->value, matchval) == 0)
return node;
}
}
return nullptr;
}
static void node_image(xml_data_node *node, messtest_command_type_t command)
{
xml_attribute_node *attr_node;
const char *s2;
int preload, device_type;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = command;
/* 'preload' attribute */
attr_node = xml_get_attribute(node, "preload");
preload = attr_node ? atoi(attr_node->value) : 0;
if (preload)
new_command.command_type += 2;
/* 'filename' attribute */
attr_node = xml_get_attribute(node, "filename");
new_command.u.image_args.filename = attr_node ? attr_node->value : NULL;
/* 'type' attribute */
attr_node = xml_get_attribute(node, "type");
if (!attr_node)
{
error_missingattribute("type");
return;
}
s2 = attr_node->value;
device_type = device_typeid(s2);
if (device_type < 0)
{
error_baddevicetype(s2);
return;
}
new_command.u.image_args.device_type = device_type;
/* 'slot' attribute */
attr_node = xml_get_attribute(node, "slot");
new_command.u.image_args.device_slot = attr_node ? atoi(attr_node->value) : 0;
/* 'format' attribute */
format_index = 0;
attr_node = xml_get_attribute(node, "format");
new_command.u.image_args.format = attr_node ? attr_node->value : NULL;
/* 'tag' attribute */
attr_node = xml_get_attribute(node, "tag");
new_command.u.image_args.device_tag = attr_node ? attr_node->value : NULL;
if (!append_command())
{
error_outofmemory();
return;
}
}
xml_data_node *xml_find_matching_sibling(xml_data_node *node, const char *name, const char *attribute, const char *matchval)
{
/* loop over siblings and find a matching attribute */
for ( ; node; node = node->next)
{
/* can pass NULL as a wildcard for the node name */
if (!name || !strcmp(name, node->name))
{
/* find a matching attribute */
xml_attribute_node *attr = xml_get_attribute(node, attribute);
if (attr && !strcmp(attr->value, matchval))
return node;
}
}
return NULL;
}
static void node_input(xml_data_node *node)
{
/* <input> - inputs natural keyboard data into a system */
xml_attribute_node *attr_node;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_INPUT;
attr_node = xml_get_attribute(node, "rate");
new_command.u.input_args.rate = atof(attr_node->value);
new_command.u.input_args.input_chars = node->value;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_imageverify(xml_data_node *node)
{
xml_attribute_node *attr_node;
const char *s;
iodevice_t device_type;
void *new_buffer;
mess_pile pile;
/* <imageverify> - verifies that an image contains specific data */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_VERIFY_IMAGE;
/* 'type' attribute */
attr_node = xml_get_attribute(node, "type");
s = attr_node ? attr_node->value : NULL;
if (!s)
{
error_missingattribute("type");
return;
}
device_type = device_typeid(s);
if (device_type < 0)
{
error_baddevicetype(s);
return;
}
new_command.u.verify_args.device_type = device_type;
pile_init(&pile);
messtest_get_data(node, &pile);
new_buffer = pool_malloc(&command_pool, pile_size(&pile));
memcpy(new_buffer, pile_getptr(&pile), pile_size(&pile));
new_command.u.verify_args.verify_data = new_buffer;
new_command.u.verify_args.verify_data_size = pile_size(&pile);
pile_delete(&pile);
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_wait(xml_data_node *node)
{
xml_attribute_node *attr_node;
attr_node = xml_get_attribute(node, "time");
if (!attr_node)
{
error_missingattribute("time");
return;
}
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_WAIT;
new_command.u.wait_time = mame_time_to_double(parse_time(attr_node->value));
if (!append_command())
{
error_outofmemory();
return;
}
}
xml_attribute_node *xml_set_attribute(xml_data_node *node, const char *name, const char *value)
{
xml_attribute_node *anode;
/* first find an existing one to replace */
anode = xml_get_attribute(node, name);
/* if we found it, free the old value and replace it */
if (anode)
{
if (anode->value)
free((void *)anode->value);
anode->value = copystring(value);
}
/* otherwise, create a new node */
else
anode = add_attribute(node, name, value);
return anode;
}
static void
parse_item_tag (feedParserCtxtPtr ctxt, xmlNodePtr cur)
{
gchar *tmp;
/* We ignore the "ping" tag */
if (xmlStrcmp (cur->name, BAD_CAST"about"))
return;
/* RSS 1.0 */
tmp = xml_get_attribute (cur, "about");
/* RSS 2.0 */
if (!tmp)
tmp = (gchar *)xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
if (tmp) {
ctxt->item->metadata = metadata_list_append (ctxt->item->metadata, "related", tmp);
g_free (tmp);
}
}
static void node_checkattr(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err;
xml_attribute_node *attr_node;
UINT32 attribute;
imgtool_attribute value;
imgtool_attribute expected_value;
memset(&value, 0, sizeof(value));
memset(&expected_value, 0, sizeof(expected_value));
attr_node = xml_get_attribute(node, "path");
if (!attr_node)
{
state->m_failed = 1;
error_missingattribute("path");
return;
}
attribute = identify_attribute(state, node, &expected_value);
if (!attribute)
return;
err = imgtool_partition_get_file_attribute(state->m_partition, attr_node->value, attribute, &value);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
return;
}
if (memcmp(&value, &expected_value, sizeof(value)))
{
state->m_failed = 1;
report_message(MSG_FAILURE, "Comparison failed");
return;
}
}
/* method to parse standard tags for each item element */
itemPtr parseEntry(feedParserCtxtPtr ctxt, xmlNodePtr cur) {
xmlChar *xtmp;
gchar *tmp2, *tmp;
NsHandler *nsh;
parseItemTagFunc pf;
g_assert(NULL != cur);
ctxt->item = item_new();
cur = cur->xmlChildrenNode;
while(cur) {
if(!cur->name) {
g_warning("invalid XML: parser returns NULL value -> tag ignored!");
cur = cur->next;
continue;
}
/* check namespace of this tag */
if(cur->ns) {
if((cur->ns->href && (nsh = (NsHandler *)g_hash_table_lookup(ns_pie_ns_uri_table, (gpointer)cur->ns->href))) ||
(cur->ns->prefix && (nsh = (NsHandler *)g_hash_table_lookup(pie_nstable, (gpointer)cur->ns->prefix)))) {
if(NULL != (pf = nsh->parseItemTag))
(*pf)(ctxt, cur);
cur = cur->next;
continue;
} else {
/*g_print("unsupported namespace \"%s\"\n", cur->ns->prefix);*/
}
} /* explicitly no following else !!! */
if(!xmlStrcmp(cur->name, BAD_CAST"title")) {
if(NULL != (tmp = unhtmlize(pie_parse_content_construct(cur)))) {
item_set_title(ctxt->item, tmp);
g_free(tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"link")) {
if(NULL != (tmp2 = xml_get_attribute(cur, "href"))) {
/* 0.3 link : rel, type and href attribute */
xtmp = xmlGetProp(cur, BAD_CAST"rel");
if(xtmp != NULL && !xmlStrcmp(xtmp, BAD_CAST"alternate"))
item_set_source(ctxt->item, tmp2);
/* else
FIXME: Maybe do something with other links? */
xmlFree(xtmp);
g_free(tmp2);
} else {
/* 0.2 link : element content is the link, or non-alternate link in 0.3 */
if(NULL != (tmp = (gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1))) {
item_set_source(ctxt->item, tmp);
g_free(tmp);
}
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"author")) {
/* parse feed author */
tmp = parseAuthor(cur);
ctxt->item->metadata = metadata_list_append(ctxt->item->metadata, "author", tmp);
g_free(tmp);
} else if(!xmlStrcmp(cur->name, BAD_CAST"contributor")) {
/* parse feed contributors */
tmp = parseAuthor(cur);
ctxt->item->metadata = metadata_list_append(ctxt->item->metadata, "contributor", tmp);
g_free(tmp);
} else if(!xmlStrcmp(cur->name, BAD_CAST"id")) {
if(NULL != (tmp = (gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1))) {
item_set_id(ctxt->item, tmp);
g_free(tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"issued")) {
/* FIXME: is <modified> or <issued> or <created> the time tag we want to display? */
if(NULL != (tmp = (gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1))) {
ctxt->item->time = date_parse_ISO8601 (tmp);
g_free(tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"content")) {
/* <content> support */
if(NULL != (tmp = pie_parse_content_construct(cur))) {
item_set_description(ctxt->item, tmp);
g_free(tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"summary")) {
/* <summary> can be used for short text descriptions, if there is no
<content> description we show the <summary> content */
if(!item_get_description(ctxt->item)) {
if(NULL != (tmp = pie_parse_content_construct(cur))) {
item_set_description(ctxt->item, tmp);
g_free(tmp);
}
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"copyright")) {
if(NULL != (tmp = (gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1))) {
ctxt->item->metadata = metadata_list_append(ctxt->item->metadata, "copyright", tmp);
g_free(tmp);
}
}
cur = cur->next;
}
/* after parsing we fill the infos into the itemPtr structure */
ctxt->item->readStatus = FALSE;
return ctxt->item;
}
void node_testzippath(xml_data_node *node)
{
xml_attribute_node *attr_node;
xml_data_node *first_child_node;
xml_data_node *child_node;
const char *path;
const char *plus;
astring *apath = NULL;
zippath_directory *directory = NULL;
const osd_directory_entry *dirent;
const char *type_string;
file_error err;
UINT64 size;
mess_pile pile;
core_file *file = NULL;
pile_init(&pile);
/* name the test case */
report_testcase_begin("zippath");
/* retrieve path */
attr_node = xml_get_attribute(node, "path");
path = (attr_node != NULL) ? attr_node->value : "";
/* retrieve 'plus' - for testing zippath_combine */
attr_node = xml_get_attribute(node, "plus");
if (attr_node != NULL)
{
plus = attr_node->value;
apath = zippath_combine(astring_alloc(), path, plus);
report_message(MSG_INFO, "Testing ZIP Path '%s' + '%s' ==> '%s'", path, plus, astring_c(apath));
}
else
{
apath = astring_cpyc(astring_alloc(), path);
report_message(MSG_INFO, "Testing ZIP Path '%s'", astring_c(apath));
}
/* try doing a file compare */
messtest_get_data(node, &pile);
if (pile_size(&pile) > 0)
{
err = zippath_fopen(astring_c(apath), OPEN_FLAG_READ, &file, NULL);
if (err != FILERR_NONE)
{
report_message(MSG_FAILURE, "Error %d opening file", (int) err);
goto done;
}
if (pile_size(&pile) != core_fsize(file))
{
report_message(MSG_FAILURE, "Expected file to be of length %d, instead got %d", (int) pile_size(&pile), (int) core_fsize(file));
goto done;
}
if (memcmp(pile_getptr(&pile), core_fbuffer(file), pile_size(&pile)))
{
report_message(MSG_FAILURE, "File sizes match, but contents do not");
goto done;
}
}
/* try doing a directory listing */
first_child_node = xml_get_sibling(node->child, "entry");
if (first_child_node != NULL)
{
err = zippath_opendir(astring_c(apath), &directory);
if (err != FILERR_NONE)
{
report_message(MSG_FAILURE, "Error %d opening directory", (int) err);
goto done;
}
/* read each directory entry */
while((dirent = zippath_readdir(directory)) != NULL)
{
/* find it in the list */
for (child_node = first_child_node; child_node != NULL; child_node = xml_get_sibling(child_node->next, "entry"))
{
attr_node = xml_get_attribute(child_node, "name");
if ((attr_node != NULL) && !strcmp(attr_node->value, dirent->name))
break;
}
/* did we find the node? */
if (child_node != NULL)
{
/* check dirent type */
attr_node = xml_get_attribute(child_node, "type");
if (attr_node != NULL)
{
type_string = dir_entry_type_string(dirent->type);
if (mame_stricmp(attr_node->value, type_string))
report_message(MSG_FAILURE, "Expected '%s' to be '%s', but instead got '%s'", dirent->name, attr_node->value, type_string);
}
/* check size */
attr_node = xml_get_attribute(child_node, "size");
if (attr_node != NULL)
{
size = atoi(attr_node->value);
if (size != dirent->size)
report_message(MSG_FAILURE, "Expected '%s' to be of size '%ld', but instead got '%ld'", dirent->name, (long) size, (long) dirent->size);
}
}
else
{
report_message(MSG_FAILURE, "Unexpected directory entry '%s'", dirent->name);
}
}
}
done:
pile_delete(&pile);
if (apath != NULL)
astring_free(apath);
if (file != NULL)
core_fclose(file);
if (directory != NULL)
zippath_closedir(directory);
}
const char *xml_get_attribute_string(xml_data_node *node, const char *attribute, const char *defvalue)
{
xml_attribute_node *attr = xml_get_attribute(node, attribute);
return attr ? attr->value : defvalue;
}
/* reads a PIE feed URL and returns a new channel structure (even if
the feed could not be read) */
static void pie_parse(feedParserCtxtPtr ctxt, xmlNodePtr cur) {
gchar *tmp2, *tmp = NULL, *tmp3;
NsHandler *nsh;
parseChannelTagFunc pf;
while(TRUE) {
if(xmlStrcmp(cur->name, BAD_CAST"feed")) {
g_string_append(ctxt->feed->parseErrors, "<p>Could not find Atom/Echo/PIE header!</p>");
break;
}
/* parse feed contents */
cur = cur->xmlChildrenNode;
while(cur) {
if(!cur->name || cur->type != XML_ELEMENT_NODE) {
cur = cur->next;
continue;
}
/* check namespace of this tag */
if(cur->ns) {
if((cur->ns->href && (nsh = (NsHandler *)g_hash_table_lookup(ns_pie_ns_uri_table, (gpointer)cur->ns->href))) ||
(cur->ns->prefix && (nsh = (NsHandler *)g_hash_table_lookup(pie_nstable, (gpointer)cur->ns->prefix)))) {
pf = nsh->parseChannelTag;
if(pf)
(*pf)(ctxt, cur);
cur = cur->next;
continue;
} else {
/*g_print("unsupported namespace \"%s\"\n", cur->ns->prefix);*/
}
} /* explicitly no following else !!! */
if(!xmlStrcmp(cur->name, BAD_CAST"title")) {
tmp = unhtmlize(pie_parse_content_construct(cur));
if(tmp) {
if(ctxt->title)
g_free(ctxt->title);
ctxt->title = tmp;
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"link")) {
tmp = xml_get_attribute (cur, "href");
if(tmp) {
/* 0.3 link : rel, type and href attribute */
tmp2 = xml_get_attribute (cur, "rel");
if(tmp2 && g_str_equal(tmp2, "alternate"))
subscription_set_homepage (ctxt->subscription, tmp);
/* else
FIXME: Maybe do something with other links? */
g_free(tmp2);
g_free(tmp);
} else {
/* 0.2 link : element content is the link, or non-alternate link in 0.3 */
tmp = (gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1);
if(tmp) {
subscription_set_homepage (ctxt->subscription, tmp);
g_free(tmp);
}
}
/* parse feed author */
} else if(!xmlStrcmp(cur->name, BAD_CAST"author")) {
/* parse feed author */
tmp = parseAuthor(cur);
if(tmp) {
ctxt->subscription->metadata = metadata_list_append(ctxt->subscription->metadata, "author", tmp);
g_free(tmp);
}
} else if (!xmlStrcmp (cur->name, BAD_CAST"tagline")) {
tmp = pie_parse_content_construct (cur);
if (tmp) {
metadata_list_set (&ctxt->subscription->metadata, "description", tmp);
g_free (tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"generator")) {
tmp = unhtmlize((gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1));
if(tmp && tmp[0] != '\0') {
tmp2 = xml_get_attribute (cur, "version");
if(tmp2) {
tmp3 = g_strdup_printf("%s %s", tmp, tmp2);
g_free(tmp);
g_free(tmp2);
tmp = tmp3;
}
tmp2 = xml_get_attribute (cur, "url");
if(tmp2) {
tmp3 = g_strdup_printf("<a href=\"%s\">%s</a>", tmp2, tmp);
g_free(tmp2);
g_free(tmp);
tmp = tmp3;
}
ctxt->subscription->metadata = metadata_list_append(ctxt->subscription->metadata, "feedgenerator", tmp);
}
g_free(tmp);
} else if(!xmlStrcmp(cur->name, BAD_CAST"copyright")) {
tmp = pie_parse_content_construct(cur);
if(tmp) {
ctxt->subscription->metadata = metadata_list_append(ctxt->subscription->metadata, "copyright", tmp);
g_free(tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"modified")) { /* Modified was last used in IETF draft 02) */
tmp = (gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1);
if(tmp) {
ctxt->subscription->metadata = metadata_list_append(ctxt->subscription->metadata, "pubDate", tmp);
ctxt->feed->time = date_parse_ISO8601 (tmp);
g_free(tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"updated")) { /* Updated was added in IETF draft 03 */
tmp = (gchar *)xmlNodeListGetString(ctxt->doc, cur->xmlChildrenNode, 1);
if(tmp) {
ctxt->subscription->metadata = metadata_list_append(ctxt->subscription->metadata, "pubDate", tmp);
ctxt->feed->time = date_parse_ISO8601 (tmp);
g_free(tmp);
}
} else if(!xmlStrcmp(cur->name, BAD_CAST"contributor")) {
tmp = parseAuthor(cur);
if(tmp) {
ctxt->subscription->metadata = metadata_list_append(ctxt->subscription->metadata, "contributor", tmp);
g_free(tmp);
}
} else if((!xmlStrcmp(cur->name, BAD_CAST"entry"))) {
ctxt->item = parseEntry(ctxt, cur);
if(ctxt->item) {
if(0 == ctxt->item->time)
ctxt->item->time = ctxt->feed->time;
ctxt->items = g_list_append(ctxt->items, ctxt->item);
}
}
cur = cur->next;
}
break;
}
}
/*
The follow are not used, but had been recognized:
"language", <---- Not in atom 0.2 or 0.3. We should use xml:lang
"lastBuildDate", <--- Where is this from?
"issued", <-- Not in the specs for feeds
"created", <---- Not in the specs for feeds
*/
gchar* pie_parse_content_construct(xmlNodePtr cur) {
gchar *mode, *type, *ret;
g_assert(NULL != cur);
ret = NULL;
/* determine encoding mode */
mode = xml_get_attribute (cur, "mode");
type = xml_get_attribute (cur, "type");
/* Modes are used in older versions of ATOM, including 0.3. It
does not exist in the newer IETF drafts.*/
if(NULL != mode) {
if(!strcmp(mode, "escaped")) {
gchar *tmp;
tmp = xhtml_extract (cur, 0, NULL);
if(NULL != tmp)
ret = tmp;
} else if(!strcmp(mode, "xml")) {
ret = xhtml_extract (cur, 1,NULL);
} else if(!strcmp(mode, "base64")) {
g_warning("Base64 encoded <content> in Atom feeds not supported!\n");
} else if(!strcmp(mode, "multipart/alternative")) {
if(NULL != cur->xmlChildrenNode)
ret = pie_parse_content_construct(cur->xmlChildrenNode);
}
g_free(mode);
} else {
/* some feeds don'ts specify a mode but a MIME type in the
type attribute... */
/* not sure what MIME types are necessary... */
/* This that need to be de-encoded and should not contain sub-tags.*/
if(NULL == type ||
!g_ascii_strcasecmp(type, "TEXT") ||
!strcmp(type, "text/plain")) {
gchar *tmp;
tmp = (gchar *)xmlNodeListGetString(cur->doc, cur->xmlChildrenNode, 1);
ret = g_markup_printf_escaped("<div xmlns=\"http://www.w3.org/1999/xhtml\"><pre>%s</pre></div>", tmp);
g_free(tmp);
/* Next are things that contain subttags */
} else if(!g_ascii_strcasecmp(type, "HTML") ||
!strcmp(type, "text/html")) {
ret = xhtml_extract (cur, 0,"http://default.base.com/");
} else if(/* HTML types */
!g_ascii_strcasecmp(type, "xhtml") ||
!strcmp(type, "application/xhtml+xml")) {
ret = xhtml_extract (cur, 1,"http://default.base.com/");
}
}
/* If the type was text, everything must be now escaped and
wrapped in pre tags.... Also, the atom 0.3 spec says that the
default type MUST be considered to be text/plain. The type tag
is required in 0.2.... */
//if (ret != NULL && (type == NULL || !strcmp(type, "text/plain") || !strcmp(type,"TEXT")))) {
g_free(type);
return ret;
}
void node_testmess(xml_data_node *node)
{
xml_data_node *child_node;
xml_attribute_node *attr_node;
int result;
pile_init(&command_pile);
pool_init(&command_pool);
memset(&new_command, 0, sizeof(new_command));
command_count = 0;
/* 'driver' attribute */
attr_node = xml_get_attribute(node, "driver");
if (!attr_node)
{
error_missingattribute("driver");
return;
}
current_testcase.driver = attr_node->value;
/* 'name' attribute */
attr_node = xml_get_attribute(node, "name");
current_testcase.name = attr_node ? attr_node->value : current_testcase.driver;
/* 'ramsize' attribute */
attr_node = xml_get_attribute(node, "ramsize");
current_testcase.ram = attr_node ? ram_parse_string(attr_node->value) : 0;
/* 'wavwrite' attribute */
attr_node = xml_get_attribute(node, "wavwrite");
current_testcase.wavwrite = attr_node && (atoi(attr_node->value) != 0);
/* report the beginning of the test case */
report_testcase_begin(current_testcase.name);
current_testcase.commands = NULL;
for (child_node = node->child; child_node; child_node = child_node->next)
{
if (!strcmp(child_node->name, "wait"))
node_wait(child_node);
else if (!strcmp(child_node->name, "input"))
node_input(child_node);
else if (!strcmp(child_node->name, "rawinput"))
node_rawinput(child_node);
else if (!strcmp(child_node->name, "switch"))
node_switch(child_node);
else if (!strcmp(child_node->name, "screenshot"))
node_screenshot(child_node);
else if (!strcmp(child_node->name, "checkblank"))
node_checkblank(child_node);
else if (!strcmp(child_node->name, "imagecreate"))
node_imagecreate(child_node);
else if (!strcmp(child_node->name, "imageload"))
node_imageload(child_node);
else if (!strcmp(child_node->name, "memverify"))
node_memverify(child_node);
else if (!strcmp(child_node->name, "imageverify"))
node_imageverify(child_node);
else if (!strcmp(child_node->name, "trace"))
node_trace(child_node);
}
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_END;
if (!append_command())
{
error_outofmemory();
return;
}
result = run_test(0, NULL);
report_testcase_ran(result);
pile_delete(&command_pile);
pool_exit(&command_pool);
}
/*
* parse a reply message and update the queue row with status
*/
int ebxml_parse_reply (char *reply, QUEUEROW *r)
{
MIME *msg, *part;
XML *xml;
char *ch, buf[PTIMESZ];
if (ebxml_status (reply))
return (-1);
if ((msg = mime_parse (reply)) == NULL)
{
error ("Failed parsing reply message\n");
return (-1);
}
/* check the ebxml envelope for ack or error */
if ((part = mime_getMultiPart (msg, 1)) == NULL)
{
error ("Reply missing ebxml envelope\n");
mime_free (msg);
return (-1);
}
if ((xml = xml_parse (mime_getBody (part))) == NULL)
{
error ("Failed parsing ebxml envelop\n");
mime_free (msg);
return (-1);
}
strcpy (buf, xml_get_text (xml, SOAPACTION));
if (!strcmp (buf, "MessageError"))
{
debug ("Error reply received!\n");
queue_field_set (r, "PROCESSINGSTATUS", "done");
queue_field_set (r, "TRANSPORTSTATUS", "failed");
ch = xml_get_attribute (xml, SOAPERROR, "eb:errorCode");
debug ("%s eb:errorCode %s\n", SOAPERROR, ch);
queue_field_set (r, "TRANSPORTERRORCODE", ch);
queue_field_set (r, "APPLICATIONSTATUS", "not-set");
queue_field_set (r, "APPLICATIONERRORCODE", "none");
ch = xml_get_text (xml, SOAPERROR);
debug ("SOAPERROR %s\n", ch);
queue_field_set (r, "APPLICATIONRESPONSE", ch);
queue_field_set (r, "MESSAGERECEIVEDTIME", ptime (NULL, buf));
xml_free (xml);
mime_free (msg);
return (0);
}
xml_free (xml);
/* Ping reply */
if (strcmp (queue_field_get (r, "ACTION"), "Ping") == 0)
{
if (strcmp (buf, "Pong"))
{
error ("Expected 'Pong' action but got '%s'\n", buf);
mime_free (msg);
return (-1);
}
queue_field_set (r, "APPLICATIONSTATUS", "not-set");
queue_field_set (r, "APPLICATIONERRORCODE", "none");
queue_field_set (r, "APPLICATIONRESPONSE", "none");
queue_field_set (r, "MESSAGERECEIVEDTIME", ptime (NULL, buf));
}
else /* regular reply */
{
if ((part = mime_getMultiPart (msg, 2)) == NULL)
{
error ("Reply missing status part\n");
mime_free (msg);
return (-1);
}
debug ("Body is...\n%s\n", mime_getBody (part));
if ((xml = xml_parse (mime_getBody (part))) == NULL)
{
error ("Miss formatted Reply status\n");
mime_free (msg);
return (-1);
}
queue_field_set (r, "APPLICATIONSTATUS",
xml_get_text (xml, "response.msh_response.status"));
queue_field_set (r, "APPLICATIONERRORCODE",
xml_get_text (xml, "response.msh_response.error"));
queue_field_set (r, "APPLICATIONRESPONSE",
xml_get_text (xml, "response.msh_response.appdata"));
queue_field_set (r, "MESSAGERECEIVEDTIME", ptime (NULL, buf));
/* TODO...
queue_field_set (r, "RESPONSEMESSAGEID", "");
queue_field_set (r, "RESPONSEARGUMENTS", "");
queue_field_set (r, "RESPONSELOCALFILE", "");
queue_field_set (r, "RESPONSEFILENAME", "");
queue_field_set (r, "RESPONSEMESSAGEORIGIN", "");
queue_field_set (r, "RESPONSEMESSAGESIGNATURE", "");
*/
xml_free (xml);
}
queue_field_set (r, "PROCESSINGSTATUS", "done");
queue_field_set (r, "TRANSPORTSTATUS", "success");
queue_field_set (r, "TRANSPORTERRORCODE", "none");
mime_free (msg);
return (0);
}
static void node_checkdirectory(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
imgtool_directory *imageenum;
imgtool_dirent ent;
char expected_listing[1024];
char actual_listing[1024];
int i/*, actual_count*/;
int mismatch;
xml_attribute_node *attr_node;
xml_data_node *child_node;
const char *filename;
expected_dirent *entry;
expected_dirent entries[256];
int entry_count;
if (!state->m_partition)
{
state->m_failed = 1;
report_message(MSG_FAILURE, "Partition not loaded");
return;
}
attr_node = xml_get_attribute(node, "path");
filename = attr_node ? attr_node->value : "";
memset(&entries, 0, sizeof(entries));
entry_count = 0;
for (child_node = xml_get_sibling(node->child, "entry"); child_node; child_node = xml_get_sibling(child_node->next, "entry"))
{
if (entry_count >= ARRAY_LENGTH(entries))
{
report_message(MSG_FAILURE, "Too many directory entries");
return;
}
entry = &entries[entry_count++];
attr_node = xml_get_attribute(child_node, "name");
entry->filename = attr_node ? attr_node->value : NULL;
attr_node = xml_get_attribute(child_node, "size");
entry->size = attr_node ? atoi(attr_node->value) : -1;
}
/* build expected listing string */
expected_listing[0] = '\0';
for (i = 0; i < entry_count; i++)
{
append_to_list(expected_listing,
ARRAY_LENGTH(expected_listing),
entries[i].filename);
}
/* now enumerate though listing */
//actual_count = 0;
actual_listing[0] = '\0';
mismatch = FALSE;
memset(&ent, 0, sizeof(ent));
err = imgtool_directory_open(state->m_partition, filename, &imageenum);
if (err)
goto done;
i = 0;
do
{
err = imgtool_directory_get_next(imageenum, &ent);
if (err)
goto done;
if (!ent.eof)
{
append_to_list(actual_listing,
ARRAY_LENGTH(actual_listing),
ent.filename);
if (i < entry_count && (strcmp(ent.filename, entries[i].filename)))
mismatch = TRUE;
i++;
}
}
while(!ent.eof);
if (i != entry_count)
mismatch = TRUE;
if (mismatch)
{
state->m_failed = 1;
report_message(MSG_FAILURE, "File listing mismatch: {%s} expected {%s}",
actual_listing, expected_listing);
goto done;
}
done:
if (imageenum)
imgtool_directory_close(imageenum);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
}
}
static void node_createimage(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err;
xml_data_node *child_node;
xml_attribute_node *attr_node;
option_resolution *opts = NULL;
const imgtool_module *module;
const char *driver;
const char *param_name;
const char *param_value;
attr_node = xml_get_attribute(node, "driver");
if (!attr_node)
{
error_missingattribute("driver");
return;
}
driver = attr_node->value;
/* does image creation support options? */
module = imgtool_find_module(attr_node->value);
if (module && module->createimage_optguide && module->createimage_optspec)
opts = option_resolution_create(module->createimage_optguide, module->createimage_optspec);
report_message(MSG_INFO, "Creating image (module '%s')", driver);
for (child_node = xml_get_sibling(node->child, "param"); child_node; child_node = xml_get_sibling(child_node->next, "param"))
{
if (!opts)
{
report_message(MSG_FAILURE, "Cannot specify creation options with this module");
return;
}
attr_node = xml_get_attribute(child_node, "name");
if (!attr_node)
{
error_missingattribute("name");
return;
}
param_name = attr_node->value;
attr_node = xml_get_attribute(child_node, "value");
if (!attr_node)
{
error_missingattribute("value");
return;
}
param_value = attr_node->value;
option_resolution_add_param(opts, param_name, param_value);
}
err = imgtool_image_create_byname(driver, tempfile_name(), opts, &state->m_image);
if (opts)
{
option_resolution_close(opts);
opts = NULL;
}
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
return;
}
err = imgtool_partition_open(state->m_image, 0, &state->m_partition);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
return;
}
}
