uwfc_t *init_track() {
uwfc_t *track;
int track_size = 0;
size_t rx = 0, rx_count = 0;
track = malloc(sizeof(uwfc_t));
if (track == NULL)
return NULL;
if (receive(STDIN, track, UWFC_HEADER_SIZE, &rx) != 0 || rx != UWFC_HEADER_SIZE) {
free(track);
return NULL;
}
#ifndef PATCHED
track_size = validate_header(track) - UWFC_HEADER_SIZE; //size of file
#else
track_size = validate_header(track); //track->sub_chunk2_size (size of data)
#endif
// track_size is signed int as a mechanism to prevent huge malloc requests
if (track_size < 0) {
free(track);
return NULL;
}
if (track_size == 0) {
track->data = NULL;
} else {
track->data = malloc(track_size);
if (track->data == NULL) {
free(track);
return NULL;
}
}
while (receive(STDIN, &track->data[rx_count], (track->sub_chunk2_size - rx_count), &rx) == 0 &&
(rx_count + rx) != track->sub_chunk2_size) {
if(rx == 0) {
free(track->data);
free(track);
return NULL;
}
rx_count += rx;
}
return track;
}
/* Load an ELF file */
int load_elf(const char *elf)
{
int ret = 0;
do
{
g_elfdata = load_file(elf, &g_elfsize);
if(g_elfdata == NULL)
{
break;
}
if(!validate_header(g_elfdata))
{
break;
}
if(!load_sections(g_elfdata))
{
break;
}
ret = 1;
}
while(0);
return ret;
}
static gboolean read_header (VFSFile * handle, gint * version, gboolean *
syncsafe, gsize * offset, gint * header_size, gint * data_size)
{
ID3v2Header header;
if (vfs_fseek (handle, 0, SEEK_SET))
return FALSE;
if (vfs_fread (& header, 1, sizeof (ID3v2Header), handle) != sizeof
(ID3v2Header))
return FALSE;
if (validate_header (& header))
{
* offset = 0;
* version = header.version;
* header_size = sizeof (ID3v2Header);
* data_size = header.size;
} else return FALSE;
* syncsafe = (header.flags & ID3_HEADER_SYNCSAFE) ? TRUE : FALSE;
TAGDBG ("Offset = %d, header size = %d, data size = %d\n",
(gint) * offset, * header_size, * data_size);
return TRUE;
}
/**
* Validates the bootloader found at the specified offset in the SPI NOR
*
* @param sf pointer to spi flash data structure
* @param offset offset of bootloader in spi NOR flash
* @param size size of bootloader
*
* @return 0 if a valid bootloader was found at the offset
* 1 if no valid bootloader was found
* -1 on error
*/
int validate_spi_bootloader(struct spi_flash *sf, uint32_t offset, size_t size)
{
struct bootloader_header *header;
uint8_t *buffer;
int rc;
buffer = calloc(size, 1);
if (!buffer) {
puts("Out of memory\n");
return -1;
}
debug("%s(%p, 0x%x, 0x%x)\n", __func__, sf, offset, size);
rc = spi_flash_read(sf, offset, size, buffer);
if (rc) {
puts("Error reading bootloader\n");
rc = -1;
} else {
header = (struct bootloader_header *)buffer;
if (validate_header(header) || validate_data(header)) {
printf("Invalid bootloader found at offset 0x%x\n",
offset);
rc = 1;
} else {
rc = 0;
}
}
if (buffer)
free(buffer);
return rc;
}
/* Load an ELF file */
int load_elf(const char *elf)
{
int ret = 0;
do
{
g_elfdata = load_file(elf);
if(g_elfdata == NULL)
{
break;
}
if(!validate_header(g_elfdata))
{
break;
}
if(!load_sections(g_elfdata))
{
break;
}
if(!process_relocs())
{
break;
}
reindex_sections();
ret = 1;
}
while(0);
return ret;
}
rxml_document_t *rxml_load_document(const char *path)
{
#ifndef RXML_TEST
RARCH_WARN("Using RXML as drop in for libxml2. Behavior might be very buggy.\n");
#endif
char *memory_buffer = NULL;
char *new_memory_buffer = NULL;
const char *mem_ptr = NULL;
long len = 0;
FILE *file = fopen(path, "r");
if (!file)
return NULL;
rxml_document_t *doc = (rxml_document_t*)calloc(1, sizeof(*doc));
if (!doc)
goto error;
fseek(file, 0, SEEK_END);
len = ftell(file);
rewind(file);
memory_buffer = (char*)malloc(len + 1);
if (!memory_buffer)
goto error;
memory_buffer[len] = '\0';
if (fread(memory_buffer, 1, len, file) != (size_t)len)
goto error;
fclose(file);
file = NULL;
mem_ptr = memory_buffer;
if (!validate_header(&mem_ptr))
goto error;
new_memory_buffer = purge_xml_comments(mem_ptr);
if (!new_memory_buffer)
goto error;
free(memory_buffer);
mem_ptr = memory_buffer = new_memory_buffer;
doc->root_node = rxml_parse_node(&mem_ptr);
if (!doc->root_node)
goto error;
free(memory_buffer);
return doc;
error:
free(memory_buffer);
if (file)
fclose(file);
rxml_free_document(doc);
return NULL;
}
/**
* Given valid header returns image size (data + header); or 0
*/
uint32_t get_image_size(const bootloader_header_t * header)
{
uint32_t isize = 0;
if (!validate_header(header))
/* failsafe has valid header - get the image size */
isize = header->hlen + header->dlen;
return isize;
}
rxml_document_t *rxml_load_document(const char *path)
{
rxml_document_t *doc;
char *memory_buffer = NULL;
char *new_memory_buffer = NULL;
const char *mem_ptr = NULL;
long len = 0;
RFILE *file = filestream_open(path,
RETRO_VFS_FILE_ACCESS_READ,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
return NULL;
doc = (rxml_document_t*)calloc(1, sizeof(*doc));
if (!doc)
goto error;
len = filestream_get_size(file);
memory_buffer = (char*)malloc(len + 1);
if (!memory_buffer)
goto error;
memory_buffer[len] = '\0';
if (filestream_read(file, memory_buffer, len) != (size_t)len)
goto error;
filestream_close(file);
file = NULL;
mem_ptr = memory_buffer;
if (!validate_header(&mem_ptr))
goto error;
new_memory_buffer = purge_xml_comments(mem_ptr);
if (!new_memory_buffer)
goto error;
free(memory_buffer);
mem_ptr = memory_buffer = new_memory_buffer;
doc->root_node = rxml_parse_node(&mem_ptr);
if (!doc->root_node)
goto error;
free(memory_buffer);
return doc;
error:
free(memory_buffer);
filestream_close(file);
rxml_free_document(doc);
return NULL;
}
static Uint32 init_dds_image(el_file_ptr file, DdsHeader *header)
{
Uint8 magic[4];
el_read(file, sizeof(magic), magic);
if (!check_dds(magic))
{
LOG_ERROR_OLD("File '%s' is invalid. Wrong magic number for a "
"valid DDS.", el_file_name(file));
return 0;
}
el_read(file, sizeof(DdsHeader), header);
header->m_size = SDL_SwapLE32(header->m_size);
header->m_flags = SDL_SwapLE32(header->m_flags);
header->m_height = SDL_SwapLE32(header->m_height);
header->m_width = SDL_SwapLE32(header->m_width);
header->m_size_or_pitch = SDL_SwapLE32(header->m_size_or_pitch);
header->m_depth = SDL_SwapLE32(header->m_depth);
header->m_mipmap_count = SDL_SwapLE32(header->m_mipmap_count);
header->m_reserved1[0] = SDL_SwapLE32(header->m_reserved1[0]);
header->m_reserved1[1] = SDL_SwapLE32(header->m_reserved1[1]);
header->m_reserved1[2] = SDL_SwapLE32(header->m_reserved1[2]);
header->m_reserved1[3] = SDL_SwapLE32(header->m_reserved1[3]);
header->m_reserved1[4] = SDL_SwapLE32(header->m_reserved1[4]);
header->m_reserved1[5] = SDL_SwapLE32(header->m_reserved1[5]);
header->m_reserved1[6] = SDL_SwapLE32(header->m_reserved1[6]);
header->m_reserved1[7] = SDL_SwapLE32(header->m_reserved1[7]);
header->m_reserved1[8] = SDL_SwapLE32(header->m_reserved1[8]);
header->m_reserved1[9] = SDL_SwapLE32(header->m_reserved1[9]);
header->m_reserved1[10] = SDL_SwapLE32(header->m_reserved1[10]);
header->m_pixel_format.m_size = SDL_SwapLE32(header->m_pixel_format.m_size);
header->m_pixel_format.m_flags = SDL_SwapLE32(header->m_pixel_format.m_flags);
header->m_pixel_format.m_fourcc = SDL_SwapLE32(header->m_pixel_format.m_fourcc);
header->m_pixel_format.m_bit_count = SDL_SwapLE32(header->m_pixel_format.m_bit_count);
header->m_pixel_format.m_red_mask = SDL_SwapLE32(header->m_pixel_format.m_red_mask);
header->m_pixel_format.m_green_mask = SDL_SwapLE32(header->m_pixel_format.m_green_mask);
header->m_pixel_format.m_blue_mask = SDL_SwapLE32(header->m_pixel_format.m_blue_mask);
header->m_pixel_format.m_alpha_mask = SDL_SwapLE32(header->m_pixel_format.m_alpha_mask);
header->m_caps.m_caps1 = SDL_SwapLE32(header->m_caps.m_caps1);
header->m_caps.m_caps2 = SDL_SwapLE32(header->m_caps.m_caps2);
header->m_caps.m_caps3 = SDL_SwapLE32(header->m_caps.m_caps3);
header->m_caps.m_caps4 = SDL_SwapLE32(header->m_caps.m_caps4);
header->m_reserved2 = SDL_SwapLE32(header->m_reserved2);
return validate_header(header, el_file_name(file));
}
state_save_error state_save_read_file(running_machine *machine, mame_file *file)
{
state_private *global = machine->state_data;
UINT32 signature = get_signature(machine);
UINT8 header[HEADER_SIZE];
state_callback *func;
state_entry *entry;
int flip;
/* if we have illegal registrations, return an error */
if (global->illegal_regs > 0)
return STATERR_ILLEGAL_REGISTRATIONS;
/* read the header and turn on compression for the rest of the file */
mame_fcompress(file, FCOMPRESS_NONE);
mame_fseek(file, 0, SEEK_SET);
if (mame_fread(file, header, sizeof(header)) != sizeof(header))
return STATERR_READ_ERROR;
mame_fcompress(file, FCOMPRESS_MEDIUM);
/* verify the header and report an error if it doesn't match */
if (validate_header(header, machine->gamedrv->name, signature, popmessage, _("Error: ")) != STATERR_NONE)
return STATERR_INVALID_HEADER;
/* determine whether or not to flip the data when done */
flip = NATIVE_ENDIAN_VALUE_LE_BE((header[9] & SS_MSB_FIRST) != 0, (header[9] & SS_MSB_FIRST) == 0);
/* read all the data, flipping if necessary */
for (entry = global->entrylist; entry != NULL; entry = entry->next)
{
UINT32 totalsize = entry->typesize * entry->typecount;
if (mame_fread(file, entry->data, totalsize) != totalsize)
return STATERR_READ_ERROR;
/* handle flipping */
if (flip)
flip_data(entry);
}
/* call the post-load functions */
for (func = global->postfunclist; func != NULL; func = func->next)
(*func->func.postload)(machine, func->param);
return STATERR_NONE;
}
// Open the shared archive file, read and validate the header
// information (version, boot classpath, etc.). If initialization
// fails, shared spaces are disabled and the file is closed. [See
// fail_continue.]
//
// Validation of the archive is done in two steps:
//
// [1] validate_header() - done here. This checks the header, including _paths_misc_info.
// [2] validate_classpath_entry_table - this is done later, because the table is in the RW
// region of the archive, which is not mapped yet.
bool FileMapInfo::initialize() {
assert(UseSharedSpaces, "UseSharedSpaces expected.");
if (!open_for_read()) {
return false;
}
init_from_file(_fd);
if (!validate_header()) {
return false;
}
SharedReadOnlySize = _header->_space[0]._capacity;
SharedReadWriteSize = _header->_space[1]._capacity;
SharedMiscDataSize = _header->_space[2]._capacity;
SharedMiscCodeSize = _header->_space[3]._capacity;
return true;
}
save_error save_manager::check_file(running_machine &machine, emu_file &file, const char *gamename, void (CLIB_DECL *errormsg)(const char *fmt, ...))
{
// if we want to validate the signature, compute it
UINT32 sig = 0;
sig = machine.save().signature();
// seek to the beginning and read the header
file.compress(FCOMPRESS_NONE);
file.seek(0, SEEK_SET);
UINT8 header[HEADER_SIZE];
if (file.read(header, sizeof(header)) != sizeof(header))
{
if (errormsg != NULL)
(*errormsg)("Could not read %s save file header",emulator_info::get_appname());
return STATERR_READ_ERROR;
}
// let the generic header check work out the rest
return validate_header(header, gamename, sig, errormsg, "");
}
int state_save_check_file(mame_file *file, const char *gamename, int validate_signature, void (CLIB_DECL *errormsg)(const char *fmt, ...))
{
UINT32 signature = 0;
UINT8 header[0x18];
/* if we want to validate the signature, compute it */
if (validate_signature)
signature = get_signature();
/* seek to the beginning and read the header */
mame_fseek(file, 0, SEEK_SET);
if (mame_fread(file, header, sizeof(header)) != sizeof(header))
{
if (errormsg)
errormsg("Could not read " APPNAME " save file header");
return -1;
}
/* let the generic header check work out the rest */
return validate_header(header, gamename, signature, errormsg, "");
}
int state_save_load_begin(mame_file *file)
{
TRACE(logerror("Beginning load\n"));
/* read the file into memory */
ss_dump_size = mame_fsize(file);
ss_dump_array = malloc(ss_dump_size);
ss_dump_file = file;
mame_fread(ss_dump_file, ss_dump_array, ss_dump_size);
/* verify the header and report an error if it doesn't match */
if (validate_header(ss_dump_array, NULL, get_signature(), popmessage, "Error: "))
{
free(ss_dump_array);
return 1;
}
/* compute the total size and offset of all the entries */
compute_size_and_offsets();
return 0;
}
save_error save_manager::read_file(emu_file &file)
{
// if we have illegal registrations, return an error
if (m_illegal_regs > 0)
return STATERR_ILLEGAL_REGISTRATIONS;
// read the header and turn on compression for the rest of the file
file.compress(FCOMPRESS_NONE);
file.seek(0, SEEK_SET);
UINT8 header[HEADER_SIZE];
if (file.read(header, sizeof(header)) != sizeof(header))
return STATERR_READ_ERROR;
file.compress(FCOMPRESS_MEDIUM);
// verify the header and report an error if it doesn't match
UINT32 sig = signature();
if (validate_header(header, machine().system().name, sig, popmessage, "Error: ") != STATERR_NONE)
return STATERR_INVALID_HEADER;
// determine whether or not to flip the data when done
bool flip = NATIVE_ENDIAN_VALUE_LE_BE((header[9] & SS_MSB_FIRST) != 0, (header[9] & SS_MSB_FIRST) == 0);
// read all the data, flipping if necessary
for (state_entry *entry = m_entry_list.first(); entry != NULL; entry = entry->next())
{
UINT32 totalsize = entry->m_typesize * entry->m_typecount;
if (file.read(entry->m_data, totalsize) != totalsize)
return STATERR_READ_ERROR;
// handle flipping
if (flip)
entry->flip_data();
}
// call the post-load functions
for (state_callback *func = m_postload_list.first(); func != NULL; func = func->next())
func->m_func();
return STATERR_NONE;
}
state_save_error state_save_check_file(running_machine *machine, mame_file *file, const char *gamename, void (CLIB_DECL *errormsg)(const char *fmt, ...))
{
UINT8 header[HEADER_SIZE];
UINT32 signature = 0;
/* if we want to validate the signature, compute it */
if (machine != NULL)
signature = get_signature(machine);
/* seek to the beginning and read the header */
mame_fcompress(file, FCOMPRESS_NONE);
mame_fseek(file, 0, SEEK_SET);
if (mame_fread(file, header, sizeof(header)) != sizeof(header))
{
if (errormsg != NULL)
(*errormsg)(_("Could not read " APPNAME " save file header"));
return STATERR_READ_ERROR;
}
/* let the generic header check work out the rest */
return validate_header(header, gamename, signature, errormsg, "");
}
// Open the shared archive file, read and validate the header
// information (version, boot classpath, etc.). If initialization
// fails, shared spaces are disabled and the file is closed. [See
// fail_continue.]
//
// Validation of the archive is done in two steps:
//
// [1] validate_header() - done here. This checks the header, including _paths_misc_info.
// [2] validate_classpath_entry_table - this is done later, because the table is in the RW
// region of the archive, which is not mapped yet.
bool FileMapInfo::initialize() {
assert(UseSharedSpaces, "UseSharedSpaces expected.");
if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space()) {
fail_continue("Tool agent requires sharing to be disabled.");
return false;
}
if (!open_for_read()) {
return false;
}
init_from_file(_fd);
if (!validate_header()) {
return false;
}
SharedReadOnlySize = _header->_space[0]._capacity;
SharedReadWriteSize = _header->_space[1]._capacity;
SharedMiscDataSize = _header->_space[2]._capacity;
SharedMiscCodeSize = _header->_space[3]._capacity;
return true;
}
int do_bootloader_validate(cmd_tbl_t * cmdtp, int flag, int argc,
char *const argv[])
{
uint32_t image_addr = 0;
const bootloader_header_t *header;
if (argc >= 2)
image_addr = simple_strtoul(argv[1], NULL, 16);
if (!image_addr) {
image_addr = getenv_hex("fileaddr", load_addr);
if (!image_addr) {
puts("ERROR: Unable to get image address from "
"'fileaddr' environment variable\n");
return 1;
}
}
header = (void *)image_addr;
if (validate_header(header)) {
puts("Image does not have valid header\n");
return 1;
}
if (validate_data(header))
return 1;
printf("Image validated. Header size %d, data size %d\n", header->hlen,
header->dlen);
printf(" Header crc 0x%x, data crc 0x%x\n",
header->hcrc, header->dcrc);
printf(" Image link address is 0x%llx\n",
header->address);
return 0;
}
static void
http_parse_query_test(void)
{
struct evkeyvalq headers;
fprintf(stdout, "Testing HTTP query parsing: ");
TAILQ_INIT(&headers);
evhttp_parse_query("http://www.test.com/?q=test", &headers);
if (validate_header(&headers, "q", "test") != 0)
goto fail;
evhttp_clear_headers(&headers);
evhttp_parse_query("http://www.test.com/?q=test&foo=bar", &headers);
if (validate_header(&headers, "q", "test") != 0)
goto fail;
if (validate_header(&headers, "foo", "bar") != 0)
goto fail;
evhttp_clear_headers(&headers);
evhttp_parse_query("http://www.test.com/?q=test+foo", &headers);
if (validate_header(&headers, "q", "test foo") != 0)
goto fail;
evhttp_clear_headers(&headers);
evhttp_parse_query("http://www.test.com/?q=test%0Afoo", &headers);
if (validate_header(&headers, "q", "test\nfoo") != 0)
goto fail;
evhttp_clear_headers(&headers);
evhttp_parse_query("http://www.test.com/?q=test%0Dfoo", &headers);
if (validate_header(&headers, "q", "test\rfoo") != 0)
goto fail;
evhttp_clear_headers(&headers);
fprintf(stdout, "OK\n");
return;
fail:
fprintf(stdout, "FAILED\n");
exit(1);
}
/**
* Command for updating a bootloader image in flash. This function
* parses the arguments, and validates the header (if header exists.)
* Actual flash updating is done by flash type specific functions.
*
* @return 0 on success
* 1 on failure
*/
int do_bootloader_update(cmd_tbl_t * cmdtp, int flag, int argc,
char *const argv[])
{
uint32_t image_addr = 0;
uint32_t image_len = 0;
uint32_t burn_addr = 0;
int failsafe = 0;
const bootloader_header_t *header;
int force_nand = 0;
int force_spi = 0;
if (argc >= 2) {
if (!strcmp(argv[1], "nand")) {
debug("Forced NAND bootloader update\n");
force_nand = 1;
argc--;
argv++;
} else if (!strcmp(argv[1], "spi")) {
debug("Forced SPI bootloader update\n");
force_spi = 1;
argc--;
argv++;
if (!strcmp(argv[1], "failsafe")) {
failsafe = 1;
argc--;
argv++;
}
}
}
if (argc >= 2)
image_addr = simple_strtoul(argv[1], NULL, 16);
if (argc >= 3)
image_len = simple_strtoul(argv[2], NULL, 16);
if (argc >= 4) {
if (force_spi || force_nand) {
if (!strcmp("failsafe", argv[3]))
failsafe = 1;
} else {
burn_addr = simple_strtoul(argv[3], NULL, 16);
}
}
if ((argc >= 5) && (strcmp("failsafe", argv[4]) == 0))
failsafe = 1;
/* If we don't support failsafe images, we need to put the image at the
* base of flash, so we treat all images like failsafe image in this
* case.
*/
#ifdef CONFIG_OCTEON_NO_FAILSAFE
failsafe = 1;
burn_addr = 0x1fc00000;
#endif
if (!burn_addr)
burn_addr = getenv_hex("burnaddr", 0);
if (!image_addr) {
image_addr = getenv_hex("fileaddr", load_addr);
if (!image_addr) {
puts("ERROR: Unable to get image address from "
"'fileaddr' environment variable\n");
return 1;
}
}
DBGUPD("%s: burn address: 0x%x, image address: 0x%x\n",
__func__, burn_addr, image_addr);
/* Figure out what kind of flash we are going to update. This will
* typically come from the bootloader header. If the bootloader does
* not have a header, then it is assumed to be a legacy NOR image, and
* a destination NOR flash address must be supplied. NAND images
* _must_ have a header.
*/
header = (void *)image_addr;
if (header->magic != BOOTLOADER_HEADER_MAGIC) {
/* No header, assume headerless NOR bootloader image */
puts("No valid bootloader header found. Assuming old headerless image\n"
"Image checks cannot be performed\n");
if (!burn_addr) {
burn_addr = CONFIG_SYS_NORMAL_BOOTLOADER_BASE;
DBGUPD("Unable to get burn address from 'burnaddr' environment variable,\n");
DBGUPD(" using default 0x%x\n", burn_addr);
}
/* We only need image length for the headerless case */
if (!image_len) {
image_len = getenv_hex("filesize", 0);
if (!image_len) {
puts("ERROR: Unable to get image size from "
"'filesize' environment variable\n");
return 1;
}
}
return do_bootloader_update_nor(image_addr, image_len,
burn_addr, failsafe);
}
/* We have a header, so validate image */
if (validate_header(header)) {
puts("ERROR: Image header has invalid CRC.\n");
return 1;
}
if (validate_data(header)) /* Errors printed */
return 1;
/* We now have a valid image, so determine what to do with it. */
puts("Valid bootloader image found.\n");
/* Check to see that it is for the board we are running on */
if (header->board_type != cvmx_sysinfo_get()->board_type) {
printf("Current board type: %s (%d), image board type: %s (%d)\n",
cvmx_board_type_to_string(cvmx_sysinfo_get()->board_type),
cvmx_sysinfo_get()->board_type,
cvmx_board_type_to_string(header->board_type),
header->board_type);
if (cvmx_sysinfo_get()->board_type != CVMX_BOARD_TYPE_GENERIC
&& header->board_type != CVMX_BOARD_TYPE_GENERIC) {
puts("ERROR: Bootloader image is not for this board type.\n");
return 1;
} else {
puts("Loading mismatched image since current "
"or new bootloader is generic.\n");
}
}
/* SDK 1.9.0 NOR images have rev of 1.1 and unkown image_type */
if (((header->image_type == BL_HEADER_IMAGE_NOR)
|| (header->image_type == BL_HEADER_IMAGE_UNKNOWN
&& header->maj_rev == 1 && header->min_rev == 1))
&& !force_nand && !force_spi) {
debug("Updating NOR bootloader\n");
return do_bootloader_update_nor(image_addr, 0, burn_addr,
failsafe);
#if defined(CONFIG_CMD_OCTEON_NAND) || defined(CONFIG_OCTEON_NAND_BOOT_END)
} else if (!force_spi &&
(header->image_type == BL_HEADER_IMAGE_STAGE2 ||
header->image_type == BL_HEADER_IMAGE_STAGE3 ||
force_nand)) {
debug("Updating NAND bootloader\n");
return (do_bootloader_update_nand(image_addr));
#endif
#if defined(CONFIG_OCTEON_SPI_BOOT_END)
} else if (!force_nand &&
(header->image_type == BL_HEADER_IMAGE_STAGE2 ||
header->image_type == BL_HEADER_IMAGE_STAGE3 ||
force_spi)) {
debug("Updating SPI bootloader\n");
return do_bootloader_update_spi(image_addr,
header->dlen + header->hlen,
failsafe, false);
#else
} else {
puts("ERROR: This bootloader not compiled for this medium\n");
return 1;
#endif
}
return 1;
}
int
ea_fdopen(ea_file_t *ef, int fd, const char *creator, int aflags, int oflags)
{
ea_file_impl_t *f = (ea_file_impl_t *)ef;
bzero(f, sizeof (*f));
f->ef_oflags = oflags;
f->ef_fd = fd;
/* Initialize depth stack. */
if (stack_check(f) == -1) {
/* exacct_error set above. */
goto error1;
}
/*
* 1. If we are O_CREAT, then we will need to write a header
* after opening name.
*/
if (oflags & O_CREAT) {
if (creator == NULL) {
EXACCT_SET_ERR(EXR_NO_CREATOR);
goto error2;
}
if ((f->ef_creator = ea_strdup(creator)) == NULL) {
/* exacct_error set above. */
goto error2;
}
if ((f->ef_fp = fdopen(f->ef_fd, "w")) == NULL) {
EXACCT_SET_ERR(EXR_SYSCALL_FAIL);
goto error3;
}
if (write_header(ef) == -1) {
/* exacct_error set above. */
goto error3;
}
/*
* 2. If we are not O_CREAT, but are RDWR or WRONLY, we need to
* seek to EOF so that appends will succeed.
*/
} else if (oflags & O_RDWR || oflags & O_WRONLY) {
if ((f->ef_fp = fdopen(f->ef_fd, "r+")) == NULL) {
EXACCT_SET_ERR(EXR_SYSCALL_FAIL);
goto error2;
}
if ((aflags & EO_VALIDATE_MSK) == EO_VALID_HDR) {
if (validate_header(ef, creator) < 0) {
/* exacct_error set above. */
goto error2;
}
}
if (fseeko(f->ef_fp, 0, SEEK_END) == -1) {
EXACCT_SET_ERR(EXR_SYSCALL_FAIL);
goto error2;
}
/*
* 3. This is an undefined manner for opening an exacct file.
*/
} else if (oflags != O_RDONLY) {
EXACCT_SET_ERR(EXR_NOTSUPP);
goto error2;
/*
* 4a. If we are RDONLY, then we are in a position such that
* either a ea_get_object or an ea_next_object will succeed. If
* aflags was set to EO_TAIL, seek to the end of the file.
*/
} else {
if ((f->ef_fp = fdopen(f->ef_fd, "r")) == NULL) {
EXACCT_SET_ERR(EXR_SYSCALL_FAIL);
goto error2;
}
if ((aflags & EO_VALIDATE_MSK) == EO_VALID_HDR) {
if (validate_header(ef, creator) == -1) {
/* exacct_error set above. */
goto error2;
}
}
/*
* 4b. Handle the "open at end" option, for consumers who want
* to go backwards through the file (i.e. lastcomm).
*/
if ((aflags & EO_POSN_MSK) == EO_TAIL) {
if (fseeko(f->ef_fp, 0, SEEK_END) < 0) {
EXACCT_SET_ERR(EXR_SYSCALL_FAIL);
goto error2;
}
}
}
EXACCT_SET_ERR(EXR_OK);
return (0);
/* Error cleanup code */
error3:
ea_strfree(f->ef_creator);
error2:
stack_free(f);
error1:
bzero(f, sizeof (*f));
return (-1);
}
struct mm_struct* load_elf(char *data, int len, Task *task, pml4_t *proc_pml4) {
if (validate_header(data)) {
pml4_t *kern_pml4 = get_cr3();
//get the header
Elf64_Ehdr *hdr = (Elf64_Ehdr*)data;
//create new mm_struct
struct mm_struct *mm = (struct mm_struct*)kmalloc_kern(PAGE_SIZE);
memset(mm, 0, sizeof(struct mm_struct));
if(hdr->e_shstrndx == 0x00) panic("NO STRING TABLE");
mm->start_code = ((Elf64_Ehdr*) data)->e_entry;
Elf64_Phdr *prgm_hdr = (Elf64_Phdr*)(data + hdr->e_phoff);
uint64_t high_addr = 0;
for(int i = 0; i < hdr->e_phnum; prgm_hdr++, i++) {
//printk("--------------LOAD-ELF-----------------\n");
if (prgm_hdr->p_type == PT_LOAD && prgm_hdr->p_filesz > 0) {
if (prgm_hdr->p_filesz > prgm_hdr->p_memsz) {
panic("Bad Elf!!!\n");
halt();
}
struct vm_area_struct *vma = (struct vm_area_struct*) kmalloc_kern(sizeof(struct vm_area_struct));
if(kmalloc_vma(proc_pml4, prgm_hdr->p_vaddr, prgm_hdr->p_memsz, USER_SETTINGS) == NULL) {
panic("KMALLOC FAILED - elf.c:load_elf:34\n");
printk("SIZE: %d\n", prgm_hdr->p_filesz);
}
// printk("ELF Virtual memory address: %p\n", prgm_hdr->p_vaddr);
set_cr3(proc_pml4);
memset((void*)prgm_hdr->p_vaddr, 0, prgm_hdr->p_memsz);
//printk("memcpy dest: %p src: %p size: %p\n", prgm_hdr->p_vaddr, data + prgm_hdr->p_offset, prgm_hdr->p_filesz);
memcpy((void*)prgm_hdr->p_vaddr, data + prgm_hdr->p_offset, prgm_hdr->p_filesz);
//memcpy((void*)prgm_hdr->p_vaddr, data + prgm_hdr->p_offset, prgm_hdr->p_memsz);
set_cr3(kern_pml4);
vma->vm_start = prgm_hdr->p_vaddr;
vma->vm_end = (uint64_t)(prgm_hdr->p_vaddr + prgm_hdr->p_memsz);
vma->vm_prot = prgm_hdr->p_flags;
add_vma(mm, vma);
if(vma->next != NULL) {
panic("not null\n");
halt();
}
if(vma->vm_end > high_addr) high_addr = vma->vm_end;
if (prgm_hdr->p_vaddr == mm->start_code) {
// its the txt section
mm->end_code = (uint64_t)(prgm_hdr->p_vaddr + prgm_hdr->p_filesz);
mm->start_data = mm->end_code +1;
}
}
}
high_addr += PAGE_SIZE;
high_addr &= PG_ALIGN;
mm->brk = high_addr;
mm->start_brk = mm->brk;
struct vm_area_struct *vma = (struct vm_area_struct*) kmalloc_kern(sizeof(struct vm_area_struct));
vma->vm_start = mm->start_brk;
vma->vm_end = mm->brk;
vma->vm_prot = 0;
add_vma(mm, vma);
return mm;
} else {
return NULL;
}
}
/**
* Update a SPI bootloader
*
* @param image_addr Address bootloader image is located in RAM
* @param image_size Size of image, required for stage 1 bootloader
* @param failsafe True if image is failsafe stage 3 bootloader
* @param stage1 True if image is stage 1 bootloader
*
* @return 0 on success
* 1 on failure
*/
int do_bootloader_update_spi(uint32_t image_addr, size_t image_size,
bool failsafe, bool stage1)
{
struct bootloader_header search_header;
struct bootloader_map image_map[10];
int images[4] = {-1, -1, -1, -1}; /* 2 stage 2 and 2 stage 3 */
const struct bootloader_header *header;
uint8_t *buffer;
struct spi_flash *sf = NULL;
uint32_t offset = stage1 ? 0 : CONFIG_OCTEON_SPI_STAGE2_START;
uint32_t erase_size;
uint32_t size;
uint32_t start = -1, end = -1;
int rc;
int image_index = 0;
int num_images = 0;
int num_stage2 = 0;
int i;
bool is_stage2 = false;
bool update_index = false;
memset(image_map, 0, sizeof(image_map));
if (!image_addr)
image_addr = getenv_ulong("fileaddr", 16, 0);
if (!image_addr)
image_addr = getenv_ulong("loadaddr", 16, load_addr);
sf = spi_flash_probe(0, 0, CONFIG_SF_DEFAULT_SPEED, SPI_MODE_0);
if (!sf) {
puts("SPI flash not found\n");
goto error;
}
debug("size: %u bytes, erase block size: %u bytes\n",
sf->size, sf->erase_size);
if (sf->size < CONFIG_OCTEON_SPI_BOOT_END) {
printf("Error: Bootloader section end offset 0x%x is greater than the size of the SPI flash (0x%x)\n",
CONFIG_OCTEON_SPI_BOOT_END, sf->size);
goto error;
}
erase_size = (image_size + sf->erase_size - 1) & ~(sf->erase_size - 1);
buffer = CASTPTR(uint8_t, image_addr);
if (stage1) {
debug("Updating stage 1 bootloader\n");
rc = spi_flash_erase(sf, 0, erase_size);
if (rc) {
puts("Error erasing SPI flash\n");
goto error;
}
puts("Writing stage 1 SPI bootloader to offset 0.\n");
rc = spi_flash_write(sf, 0, image_size, buffer);
if (rc) {
puts("Error writing stage 1 bootloader to SPI flash\n");
goto error;
}
printf("Successfully wrote %zu bytes.\n", image_size);
return 0;
}
header = CASTPTR(struct bootloader_header, image_addr);
is_stage2 = header->image_type == BL_HEADER_IMAGE_STAGE2;
printf("%s %u byte bootloader found at address 0x%x\n",
is_stage2 ? "Stage 2" : "Final stage", image_size, image_addr);
/* Search for U-Boot image */
do {
/* debug("Looking for bootloader at offset 0x%x\n", offset);*/
rc = spi_flash_read(sf, offset, sizeof(search_header),
&search_header);
if (rc) {
printf("Error reading offset %u of SPI flash\n", offset);
goto error;
}
if (!validate_header(&search_header)) {
debug("Found valid %u byte stage %d header at offset 0x%x\n",
search_header.hlen + search_header.dlen,
search_header.image_type == BL_HEADER_IMAGE_STAGE2 ? 2 : 3,
offset);
if (update_index)
image_index++;
update_index = false;
size = search_header.hlen + search_header.dlen;
debug("Validating bootloader at 0x%x, size: %zu\n",
offset, size);
if (size > (2 << 20)) {
rc = 1;
puts("Invalid bootloader image size exceeds 2MB\n");
} else {
rc = validate_spi_bootloader(sf, offset, size);
}
if (rc < 0) {
debug("Error reading bootloader from SPI\n");
goto error;
} else if (rc == 0) {
debug("Found valid bootloader\n");
image_map[image_index].size =
(size + erase_size - 1) & ~erase_size;
image_map[image_index].free_space = false;
image_map[image_index].type = search_header.image_type;
} else {
debug("Found invalid bootloader\n");
/* Calculate free size based on invalid
* bootloader size.
*/
image_map[image_index].image_size = size;
/* Including padding for erase block size */
image_map[image_index].size =
(size + sf->erase_size - 1)
& ~(sf->erase_size - 1);
image_map[image_index].free_space = true;
image_map[image_index].type = BL_HEADER_IMAGE_UNKNOWN;
}
image_map[image_index].offset = offset;
offset += size + sf->erase_size - 1;
offset &= ~(sf->erase_size - 1);
image_index++;
} else {
update_index = true;
/* debug("No header at offset 0x%x\n", offset); */
if (!image_map[image_index].size) {
image_map[image_index].offset = offset;
image_map[image_index].free_space = true;
}
image_map[image_index].size += sf->erase_size;
offset += sf->erase_size;
}
} while (offset < CONFIG_OCTEON_SPI_BOOT_END && image_index < 10);
if (update_index)
image_index++;
for (i = 0, num_images = 0; i < image_index && num_images < 4; i++)
if (!image_map[i].free_space) {
images[num_images++] = i;
if (image_map[i].type == BL_HEADER_IMAGE_STAGE2)
num_stage2++;
}
#ifdef DEBUG
debug("Image map:\n");
for (i = 0; i < image_index; i++)
printf("%d: offset: 0x%x, image size: %#x, size: 0x%x, type: %d, free: %s\n",
i, image_map[i].offset, image_map[i].image_size,
image_map[i].size,
image_map[i].type,
image_map[i].free_space ? "yes" : "no");
#endif
if (is_stage2) {
#ifdef CONFIG_OCTEON_NO_FAILSAFE
/* If there's no failsafe then we just overwrite the
* first bootloader by pretending it is a failsafe.
*/
failsafe = 1;
#endif
if (failsafe || num_images == 0 || num_stage2 < 2) {
i = images[0];
if (i < 0)
i = 0;
if (image_map[i].type != BL_HEADER_IMAGE_STAGE2 &&
image_map[i].type != BL_HEADER_IMAGE_UNKNOWN &&
!image_map[i].free_space) {
puts("Warning: no stage 2 bootloader found,\n"
"overwriting existing non-stage 2 bootloader image.\n");
}
if (i > 0 && image_map[i - 1].free_space)
start = image_map[i - 1].offset;
else
start = image_map[i].offset;
if ((i + 1) < image_index && image_map[i + 1].free_space)
end = image_map[i + 1].offset + image_map[i + 1].size;
else
end = image_map[i].offset + image_map[i].size;
size = end - start;
if (image_size > size)
puts("Warning: new failsafe stage 2 image overwrites old non-failsafe stage 2 image.\n" "Please update non-failsafe stage 2 bootloader next.\n");
} else {
if (num_stage2 > 0) {
i = images[1];
if (i < 0)
i = 1;
} else {
i = images[0];
}
start = image_map[i].offset;
end = start + image_map[i].size;
debug("New stage 2 image map %d start: 0x%x, end: 0x%x\n",
i, start, end);
}
} else {
debug("Non-stage 2 bootloader\n");
i = num_stage2;
if (!failsafe && num_images > num_stage2)
i++;
if (images[i] < 0)
i = images[i - 1] + 1;
else if (image_map[i].size < erase_size &&
!image_map[i + 1].free_space)
printf("Warning: overwriting image following this image at offset 0x%x\n",
image_map[i + 1].offset);
start = image_map[i].offset;
end = start + image_map[i].size;
debug("New final stage bootloader image map %d start: 0x%x, end: 0x%x\n",
i, start, end);
}
if (end < 0 || start < 0) {
printf("Error detected, start or end is negative\n");
goto error;
}
if (end - start < erase_size) {
printf("Not enough space available, need %u bytes but only %u are available\n",
image_size, end - start);
}
printf("Erasing %u bytes starting at offset 0x%x, please wait...\n", erase_size, start);
rc = spi_flash_erase(sf, start, erase_size);
if (rc) {
printf("Error erasing %u bytes starting at offset 0x%x\n",
erase_size, start);
goto error;
}
printf("Writing %u bytes...\n", image_size);
rc = spi_flash_write(sf, start, image_size, header);
if (rc) {
printf("Error writing %u bytes starting at offset 0x%x\n",
image_size, start);
goto error;
}
printf("Done.\n%u bytes were written starting at offset 0x%x\n",
image_size, start);
if (sf)
free(sf);
return 0;
error:
if (sf)
free(sf);
return 1;
}
/* attempts to read verity metadata from `f->fd' position `offset'; if in r/w
mode, rewrites the metadata if it had errors */
int verity_parse_header(fec_handle *f, uint64_t offset)
{
check(f);
check(f->data_size > VERITY_METADATA_SIZE);
if (offset > f->data_size - VERITY_METADATA_SIZE) {
debug("failed to read verity header: offset %" PRIu64 " is too far",
offset);
return -1;
}
verity_info *v = &f->verity;
uint64_t errors = f->errors;
if (!raw_pread(f, &v->header, sizeof(v->header), offset)) {
error("failed to read verity header: %s", strerror(errno));
return -1;
}
/* use raw data to check for the alternative magic, because it will
be error corrected to VERITY_MAGIC otherwise */
if (v->header.magic == VERITY_MAGIC_DISABLE) {
/* this value is not used by us, but can be used by a caller to
decide whether dm-verity should be enabled */
v->disabled = true;
}
if (fec_pread(f, &v->ecc_header, sizeof(v->ecc_header), offset) !=
sizeof(v->ecc_header)) {
warn("failed to read verity header: %s", strerror(errno));
return -1;
}
if (validate_header(f, &v->header, offset)) {
/* raw verity header is invalid; this could be due to corruption, or
due to missing verity metadata */
if (validate_header(f, &v->ecc_header, offset)) {
return -1; /* either way, we cannot recover */
}
/* report mismatching fields */
if (!v->disabled && v->header.magic != v->ecc_header.magic) {
warn("corrected verity header magic");
v->header.magic = v->ecc_header.magic;
}
if (v->header.version != v->ecc_header.version) {
warn("corrected verity header version");
v->header.version = v->ecc_header.version;
}
if (v->header.length != v->ecc_header.length) {
warn("corrected verity header length");
v->header.length = v->ecc_header.length;
}
if (memcmp(v->header.signature, v->ecc_header.signature,
sizeof(v->header.signature))) {
warn("corrected verity header signature");
/* we have no way of knowing which signature is correct, if either
of them is */
}
}
v->metadata_start = offset;
if (parse_table(f, offset + sizeof(v->header), v->header.length,
false) == -1 &&
parse_table(f, offset + sizeof(v->header), v->header.length,
true) == -1) {
return -1;
}
/* if we corrected something while parsing metadata and we are in r/w
mode, rewrite the corrected metadata */
if (f->mode & O_RDWR && f->errors > errors &&
rewrite_metadata(f, offset) < 0) {
warn("failed to rewrite verity metadata: %s", strerror(errno));
}
if (v->metadata_start < v->hash_start) {
f->data_size = v->metadata_start;
} else {
f->data_size = v->hash_start;
}
return 0;
}
std::string a78_cart_slot_device::get_default_card_software()
{
if (open_image_file(mconfig().options()))
{
const char *slot_string;
dynamic_buffer head(128);
int type = A78_TYPE0, mapper;
// Load and check the header
m_file->read(&head[0], 128);
// let's try to auto-fix some common errors in the header
mapper = validate_header((head[53] << 8) | head[54], FALSE);
switch (mapper & 0x2e)
{
case 0x0000:
type = BIT(mapper, 0) ? A78_TYPE1 : A78_TYPE0;
break;
case 0x0002:
type = BIT(mapper, 0) ? A78_TYPE3 : A78_TYPE2;
break;
case 0x0006:
type = A78_TYPE6;
break;
case 0x000a:
type = A78_TYPEA;
break;
case 0x0022:
case 0x0026:
if (m_file->size() > 0x40000)
type = A78_MEGACART;
else
type = A78_VERSABOARD;
break;
}
// check if cart has a POKEY at $0450 (typically a VersaBoard variant)!
if (mapper & 0x40)
{
if (type != A78_TYPE2)
{
type &= ~0x02;
type += A78_POKEY0450;
}
}
// check special bits, which override the previous
if ((mapper & 0xff00) == 0x0100)
type = A78_ACTIVISION;
else if ((mapper & 0xff00) == 0x0200)
type = A78_ABSOLUTE;
logerror("Cart type: %x\n", type);
slot_string = a78_get_slot(type);
clear();
return std::string(slot_string);
}
else
return software_get_default_slot("a78_rom");
}
bool a78_cart_slot_device::call_load()
{
if (m_cart)
{
UINT32 len;
if (software_entry() != nullptr)
{
const char *pcb_name;
bool has_ram = get_software_region("ram") ? TRUE : FALSE;
bool has_nvram = get_software_region("nvram") ? TRUE : FALSE;
len = get_software_region_length("rom");
m_cart->rom_alloc(len, tag());
memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);
if ((pcb_name = get_feature("slot")) != nullptr)
m_type = a78_get_pcb_id(pcb_name);
else
m_type = A78_TYPE0;
if (has_ram)
m_cart->ram_alloc(get_software_region_length("ram"));
if (has_nvram)
{
m_cart->nvram_alloc(get_software_region_length("nvram"));
battery_load(m_cart->get_nvram_base(), get_software_region_length("nvram"), 0xff);
}
}
else
{
// Load and check the header
int mapper;
char head[128];
fread(head, 128);
if (verify_header((char *)head) == IMAGE_VERIFY_FAIL)
return IMAGE_INIT_FAIL;
len = (head[49] << 24) | (head[50] << 16) | (head[51] << 8) | head[52];
if (len + 128 > length())
{
logerror("Invalid length in the header. The game might be corrupted.\n");
len = length() - 128;
}
// let's try to auto-fix some common errors in the header
mapper = validate_header((head[53] << 8) | head[54], TRUE);
switch (mapper & 0x2e)
{
case 0x0000:
m_type = BIT(mapper, 0) ? A78_TYPE1 : A78_TYPE0;
break;
case 0x0002:
m_type = BIT(mapper, 0) ? A78_TYPE3 : A78_TYPE2;
break;
case 0x0006:
m_type = A78_TYPE6;
break;
case 0x000a:
m_type = A78_TYPEA;
break;
case 0x0022:
case 0x0026:
if (len > 0x40000)
m_type = A78_MEGACART;
else
m_type = A78_VERSABOARD;
break;
}
// check if cart has a POKEY at $0450 (typically a VersaBoard variant)
if (mapper & 0x40)
{
if (m_type != A78_TYPE2)
{
m_type &= ~0x02;
m_type += A78_POKEY0450;
}
}
// check special bits, which override the previous
if ((mapper & 0xff00) == 0x0100)
m_type = A78_ACTIVISION;
else if ((mapper & 0xff00) == 0x0200)
m_type = A78_ABSOLUTE;
logerror("Cart type: 0x%x\n", m_type);
if (head[58] == 1)
{
osd_printf_info("This cart supports external NVRAM using HSC.\n");
osd_printf_info("Run it with the High Score Cart mounted to exploit this feature.\n");
}
else if (head[58] == 2)
{
osd_printf_info("This cart supports external NVRAM using SaveKey.\n");
osd_printf_info("This is not supported in MAME currently.\n");
}
if (head[63])
{
osd_printf_info("This cart requires XBoarD / XM expansion\n");
osd_printf_info("Run it through the expansion to exploit this feature.\n");
}
internal_header_logging((UINT8 *)head, length());
m_cart->rom_alloc(len, tag());
fread(m_cart->get_rom_base(), len);
if (m_type == A78_TYPE6)
m_cart->ram_alloc(0x4000);
if (m_type == A78_MEGACART || (m_type >= A78_VERSABOARD && m_type <= A78_VERSA_POK450))
m_cart->ram_alloc(0x8000);
if (m_type == A78_XB_BOARD || m_type == A78_XM_BOARD)
m_cart->ram_alloc(0x20000);
if (m_type == A78_HSC || m_type == A78_XM_BOARD)
{
m_cart->nvram_alloc(0x800);
battery_load(m_cart->get_nvram_base(), 0x800, 0xff);
}
}
//printf("Type: %s\n", a78_get_slot(m_type));
}
return IMAGE_INIT_PASS;
}
unsigned int __stdcall CompletionThread(LPVOID pComPort)
{
HANDLE hCompletionPort = (HANDLE)pComPort;
DWORD BytesTransferred;
LPPER_HANDLE_DATA PerHandleData;
LPPER_IO_DATA PerIoData;
DWORD flags;
while (1)
{
GetQueuedCompletionStatus(hCompletionPort, // Completion Port
&BytesTransferred,
(LPDWORD)&PerHandleData,
(LPOVERLAPPED*)&PerIoData,
INFINITE
);
if (BytesTransferred == 0)
{
closesocket(PerHandleData->hClntSock);
free(PerHandleData);
free(PerIoData);
continue;
}
PerIoData->wsaBuf.buf[BytesTransferred] = '\0';
printf("Recv[%s]\n", PerIoData->wsaBuf.buf);
std::string header = PerIoData->wsaBuf.buf;
int iResult;
std::vector<std::string> v_new_header;
std::vector<std::string> s_new_host;
if (!validate_header(header)) {
continue;
}
std::vector<std::string> v_header = tokenize(header, "\r\n");
std::string content;
if (std::regex_search(header, std::regex("CONNECT"))) {
closesocket(PerHandleData->hClntSock);
continue;
}
for (int i = 0; i < v_header.size(); i++) {
if (std::regex_search(v_header[i], std::regex("Content-Length"))) {
int content_length = atoi(trim(tokenize(v_header[i], ":")[1]).c_str());
std::smatch m;
std::regex_search(header, m, std::regex("\r\n\r\n"));
content = header.substr(m.position() + 4) + "\r\n";
header = header.substr(0, m.position() + 4);
}
}
v_header = tokenize(header, "\r\n");
v_new_header = generate_new_header(v_header);
s_new_host = process_new_host(v_header);
struct addrinfo *result = NULL, *ptr = NULL, hints;
ZeroMemory(&hints, sizeof(hints));
//gethostbyname(s_new_host.c_str());
iResult = getaddrinfo(s_new_host[0].c_str(), s_new_host[1].c_str(), &hints, &result);
if (iResult != 0) {
std::cout << "getaddrinfo failed: " << iResult << std::endl;
WSACleanup();
return 1;
}
SOCKET ProxySocket = INVALID_SOCKET;
ProxySocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
if (ProxySocket == INVALID_SOCKET) {
std::cout << "Error at socket(): " << WSAGetLastError() << std::endl;
freeaddrinfo(result);
WSACleanup();
return 1;
}
iResult = connect(ProxySocket, result->ai_addr, (int)result->ai_addrlen);
if (iResult == SOCKET_ERROR) {
closesocket(ProxySocket);
ProxySocket = INVALID_SOCKET;
}
if (ProxySocket == INVALID_SOCKET) {
std::cout << "Unable to connect to server!\n" << std::endl;
WSACleanup();
return 1;
}
for (int i = 0; i < v_new_header.size(); i++) {
iResult = send(ProxySocket, v_new_header[i].c_str(), v_new_header[i].length(), 0);
}
iResult = send(ProxySocket, content.c_str(), content.length(), 0);
if (iResult == SOCKET_ERROR) {
printf("send failed: %d\n", WSAGetLastError());
closesocket(ProxySocket);
WSACleanup();
return 1;
}
iResult = throw_response(ProxySocket, PerHandleData->hClntSock);
//PerIoData->wsaBuf.len = BytesTransferred;
//WSASend(PerHandleData->hClntSock, &(PerIoData->wsaBuf), 1, NULL, 0, NULL, NULL);
//// RECEIVE AGAIN
//memset(&(PerIoData->overlapped), 0, sizeof(OVERLAPPED));
//PerIoData->wsaBuf.len = BUFSIZE;
//PerIoData->wsaBuf.buf = PerIoData->buffer;
//flags = 0;
//WSARecv(PerHandleData->hClntSock,
// &(PerIoData->wsaBuf),
// 1,
// NULL,
// &flags,
// &(PerIoData->overlapped),
// NULL
// );
}
return 0;
}
int
main(int argc, char * argv[], char * envp[])
{
ParseDelimitedText * parser;
int input_file_fd;
char input_file_buffer[PDT_BLK_SIZE];
size_t bytes_read;
/* Parse command line parameters */
set_params(argc, argv);
/* Load the format file */
printf("Reading format file %s\n", format_file->string);
format = new_PDTFormat();
format->m->read_file(format, format_file->string, format_file->length);
format->columns->m->reset_each(format->columns);
/* Open the input file */
input_file_fd = open_input_file();
parser = new_ParseDelimitedText(0);
/* Set the parser's options */
parser->m->apply_format(parser, format);
parser->m->set_block_size(parser, PDT_BLK_SIZE);
parser->m->set_field_callback(parser, header_field);
parser->m->set_record_callback(parser, header_record);
/* Initialize Globals */
header_fields = new_Array();
header_fields->auto_free = null_String->m->Array_free;
valid = 1;
field_count = 0;
/* Validate the file header */
while(parser->stop == 0
&& (bytes_read = read(input_file_fd, input_file_buffer, PDT_BLK_SIZE)) != 0) {
parser->m->parse(parser, input_file_buffer, bytes_read);
}
parser->m->finish(parser);
valid = validate_header();
/* Validate the file body */
if(valid == 1) {
parser->m->set_field_callback(parser, field);
parser->m->set_record_callback(parser, record);
parser->stop = 0;
while(parser->stop == 0
&& (bytes_read = read(input_file_fd, input_file_buffer, PDT_BLK_SIZE)) != 0) {
parser->m->parse(parser, input_file_buffer, bytes_read);
}
parser->m->finish(parser);
}
/* Cleanup */
close(input_file_fd);
parser->m->free(parser);
header_fields->m->free(header_fields);
format->m->free(format);
return (valid) ? SHELL_TRUE : SHELL_FALSE;
}
static bool_t read_header (VFSFile * handle, int * version, bool_t *
syncsafe, int64_t * offset, int * header_size, int * data_size, int *
footer_size)
{
ID3v2Header header, footer;
if (vfs_fseek (handle, 0, SEEK_SET))
return FALSE;
if (vfs_fread (& header, 1, sizeof (ID3v2Header), handle) != sizeof
(ID3v2Header))
return FALSE;
if (validate_header (& header, FALSE))
{
* offset = 0;
* version = header.version;
* header_size = sizeof (ID3v2Header);
* data_size = header.size;
if (header.flags & ID3_HEADER_HAS_FOOTER)
{
if (vfs_fseek (handle, header.size, SEEK_CUR))
return FALSE;
if (vfs_fread (& footer, 1, sizeof (ID3v2Header), handle) != sizeof
(ID3v2Header))
return FALSE;
if (! validate_header (& footer, TRUE))
return FALSE;
* footer_size = sizeof (ID3v2Header);
}
else
* footer_size = 0;
}
else
{
int64_t end = vfs_fsize (handle);
if (end < 0)
return FALSE;
if (vfs_fseek (handle, end - sizeof (ID3v2Header), SEEK_SET))
return FALSE;
if (vfs_fread (& footer, 1, sizeof (ID3v2Header), handle) != sizeof
(ID3v2Header))
return FALSE;
if (! validate_header (& footer, TRUE))
return FALSE;
* offset = end - 2 * sizeof (ID3v2Header) - footer.size;
* version = footer.version;
* header_size = sizeof (ID3v2Header);
* data_size = footer.size;
* footer_size = sizeof (ID3v2Header);
if (vfs_fseek (handle, * offset, SEEK_SET))
return FALSE;
if (vfs_fread (& header, 1, sizeof (ID3v2Header), handle) != sizeof
(ID3v2Header))
return FALSE;
if (! validate_header (& header, FALSE))
return FALSE;
}
* syncsafe = (header.flags & ID3_HEADER_SYNCSAFE) ? TRUE : FALSE;
if (header.flags & ID3_HEADER_HAS_EXTENDED_HEADER)
{
int extended_size = 0;
if (header.version == 3)
{
if (! skip_extended_header_3 (handle, & extended_size))
return FALSE;
}
else if (header.version == 4)
{
if (! skip_extended_header_4 (handle, & extended_size))
return FALSE;
}
* header_size += extended_size;
* data_size -= extended_size;
}
TAGDBG ("Offset = %d, header size = %d, data size = %d, footer size = "
"%d.\n", (int) * offset, * header_size, * data_size, * footer_size);
return TRUE;
}
//-------- Begin of function GameFile::load_game --------//
//
// return : <int> 1 - loaded successfully.
// 0 - not loaded.
// -1 - error and partially loaded
//
int GameFile::load_game(const char *base_path, char* fileName)
{
char full_path[MAX_PATH+1];
File file;
int rc=0;
const char *errMsg = NULL;
power.win_opened=1; // to disable power.mouse_handler()
int oldCursor = mouse_cursor.get_icon();
mouse_cursor.set_icon( CURSOR_WAITING );
int powerEnableFlag = power.enable_flag;
if( fileName )
strcpy( file_name, fileName );
rc = 1;
if (!misc.path_cat(full_path, base_path, file_name, MAX_PATH))
{
rc = 0;
errMsg = _("Path too long to the saved game");
}
if(rc && !file.file_open(full_path, 0, 1)) // 0=tell File don't handle error itself
{
rc = 0;
errMsg = _("Cannot open save game file");
}
//-------- read in the GameFile class --------//
if( rc )
{
char gameFileName[MAX_PATH+1];
strcpy( gameFileName, file_name ); // save the file name actually read, in case that the file names are different
MSG(__FILE__":%d: file_read(this, ...);\n", __LINE__);
if( !file.file_read(this, sizeof(GameFile)) ) // read the whole object from the saved game file
{
rc = 0;
errMsg = _("Cannot read file header");
}
if( rc )
{
if( !validate_header() )
{
rc = 0;
errMsg = _("Save game incompatible");
}
else
strcpy( file_name, gameFileName );
}
}
//--------------------------------------------//
// 1=allow the writing size and the read size to be different
if( rc )
{
config.terrain_set = terrain_set;
game.deinit(1); // deinit last game first, 1-it is called during loading of a game
game.init(1); // init game
//-------- read in saved game ----------//
// ###### patch begin Gilbert 20/1 #######//
//if( !read_file(&file) )
//{
// rc = -1;
// errMsg = "Load game error";
//}
switch( read_file(&file) )
{
case 1:
rc = 1;
break;
case -1:
rc = 0; // consider cancel load game
errMsg = _("Incompatible save game");
break;
case 0:
default:
rc = -1;
errMsg = _("Load game error");
}
if( rc > 0 )
{
load_process(); // process game data after loading the game
//------- create the town network --------//
town_network_array.recreate_after_load();
}
// ###### patch end Gilbert 20/1 #######//
}
file.file_close();
power.enable_flag = powerEnableFlag;
mouse_cursor.restore_icon( oldCursor );
power.win_opened=0;
//---------------------------------------//
switch(rc) // don't display msg if loaded successfully (rc==1)
{
case 0:
case -1:
box.msg( errMsg );
break;
}
last_read_success_flag = rc; // for external functions to read.
return rc;
}
