int detect_system(const char *track_path, const char **system_name) { int rv; char magic[MAGIC_LEN]; int i; RFILE *fd = filestream_open(track_path, RFILE_MODE_READ, -1); if (!fd) { RARCH_LOG("Could not open data track of file '%s': %s\n", track_path, strerror(errno)); rv = -errno; goto clean; } RARCH_LOG("%s\n", msg_hash_to_str(MSG_COMPARING_WITH_KNOWN_MAGIC_NUMBERS)); for (i = 0; MAGIC_NUMBERS[i].system_name != NULL; i++) { filestream_seek(fd, MAGIC_NUMBERS[i].offset, SEEK_SET); if (filestream_read(fd, magic, MAGIC_LEN) < MAGIC_LEN) { RARCH_LOG("Could not read data from file '%s' at offset %d: %s\n", track_path, MAGIC_NUMBERS[i].offset, strerror(errno)); rv = -errno; goto clean; } if (!string_is_empty(MAGIC_NUMBERS[i].magic) && !string_is_empty(magic) && string_is_equal_fast(MAGIC_NUMBERS[i].magic, magic, MAGIC_LEN)) { *system_name = MAGIC_NUMBERS[i].system_name; rv = 0; goto clean; } } filestream_seek(fd, 0x8008, SEEK_SET); if (filestream_read(fd, magic, 8) > 0) { magic[8] = '\0'; if (!string_is_empty(magic) && string_is_equal_fast(magic, "PSP GAME", 8)) { *system_name = "psp\0"; rv = 0; goto clean; } } RARCH_LOG("%s\n", msg_hash_to_str(MSG_COULD_NOT_FIND_COMPATIBLE_SYSTEM)); rv = -EINVAL; clean: filestream_close(fd); return rv; }
int filestream_eof(RFILE *stream) { size_t current_position = filestream_tell(stream); size_t end_position = filestream_seek(stream, 0, SEEK_END); filestream_seek(stream, current_position, SEEK_SET); if (current_position >= end_position) return 1; return 0; }
int detect_system(const char *track_path, int32_t offset, const char **system_name) { int rv; char magic[MAGIC_LEN]; int i; RFILE *fd = filestream_open(track_path, RFILE_MODE_READ, -1); if (!fd) { RARCH_LOG("Could not open data track of file '%s': %s\n", track_path, strerror(errno)); rv = -errno; goto clean; } filestream_seek(fd, offset, SEEK_SET); if (filestream_read(fd, magic, MAGIC_LEN) < MAGIC_LEN) { RARCH_LOG("Could not read data from file '%s' at offset %d: %s\n", track_path, offset, strerror(errno)); rv = -errno; goto clean; } RARCH_LOG("Comparing with known magic numbers...\n"); for (i = 0; MAGIC_NUMBERS[i].system_name != NULL; i++) { if (memcmp(MAGIC_NUMBERS[i].magic, magic, MAGIC_LEN) == 0) { *system_name = MAGIC_NUMBERS[i].system_name; rv = 0; goto clean; } } filestream_seek(fd, 0x8008, SEEK_SET); if (filestream_read(fd, magic, 8) > 0) { magic[8] = '\0'; if (string_is_equal(magic, "PSP GAME")) { *system_name = "psp\0"; rv = 0; goto clean; } } RARCH_LOG("Could not find compatible system\n"); rv = -EINVAL; clean: filestream_close(fd); return rv; }
void filestream_set_size(RFILE *stream) { if (!stream) return; filestream_seek(stream, 0, SEEK_SET); filestream_seek(stream, 0, SEEK_END); stream->size = filestream_tell(stream); filestream_seek(stream, 0, SEEK_SET); }
/** * libretrodb_cursor_reset: * @cursor : Handle to database cursor. * * Resets cursor. * * Returns: ???. **/ int libretrodb_cursor_reset(libretrodb_cursor_t *cursor) { cursor->eof = 0; return filestream_seek(cursor->fd, (ssize_t)(cursor->db->root + sizeof(libretrodb_header_t)), SEEK_SET); }
int libretrodb_create(RFILE *fd, libretrodb_value_provider value_provider, void *ctx) { int rv; libretrodb_metadata_t md; struct rmsgpack_dom_value item; uint64_t item_count = 0; libretrodb_header_t header = {{0}}; ssize_t root = filestream_seek(fd, 0, SEEK_CUR); memcpy(header.magic_number, MAGIC_NUMBER, sizeof(MAGIC_NUMBER)-1); /* We write the header in the end because we need to know the size of * the db first */ filestream_seek(fd, sizeof(libretrodb_header_t), SEEK_CUR); item.type = RDT_NULL; while ((rv = value_provider(ctx, &item)) == 0) { if ((rv = libretrodb_validate_document(&item)) < 0) goto clean; if ((rv = rmsgpack_dom_write(fd, &item)) < 0) goto clean; rmsgpack_dom_value_free(&item); item.type = RDT_NULL; item_count++; } if (rv < 0) goto clean; if ((rv = rmsgpack_dom_write(fd, &sentinal)) < 0) goto clean; header.metadata_offset = swap_if_little64(filestream_seek(fd, 0, SEEK_CUR)); md.count = item_count; libretrodb_write_metadata(fd, &md); filestream_seek(fd, root, SEEK_SET); filestream_write(fd, &header, sizeof(header)); clean: rmsgpack_dom_value_free(&item); return rv; }
void filestream_rewind(RFILE *stream) { if (!stream) return; filestream_seek(stream, 0L, RETRO_VFS_SEEK_POSITION_START); stream->error_flag = false; stream->eof_flag = false; }
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; RFILE *file = filestream_open(path, RFILE_MODE_READ, -1); if (!file) return NULL; rxml_document_t *doc = (rxml_document_t*)calloc(1, sizeof(*doc)); if (!doc) goto error; filestream_seek(file, 0, SEEK_END); len = filestream_tell(file); filestream_rewind(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; }
/** * filestream_read_file: * @path : path to file. * @buf : buffer to allocate and read the contents of the * file into. Needs to be freed manually. * * Read the contents of a file into @buf. * * Returns: number of items read, -1 on error. */ int filestream_read_file(const char *path, void **buf, ssize_t *len) { ssize_t ret = 0; ssize_t content_buf_size = 0; void *content_buf = NULL; RFILE *file = filestream_open(path, RFILE_MODE_READ, -1); if (!file) { fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno)); goto error; } if (filestream_seek(file, 0, SEEK_END) != 0) goto error; content_buf_size = filestream_tell(file); if (content_buf_size < 0) goto error; filestream_rewind(file); content_buf = malloc(content_buf_size + 1); if (!content_buf) goto error; ret = filestream_read(file, content_buf, content_buf_size); if (ret < 0) { fprintf(stderr, "Failed to read %s: %s\n", path, strerror(errno)); goto error; } filestream_close(file); *buf = content_buf; /* Allow for easy reading of strings to be safe. * Will only work with sane character formatting (Unix). */ ((char*)content_buf)[content_buf_size] = '\0'; if (len) *len = ret; return 1; error: if (file) filestream_close(file); if (content_buf) free(content_buf); if (len) *len = -1; *buf = NULL; return 0; }
int libretrodb_open(const char *path, libretrodb_t *db) { libretrodb_header_t header; libretrodb_metadata_t md; int rv; RFILE *fd = filestream_open(path, RFILE_MODE_READ, -1); if (!fd) return -errno; strlcpy(db->path, path, sizeof(db->path)); db->root = filestream_seek(fd, 0, SEEK_CUR); if ((rv = filestream_read(fd, &header, sizeof(header))) == -1) { rv = -errno; goto error; } if (strncmp(header.magic_number, MAGIC_NUMBER, sizeof(MAGIC_NUMBER)) != 0) { rv = -EINVAL; goto error; } header.metadata_offset = swap_if_little64(header.metadata_offset); filestream_seek(fd, (ssize_t)header.metadata_offset, SEEK_SET); if (libretrodb_read_metadata(fd, &md) < 0) { rv = -EINVAL; goto error; } db->count = md.count; db->first_index_offset = filestream_seek(fd, 0, SEEK_CUR); db->fd = fd; return 0; error: if (fd) filestream_close(fd); return rv; }
static int libretrodb_find_index(libretrodb_t *db, const char *index_name, libretrodb_index_t *idx) { ssize_t eof = filestream_seek(db->fd, 0, SEEK_END); ssize_t offset = filestream_seek(db->fd, (ssize_t)db->first_index_offset, SEEK_SET); while (offset < eof) { libretrodb_read_index_header(db->fd, idx); if (strncmp(index_name, idx->name, strlen(idx->name)) == 0) return 0; offset = filestream_seek(db->fd, (ssize_t)idx->next, SEEK_CUR); } return -1; }
int intfstream_seek(intfstream_internal_t *intf, int offset, int whence) { if (!intf) return -1; switch (intf->type) { case INTFSTREAM_FILE: return filestream_seek(intf->file.fp, offset, whence); case INTFSTREAM_MEMORY: return memstream_seek(intf->memory.fp, offset, whence); } return -1; }
int64_t rfseek(RFILE* stream, int64_t offset, int origin) { int seek_position = -1; switch (origin) { case SEEK_SET: seek_position = RETRO_VFS_SEEK_POSITION_START; break; case SEEK_CUR: seek_position = RETRO_VFS_SEEK_POSITION_CURRENT; break; case SEEK_END: seek_position = RETRO_VFS_SEEK_POSITION_END; break; } return filestream_seek(stream, offset, seek_position); }
void FileStream::seek(int64_t offset, int whence) { int seek_position = -1; if (!fp) return; switch (whence) { case SEEK_SET: seek_position = RETRO_VFS_SEEK_POSITION_START; break; case SEEK_CUR: seek_position = RETRO_VFS_SEEK_POSITION_CURRENT; break; case SEEK_END: seek_position = RETRO_VFS_SEEK_POSITION_END; break; } filestream_seek(fp, offset, seek_position); }
RFILE* rfopen(const char *path, const char *mode) { RFILE *output = NULL; unsigned int retro_mode = RETRO_VFS_FILE_ACCESS_READ; bool position_to_end = false; if (strstr(mode, "r")) { retro_mode = RETRO_VFS_FILE_ACCESS_READ; if (strstr(mode, "+")) { retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE | RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING; } } else if (strstr(mode, "w")) { retro_mode = RETRO_VFS_FILE_ACCESS_WRITE; if (strstr(mode, "+")) retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE; } else if (strstr(mode, "a")) { retro_mode = RETRO_VFS_FILE_ACCESS_WRITE | RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING; position_to_end = true; if (strstr(mode, "+")) { retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE | RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING; } } output = filestream_open(path, retro_mode, RETRO_VFS_FILE_ACCESS_HINT_NONE); if (output && position_to_end) filestream_seek(output, 0, RETRO_VFS_SEEK_POSITION_END); return output; }
int libretrodb_find_entry(libretrodb_t *db, const char *index_name, const void *key, struct rmsgpack_dom_value *out) { libretrodb_index_t idx; int rv; void *buff; uint64_t offset; ssize_t bufflen, nread = 0; if (libretrodb_find_index(db, index_name, &idx) < 0) return -1; bufflen = idx.next; buff = malloc(bufflen); if (!buff) return -ENOMEM; while (nread < bufflen) { void *buff_ = (uint64_t *)buff + nread; rv = filestream_read(db->fd, buff_, bufflen - nread); if (rv <= 0) { free(buff); return -errno; } nread += rv; } rv = binsearch(buff, key, db->count, (ssize_t)idx.key_size, &offset); free(buff); if (rv == 0) filestream_seek(db->fd, (ssize_t)offset, SEEK_SET); return rmsgpack_dom_read(db->fd, out); }
int64_t intfstream_seek(intfstream_internal_t *intf, int64_t offset, int whence) { if (!intf) return -1; switch (intf->type) { case INTFSTREAM_FILE: { int seek_position = 0; switch (whence) { case SEEK_SET: seek_position = RETRO_VFS_SEEK_POSITION_START; break; case SEEK_CUR: seek_position = RETRO_VFS_SEEK_POSITION_CURRENT; break; case SEEK_END: seek_position = RETRO_VFS_SEEK_POSITION_END; break; } return (int64_t)filestream_seek(intf->file.fp, (int64_t)offset, seek_position); } case INTFSTREAM_MEMORY: return (int64_t)memstream_seek(intf->memory.fp, offset, whence); case INTFSTREAM_CHD: #ifdef HAVE_CHD return (int64_t)chdstream_seek(intf->chd.fp, offset, whence); #else break; #endif } return -1; }
int libretrodb_create_index(libretrodb_t *db, const char *name, const char *field_name) { struct node_iter_ctx nictx; struct rmsgpack_dom_value key; libretrodb_index_t idx; uint64_t idx_header_offset; struct rmsgpack_dom_value item; libretrodb_cursor_t cur = {0}; struct rmsgpack_dom_value *field = NULL; void *buff = NULL; uint64_t *buff_u64 = NULL; uint8_t field_size = 0; uint64_t item_loc = libretrodb_tell(db); bintree_t *tree = bintree_new(node_compare, &field_size); if (!tree || (libretrodb_cursor_open(db, &cur, NULL) != 0)) goto clean; key.type = RDT_STRING; key.val.string.len = strlen(field_name); /* We know we aren't going to change it */ key.val.string.buff = (char *) field_name; item.type = RDT_NULL; while (libretrodb_cursor_read_item(&cur, &item) == 0) { if (item.type != RDT_MAP) { printf("Only map keys are supported\n"); goto clean; } field = rmsgpack_dom_value_map_value(&item, &key); if (!field) { printf("field not found in item\n"); goto clean; } if (field->type != RDT_BINARY) { printf("field is not binary\n"); goto clean; } if (field->val.binary.len == 0) { printf("field is empty\n"); goto clean; } if (field_size == 0) field_size = field->val.binary.len; else if (field->val.binary.len != field_size) { printf("field is not of correct size\n"); goto clean; } buff = malloc(field_size + sizeof(uint64_t)); if (!buff) { goto clean; } memcpy(buff, field->val.binary.buff, field_size); buff_u64 = (uint64_t *)buff + field_size; memcpy(buff_u64, &item_loc, sizeof(uint64_t)); if (bintree_insert(tree, buff) != 0) { printf("Value is not unique: "); rmsgpack_dom_value_print(field); printf("\n"); goto clean; } buff = NULL; rmsgpack_dom_value_free(&item); item_loc = libretrodb_tell(db); } idx_header_offset = filestream_seek(db->fd, 0, SEEK_END); (void)idx_header_offset; strncpy(idx.name, name, 50); idx.name[49] = '\0'; idx.key_size = field_size; idx.next = db->count * (field_size + sizeof(uint64_t)); libretrodb_write_index_header(db->fd, &idx); nictx.db = db; nictx.idx = &idx; bintree_iterate(tree, node_iter, &nictx); clean: rmsgpack_dom_value_free(&item); if (buff) free(buff); if (cur.is_valid) libretrodb_cursor_close(&cur); if (tree) bintree_free(tree); free(tree); return 0; }
int detect_psp_game(const char *track_path, char *game_id) { unsigned pos; bool rv = false; RFILE *fd = filestream_open(track_path, RFILE_MODE_READ, -1); if (!fd) { RARCH_LOG("Could not open data track: %s\n", strerror(errno)); return -errno; } for (pos = 0; pos < 100000; pos++) { filestream_seek(fd, pos, SEEK_SET); if (filestream_read(fd, game_id, 5) > 0) { game_id[5] = '\0'; if (string_is_equal(game_id, "ULES-") || string_is_equal(game_id, "ULUS-") || string_is_equal(game_id, "ULJS-") || string_is_equal(game_id, "ULEM-") || string_is_equal(game_id, "ULUM-") || string_is_equal(game_id, "ULJM-") || string_is_equal(game_id, "UCES-") || string_is_equal(game_id, "UCUS-") || string_is_equal(game_id, "UCJS-") || string_is_equal(game_id, "UCAS-") || string_is_equal(game_id, "NPEH-") || string_is_equal(game_id, "NPUH-") || string_is_equal(game_id, "NPJH-") || string_is_equal(game_id, "NPEG-") || string_is_equal(game_id, "NPUG-") || string_is_equal(game_id, "NPJG-") || string_is_equal(game_id, "NPHG-") || string_is_equal(game_id, "NPEZ-") || string_is_equal(game_id, "NPUZ-") || string_is_equal(game_id, "NPJZ-") ) { filestream_seek(fd, pos, SEEK_SET); if (filestream_read(fd, game_id, 10) > 0) { #if 0 game_id[4] = '-'; game_id[8] = game_id[9]; game_id[9] = game_id[10]; #endif game_id[10] = '\0'; rv = true; } break; } } else break; } filestream_close(fd); return rv; }
static int detect_ps1_game_sub(const char *track_path, char *game_id, int sub_channel_mixed) { uint8_t* tmp; uint8_t buffer[2048 * 2]; int skip, frame_size, is_mode1, cd_sector; RFILE *fp = filestream_open(track_path, RFILE_MODE_READ, -1); if (!fp) return 0; is_mode1 = 0; filestream_seek(fp, 0, SEEK_END); if (!sub_channel_mixed) { if (!(filestream_tell(fp) & 0x7FF)) { unsigned int mode_test = 0; filestream_seek(fp, 0, SEEK_SET); filestream_read(fp, &mode_test, 4); if (mode_test != MODETEST_VAL) is_mode1 = 1; } } skip = is_mode1? 0: 24; frame_size = sub_channel_mixed? 2448: is_mode1? 2048: 2352; filestream_seek(fp, 156 + skip + 16 * frame_size, SEEK_SET); filestream_read(fp, buffer, 6); cd_sector = buffer[2] | (buffer[3] << 8) | (buffer[4] << 16); filestream_seek(fp, skip + cd_sector * frame_size, SEEK_SET); filestream_read(fp, buffer, 2048 * 2); tmp = buffer; while (tmp < (buffer + 2048 * 2)) { if (!*tmp) return 0; if (!strncasecmp((const char*)(tmp + 33), "SYSTEM.CNF;1", 12)) break; tmp += *tmp; } if(tmp >= (buffer + 2048 * 2)) return 0; cd_sector = tmp[2] | (tmp[3] << 8) | (tmp[4] << 16); filestream_seek(fp, 13 + skip + cd_sector * frame_size, SEEK_SET); filestream_read(fp, buffer, 256); tmp = (uint8_t*)strrchr((const char*)buffer, '\\'); if(!tmp) tmp = buffer; else tmp++; *game_id++ = toupper(*tmp++); *game_id++ = toupper(*tmp++); *game_id++ = toupper(*tmp++); *game_id++ = toupper(*tmp++); *game_id++ = '-'; tmp++; *game_id++ = *tmp++; *game_id++ = *tmp++; *game_id++ = *tmp++; tmp++; *game_id++ = *tmp++; *game_id++ = *tmp++; *game_id = 0; filestream_close(fp); return 1; }
void filestream_rewind(RFILE *stream) { filestream_seek(stream, 0L, SEEK_SET); }
RFILE *filestream_open(const char *path, unsigned mode, ssize_t len) { int flags = 0; int mode_int = 0; const char *mode_str = NULL; RFILE *stream = (RFILE*)calloc(1, sizeof(*stream)); if (!stream) return NULL; (void)mode_str; (void)mode_int; (void)flags; stream->hints = mode; #ifdef HAVE_MMAP if (stream->hints & RFILE_HINT_MMAP && (stream->hints & 0xff) == RFILE_MODE_READ) stream->hints |= RFILE_HINT_UNBUFFERED; else #endif stream->hints &= ~RFILE_HINT_MMAP; switch (mode & 0xff) { case RFILE_MODE_READ: #if defined(VITA) || defined(PSP) mode_int = 0777; flags = PSP_O_RDONLY; #elif defined(__CELLOS_LV2__) mode_int = 0777; flags = CELL_FS_O_RDONLY; #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) mode_str = "rb"; #endif /* No "else" here */ flags = O_RDONLY; #endif break; case RFILE_MODE_WRITE: #if defined(VITA) || defined(PSP) mode_int = 0777; flags = PSP_O_CREAT | PSP_O_WRONLY | PSP_O_TRUNC; #elif defined(__CELLOS_LV2__) mode_int = 0777; flags = CELL_FS_O_CREAT | CELL_FS_O_WRONLY | CELL_FS_O_TRUNC; #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) mode_str = "wb"; #endif else { flags = O_WRONLY | O_CREAT | O_TRUNC; #ifndef _WIN32 flags |= S_IRUSR | S_IWUSR; #endif } #endif break; case RFILE_MODE_READ_WRITE: #if defined(VITA) || defined(PSP) mode_int = 0777; flags = PSP_O_RDWR; #elif defined(__CELLOS_LV2__) mode_int = 0777; flags = CELL_FS_O_RDWR; #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) mode_str = "w+"; #endif else { flags = O_RDWR; #ifdef _WIN32 flags |= O_BINARY; #endif } #endif break; } #if defined(VITA) || defined(PSP) stream->fd = sceIoOpen(path, flags, mode_int); #elif defined(__CELLOS_LV2__) cellFsOpen(path, flags, &stream->fd, NULL, 0); #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) { stream->fp = fopen(path, mode_str); if (!stream->fp) goto error; } else #endif { stream->fd = open(path, flags); if (stream->fd == -1) goto error; #ifdef HAVE_MMAP if (stream->hints & RFILE_HINT_MMAP) { stream->mappos = 0; stream->mapped = NULL; stream->mapsize = filestream_seek(stream, 0, SEEK_END); if (stream->mapsize == (uint64_t)-1) goto error; filestream_rewind(stream); stream->mapped = (uint8_t*)mmap((void*)0, stream->mapsize, PROT_READ, MAP_SHARED, stream->fd, 0); if (stream->mapped == MAP_FAILED) stream->hints &= ~RFILE_HINT_MMAP; } #endif } #endif #if defined(VITA) || defined(PSP) || defined(__CELLOS_LV2__) if (stream->fd == -1) goto error; #endif return stream; error: filestream_close(stream); return NULL; }
static int detect_ps1_game_sub(const char *track_path, char *game_id, int sub_channel_mixed) { uint8_t* tmp; uint8_t* boot_file; int skip, frame_size, is_mode1, cd_sector; uint8_t buffer[2048 * 2]; RFILE *fp = filestream_open(track_path, RFILE_MODE_READ, -1); if (!fp) return 0; buffer[0] = '\0'; is_mode1 = 0; filestream_seek(fp, 0, SEEK_END); if (!sub_channel_mixed) { if (!(filestream_tell(fp) & 0x7FF)) { unsigned int mode_test = 0; filestream_seek(fp, 0, SEEK_SET); filestream_read(fp, &mode_test, 4); if (mode_test != MODETEST_VAL) is_mode1 = 1; } } skip = is_mode1? 0: 24; frame_size = sub_channel_mixed? 2448: is_mode1? 2048: 2352; filestream_seek(fp, 156 + skip + 16 * frame_size, SEEK_SET); filestream_read(fp, buffer, 6); cd_sector = buffer[2] | (buffer[3] << 8) | (buffer[4] << 16); filestream_seek(fp, skip + cd_sector * frame_size, SEEK_SET); filestream_read(fp, buffer, 2048 * 2); tmp = buffer; while (tmp < (buffer + 2048 * 2)) { if (!*tmp) goto error; if (!strncasecmp((const char*)(tmp + 33), "SYSTEM.CNF;1", 12)) break; tmp += *tmp; } if(tmp >= (buffer + 2048 * 2)) goto error; cd_sector = tmp[2] | (tmp[3] << 8) | (tmp[4] << 16); filestream_seek(fp, skip + cd_sector * frame_size, SEEK_SET); filestream_read(fp, buffer, 256); buffer[256] = '\0'; tmp = buffer; while(*tmp && strncasecmp((const char*)tmp, "boot", 4)) tmp++; if(!*tmp) goto error; boot_file = tmp; while(*tmp && *tmp != '\n') { if((*tmp == '\\') || (*tmp == ':')) boot_file = tmp + 1; tmp++; } tmp = boot_file; *game_id++ = toupper(*tmp++); *game_id++ = toupper(*tmp++); *game_id++ = toupper(*tmp++); *game_id++ = toupper(*tmp++); *game_id++ = '-'; if(!isalnum(*tmp)) tmp++; while(isalnum(*tmp)) { *game_id++ = *tmp++; if(*tmp == '.') tmp++; } *game_id = 0; filestream_close(fp); return 1; error: filestream_close(fp); return 0; }
RFILE *filestream_open(const char *path, unsigned mode, ssize_t len) { int flags = 0; int mode_int = 0; #if defined(HAVE_BUFFERED_IO) const char *mode_str = NULL; #endif RFILE *stream = (RFILE*)calloc(1, sizeof(*stream)); if (!stream) return NULL; (void)mode_int; (void)flags; stream->hints = mode; #ifdef HAVE_MMAP if (stream->hints & RFILE_HINT_MMAP && (stream->hints & 0xff) == RFILE_MODE_READ) stream->hints |= RFILE_HINT_UNBUFFERED; else #endif stream->hints &= ~RFILE_HINT_MMAP; switch (mode & 0xff) { case RFILE_MODE_READ_TEXT: #if defined(PSP) mode_int = 0666; flags = PSP_O_RDONLY; #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) mode_str = MODE_STR_READ; #endif /* No "else" here */ flags = O_RDONLY; #endif break; case RFILE_MODE_READ: #if defined(PSP) mode_int = 0666; flags = PSP_O_RDONLY; #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) mode_str = MODE_STR_READ_UNBUF; #endif /* No "else" here */ flags = O_RDONLY; #endif break; case RFILE_MODE_WRITE: #if defined(PSP) mode_int = 0666; flags = PSP_O_CREAT | PSP_O_WRONLY | PSP_O_TRUNC; #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) mode_str = MODE_STR_WRITE_UNBUF; #endif else { flags = O_WRONLY | O_CREAT | O_TRUNC; #ifndef _WIN32 flags |= S_IRUSR | S_IWUSR; #endif } #endif break; case RFILE_MODE_READ_WRITE: #if defined(PSP) mode_int = 0666; flags = PSP_O_RDWR; #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) mode_str = MODE_STR_WRITE_PLUS; #endif else { flags = O_RDWR; #ifdef _WIN32 flags |= O_BINARY; #endif } #endif break; } #if defined(PSP) stream->fd = sceIoOpen(path, flags, mode_int); #else #if defined(HAVE_BUFFERED_IO) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) { stream->fp = fopen(path, mode_str); if (!stream->fp) goto error; } else #endif { /* FIXME: HAVE_BUFFERED_IO is always 1, but if it is ever changed, open() needs to be changed to _wopen() for WIndows. */ stream->fd = open(path, flags); if (stream->fd == -1) goto error; #ifdef HAVE_MMAP if (stream->hints & RFILE_HINT_MMAP) { stream->mappos = 0; stream->mapped = NULL; stream->mapsize = filestream_seek(stream, 0, SEEK_END); if (stream->mapsize == (uint64_t)-1) goto error; filestream_rewind(stream); stream->mapped = (uint8_t*)mmap((void*)0, stream->mapsize, PROT_READ, MAP_SHARED, stream->fd, 0); if (stream->mapped == MAP_FAILED) stream->hints &= ~RFILE_HINT_MMAP; } #endif } #endif #if defined(PSP) if (stream->fd == -1) goto error; #endif return stream; error: filestream_close(stream); return NULL; }
static uint64_t libretrodb_tell(libretrodb_t *db) { return filestream_seek(db->fd, 0, SEEK_CUR); }
int detect_psp_game(const char *track_path, char *game_id) { unsigned pos; bool rv = false; RFILE *fd = filestream_open(track_path, RFILE_MODE_READ, -1); if (!fd) { RARCH_LOG("%s: %s\n", msg_hash_to_str(MSG_COULD_NOT_OPEN_DATA_TRACK), strerror(errno)); return -errno; } for (pos = 0; pos < 100000; pos++) { filestream_seek(fd, pos, SEEK_SET); if (filestream_read(fd, game_id, 5) > 0) { game_id[5] = '\0'; if (!string_is_empty(game_id)) { if ( (string_is_equal_fast(game_id, "ULES-", 5)) || (string_is_equal_fast(game_id, "ULUS-", 5)) || (string_is_equal_fast(game_id, "ULJS-", 5)) || (string_is_equal_fast(game_id, "ULEM-", 5)) || (string_is_equal_fast(game_id, "ULUM-", 5)) || (string_is_equal_fast(game_id, "ULJM-", 5)) || (string_is_equal_fast(game_id, "UCES-", 5)) || (string_is_equal_fast(game_id, "UCUS-", 5)) || (string_is_equal_fast(game_id, "UCJS-", 5)) || (string_is_equal_fast(game_id, "UCAS-", 5)) || (string_is_equal_fast(game_id, "NPEH-", 5)) || (string_is_equal_fast(game_id, "NPUH-", 5)) || (string_is_equal_fast(game_id, "NPJH-", 5)) || (string_is_equal_fast(game_id, "NPEG-", 5)) || (string_is_equal_fast(game_id, "NPUG-", 5)) || (string_is_equal_fast(game_id, "NPJG-", 5)) || (string_is_equal_fast(game_id, "NPHG-", 5)) || (string_is_equal_fast(game_id, "NPEZ-", 5)) || (string_is_equal_fast(game_id, "NPUZ-", 5)) || (string_is_equal_fast(game_id, "NPJZ-", 5)) ) { filestream_seek(fd, pos, SEEK_SET); if (filestream_read(fd, game_id, 10) > 0) { #if 0 game_id[4] = '-'; game_id[8] = game_id[9]; game_id[9] = game_id[10]; #endif game_id[10] = '\0'; rv = true; } break; } } } else break; } filestream_close(fd); return rv; }