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; }