/* * fopen() for a compressed file */ struct zfile *zfile_fopen (const char *name, const char *mode) { struct zfile *l; FILE *f; char zipname[1000]; if( *name == '\0' ) return NULL; l = zfile_create (); l->name = strdup (name); #ifdef SINGLEFILE if (zfile_opensinglefile (l)) return l; #endif f = openzip (l->name, zipname); if (f) { if (strcasecmp (mode, "rb")) { zfile_fclose (l); fclose (f); return 0; } l->zipname = strdup (zipname); } if (!f) { f = fopen (name, mode); if (!f) { zfile_fclose (l); return 0; } } l->f = f; l = zuncompress (l); return l; }
/* we want to delete temporary files as early as possible */ static struct zfile *updateoutputfile (struct zfile *z) { struct zfile *z2 = 0; int size; FILE *f = fopen (z->name, "rb"); for (;;) { if (!f) break; fseek (f, 0, SEEK_END); size = ftell (f); fseek (f, 0, SEEK_SET); if (!size) break; z2 = zfile_fopen_empty (z->name, size); if (!z2) break; fread (z2->data, size, 1, f); fclose (f); zfile_fclose (z); return z2; } if (f) fclose (f); zfile_fclose (z); zfile_fclose (z2); return 0; }
static struct zfile *dms (struct zfile *z) { char cmd[2048]; struct zfile *zi = createinputfile (z); struct zfile *zo = createoutputfile (z); if (zi && zo) { sprintf(cmd, "xdms -q u \"%s\" +\"%s\"", zi->name, zo->name); execute_command (cmd); } zfile_fclose (zi); zfile_fclose (z); return updateoutputfile (zo); }
int fsimage_open(disk_image_t *image) { fsimage_t *fsimage; fsimage = image->media.fsimage; if (image->read_only) { fsimage->fd = zfile_fopen(fsimage->name, MODE_READ); } else { fsimage->fd = zfile_fopen(fsimage->name, MODE_READ_WRITE); /* If we cannot open the image read/write, try to open it read only. */ if (fsimage->fd == NULL) { fsimage->fd = zfile_fopen(fsimage->name, MODE_READ); image->read_only = 1; } } if (fsimage->fd == NULL) { log_error(fsimage_log, "Cannot open file `%s'.", fsimage->name); return -1; } if (fsimage_probe(image) == 0) return 0; zfile_fclose(fsimage->fd); log_message(fsimage_log, "Unknown disk image `%s'.", fsimage->name); return -1; }
int fsimage_open(disk_image_t *image) { fsimage_t *fsimage; fsimage = image->media.fsimage; if (image->read_only) { fsimage->fd = zfile_fopen(fsimage->name, MODE_READ); } else { fsimage->fd = zfile_fopen(fsimage->name, MODE_READ_WRITE); /* If we cannot open the image read/write, try to open it read only. */ if (fsimage->fd == NULL) { fsimage->fd = zfile_fopen(fsimage->name, MODE_READ); image->read_only = 1; } } if (fsimage->fd == NULL) { #ifdef CELL_DEBUG printf("INFO: Cannot open file `%s'.\n", fsimage->name); #endif return -1; } if (fsimage_probe(image) == 0) return 0; zfile_fclose(fsimage->fd); #ifdef CELL_DEBUG printf("ERROR: Unknown disk image `%s'.\n", fsimage->name); #endif return -1; }
static int loadsample (TCHAR *path, struct drvsample *ds) { struct zfile *f; uae_u8 *buf; int size; TCHAR name[MAX_DPATH]; f = zfile_fopen (path, _T("rb"), ZFD_NORMAL); if (!f) { _tcscpy (name, path); _tcscat (name, _T(".wav")); f = zfile_fopen (name, _T("rb"), ZFD_NORMAL); if (!f) { write_log (_T("driveclick: can't open '%s' (or '%s')\n"), path, name); return 0; } } zfile_fseek (f, 0, SEEK_END); size = zfile_ftell (f); buf = xmalloc (uae_u8, size); zfile_fseek (f, 0, SEEK_SET); zfile_fread (buf, size, 1, f); zfile_fclose (f); ds->len = size; ds->p = decodewav (buf, &ds->len); xfree (buf); return 1; }
static int read_kickstart (struct zfile *f, uae_u8 *mem, int size, int dochecksum, int *cloanto_rom) { unsigned char buffer[20]; int i, j, cr = 0; fprintf(stderr,"read_kickstart\n"); if (cloanto_rom) *cloanto_rom = 0; i = zfile_fread (buffer, 1, 11, f); if (strncmp ((char *) buffer, "AMIROMTYPE1", 11) != 0) { zfile_fseek (f, 0, SEEK_SET); } else { cr = 1; } if (cloanto_rom) *cloanto_rom = cr; i = zfile_fread (mem, 1, size, f); if (i != 8192 && i != 65536 && i != 131072 && i != 262144 && i != 524288 && i != 524288 * 2 && i != 524288 * 4) { gui_message ("Error while reading Kickstart ROM file."); return 0; } if (i == size / 2) memcpy (mem + size / 2, mem, size / 2); if (cr) { if (!decode_cloanto_rom (mem, size, i, 0)) return 0; } if (currprefs.cs_a1000ram) { int off = 0; a1000_bootrom = xcalloc (262144, 1); while (off + i < 262144) { memcpy (a1000_bootrom + off, kickmemory, i); off += i; } memset (kickmemory, 0, kickmem_size); a1000_handle_kickstart (1); dochecksum = 0; i = 524288; } zfile_fclose (f); for (j = 0; j < 256 && i >= 262144; j++) { if (!memcmp (mem + j, kickstring, strlen (kickstring) + 1)) break; } if (j == 256 || i < 262144) dochecksum = 0; if (dochecksum) kickstart_checksum (mem, size); return 1; }
static int zfile_load(const char *filename, BYTE *dest, size_t size) { FILE *fd; fd = zfile_fopen(filename, MODE_READ); if (!fd) { return -1; } if (util_file_length(fd) != size) { zfile_fclose(fd); return -1; } if (fread(dest, size, 1, fd) < 1) { zfile_fclose(fd); return -1; } zfile_fclose(fd); return 0; }
bool rp9_parse_file(struct uae_prefs *p, const char *filename) { bool bResult = false; struct zfile *zf; unzFile uz; unz_file_info file_info; char *manifest; add_HDF_DHnum = 0; clip_no_hires = false; zf = zfile_fopen(filename, _T("rb")); if(zf != NULL) { uz = unzOpen(zf); if (uz != NULL) { if (unzLocateFile (uz, RP9_MANIFEST, 1) == UNZ_OK) { if (unzGetCurrentFileInfo (uz, &file_info, NULL, 0, NULL, 0, NULL, 0) == UNZ_OK) { manifest = (char *)malloc(file_info.uncompressed_size + 1); if(manifest != NULL) { if (unzOpenCurrentFile (uz) == UNZ_OK) { int readsize = unzReadCurrentFile(uz, manifest, file_info.uncompressed_size); unzCloseCurrentFile(uz); if(readsize == file_info.uncompressed_size) { manifest[readsize] = '\0'; bResult = parse_manifest(p, uz, manifest); if(bResult) { // Fixup some prefs... if(p->m68k_speed >= 0) p->cachesize = 0; // Use JIT only if max. speed selected p->input_joymouse_multiplier = 5; // Most games need slower mouse movement... } } } free(manifest); } } } unzClose (uz); } zfile_fclose(zf); } return bResult; }
static void cdtvcr_battram_reset (void) { struct zfile *f; int v; memset (cdtvcr_ram, 0, CDTVCR_RAM_SIZE); f = zfile_fopen (currprefs.flashfile, _T("rb+"), ZFD_NORMAL); if (!f) { f = zfile_fopen (currprefs.flashfile, _T("wb"), 0); if (f) { zfile_fwrite (cdtvcr_ram, CDTVCR_RAM_SIZE, 1, f); zfile_fclose (f); } return; } v = zfile_fread (cdtvcr_ram, 1, CDTVCR_RAM_SIZE, f); if (v < CDTVCR_RAM_SIZE) zfile_fwrite (cdtvcr_ram + v, 1, CDTVCR_RAM_SIZE - v, f); zfile_fclose (f); }
/* Close a ZipFile opened with unzipOpen. If there is files inside the .Zip opened with unzipOpenCurrentFile (see later), these files MUST be closed with unzipCloseCurrentFile before call unzipClose. return UNZ_OK if there is no problem. */ extern int ZEXPORT unzClose (unzFile file) { unz_s* s; if (file==NULL) return UNZ_PARAMERROR; s=(unz_s*)file; if (s->pfile_in_zip_read!=NULL) unzCloseCurrentFile(file); zfile_fclose(s->file); TRYFREE(s); return UNZ_OK; }
static struct zfile *dms (struct zfile *z) { int ret; struct zfile *zo; zo = zfile_fopen_empty ("zipped.dms", 1760 * 512); if (!zo) return z; ret = DMS_Process_File (z, zo, CMD_UNPACK, OPT_VERBOSE, 0, 0); if (ret == NO_PROBLEM || ret == DMS_FILE_END) { zfile_fclose (z); return zo; } return z; }
static int zfile_load(const char *filename, BYTE *dest) { FILE *fd; size_t fsize; fd = zfile_fopen(filename, MODE_READ); if (!fd) { log_message(fe_log, "Failed to open image `%s'!", filename); return -1; } fsize = util_file_length(fd); if (fsize < 0x8000) { size_t tsize; size_t offs; tsize = (fsize + 0x0fff) & 0xfffff000; offs = 0x8000 - tsize; dest += offs; log_message(fe_log, "Size less than 32kB. Aligning as close as possible to the 32kB boundary in 4kB blocks. (0x%06X-0x%06X)", (unsigned int)offs, (unsigned int)(offs + tsize)); } else if (fsize < (size_t)CART_ROM_SIZE) { log_message(fe_log, "Size less than 512kB, padding."); } else if (fsize > (size_t)CART_ROM_SIZE) { fsize = CART_ROM_SIZE; log_message(fe_log, "Size larger than 512kB, truncating."); } if (fread(dest, fsize, 1, fd) < 1) { log_message(fe_log, "Failed to read image `%s'!", filename); zfile_fclose(fd); return -1; } zfile_fclose(fd); log_message(fe_log, "Read image `%s'.", filename); return 0; }
int fsimage_close(disk_image_t *image) { fsimage_t *fsimage; fsimage = image->media.fsimage; if (fsimage->fd == NULL) { log_error(fsimage_log, "Cannot close file `%s'.", fsimage->name); return -1; } zfile_fclose(fsimage->fd); fsimage_error_info_destroy(fsimage); return 0; }
void chd_file::close() { // reset file characteristics if (m_owns_file && m_file != NULL) zfile_fclose(m_file); m_file = NULL; m_owns_file = false; m_allow_reads = false; m_allow_writes = false; // reset core parameters from the header m_version = HEADER_VERSION; m_logicalbytes = 0; m_mapoffset = 0; m_metaoffset = 0; m_hunkbytes = 0; m_hunkcount = 0; m_unitbytes = 0; m_unitcount = 0; memset(m_compression, 0, sizeof(m_compression)); m_parent = NULL; m_parent_missing = false; // reset key offsets within the header m_mapoffset_offset = 0; m_metaoffset_offset = 0; m_sha1_offset = 0; m_rawsha1_offset = 0; m_parentsha1_offset = 0; // reset map information m_mapentrybytes = 0; m_rawmap.reset(); // reset compression management for (int decompnum = 0; decompnum < ARRAY_LENGTH(m_decompressor); decompnum++) { delete m_decompressor[decompnum]; m_decompressor[decompnum] = NULL; } m_compressed.reset(); // reset caching m_cache.reset(); m_cachehunk = ~0; }
static void cdtvcr_battram_write (int addr, int v) { struct zfile *f; int offset = addr & CDTVCR_RAM_MASK; if (offset >= CDTVCR_RAM_SIZE) return; gui_flicker_led (LED_MD, 0, 2); if (cdtvcr_ram[offset] == v) return; cdtvcr_ram[offset] = v; f = zfile_fopen (currprefs.flashfile, _T("rb+"), ZFD_NORMAL); if (!f) return; zfile_fseek (f, offset, SEEK_SET); zfile_fwrite (cdtvcr_ram + offset, 1, 1, f); zfile_fclose (f); }
void addkeyfile (const TCHAR *path) { struct zfile *f; int keysize; uae_u8 *keybuf; f = zfile_fopen (path, L"rb", ZFD_NORMAL); if (!f) return; zfile_fseek (f, 0, SEEK_END); keysize = zfile_ftell (f); if (keysize > 0) { zfile_fseek (f, 0, SEEK_SET); keybuf = xmalloc (uae_u8, keysize); zfile_fread (keybuf, 1, keysize, f); addkey (keybuf, keysize, path); } zfile_fclose (f); }
void inprec_close(void) { if (!inprec_zf) return; if (inprec_buffer && input_recording > 0) { hsync_counter++; inprec_rstart(INPREC_END); inprec_rend(); hsync_counter--; zfile_fwrite (inprec_buffer, inprec_p - inprec_buffer, 1, inprec_zf); inprec_p = inprec_buffer; } zfile_fclose (inprec_zf); inprec_zf = NULL; xfree (inprec_buffer); inprec_buffer = NULL; input_recording = 0; write_log ("inprec finished\n"); }
int fsimage_close(disk_image_t *image) { fsimage_t *fsimage; fsimage = image->media.fsimage; if (fsimage->fd == NULL) { #ifdef CELL_DEBUG printf("ERROR: Cannot close file `%s'.\n", fsimage->name); #endif return -1; } zfile_fclose(fsimage->fd); fsimage_error_info_destroy(fsimage); return 0; }
static void mergecd32 (uae_u8 *dst, uae_u8 *src, int size) { int i, k; k = 0; for (i = 0; i < size / 2; i += 2) { int j = i + size / 2; dst[k + 1] = src[i + 0]; dst[k + 0] = src[i + 1]; dst[k + 3] = src[j + 0]; dst[k + 2] = src[j + 1]; k += 4; } #if 0 { struct zfile *f; f = zfile_fopen ("c:\\d\\1.rom","wb", ZFD_NORMAL); zfile_fwrite (dst, 1, size, f); zfile_fclose(f); } #endif }
void amax_init (void) { struct zfile *z; if (!currprefs.amaxromfile[0]) return; amax_reset (); z = zfile_fopen (currprefs.amaxromfile, _T("rb"), ZFD_NORMAL); if (!z) { write_log (_T("AMAX: failed to load rom '%s'\n"), currprefs.amaxromfile); return; } zfile_fseek (z, 0, SEEK_END); amax_rom_size = zfile_ftell (z); zfile_fseek (z, 0, SEEK_SET); rom = xmalloc (uae_u8, amax_rom_size); zfile_fread (rom, amax_rom_size, 1, z); zfile_fclose (z); write_log (_T("AMAX: '%s' loaded, %d bytes\n"), currprefs.amaxromfile, amax_rom_size); dselect = 0x20; }
struct zfile *read_rom_name (const TCHAR *filename) { int i; struct zfile *f; for (i = 0; i < romlist_cnt; i++) { if (!_tcsicmp (filename, rl[i].path)) { struct romdata *rd = rl[i].rd; f = read_rom (&rd); if (f) return f; } } f = rom_fopen (filename, L"rb", ZFD_NORMAL); if (f) { uae_u8 tmp[11]; zfile_fread (tmp, sizeof tmp, 1, f); if (!memcmp (tmp, "AMIROMTYPE1", sizeof tmp)) { struct zfile *df; int size; uae_u8 *buf; addkeydir (filename); zfile_fseek (f, 0, SEEK_END); size = zfile_ftell (f) - sizeof tmp; zfile_fseek (f, sizeof tmp, SEEK_SET); buf = xmalloc (uae_u8, size); zfile_fread (buf, size, 1, f); df = zfile_fopen_empty (f, L"tmp.rom", size); decode_cloanto_rom_do (buf, size, size); zfile_fwrite (buf, size, 1, df); zfile_fclose (f); xfree (buf); zfile_fseek (df, 0, SEEK_SET); f = df; } else { zfile_fseek (f, -((int)sizeof tmp), SEEK_CUR); } } return f; }
static int loadsample (const char *path, struct drvsample *ds) { struct zfile *f; uae_u8 *buf; int size; f = zfile_fopen (path, "rb"); if (!f) { write_log ("driveclick: can't open '%s'\n", path); return 0; } zfile_fseek (f, 0, SEEK_END); size = zfile_ftell (f); buf = malloc (size); zfile_fseek (f, 0, SEEK_SET); zfile_fread (buf, size, 1, f); zfile_fclose (f); ds->len = size; ds->p = decodewav (buf, &ds->len); free (buf); return 1; }
static int read_rom_file (uae_u8 *buf, const struct romdata *rd) { struct zfile *zf; struct romlist *rl = romlist_getrl (rd); uae_char tmp[11]; if (!rl || _tcslen (rl->path) == 0) return 0; zf = zfile_fopen (rl->path, L"rb", ZFD_NORMAL); if (!zf) return 0; addkeydir (rl->path); zfile_fread (tmp, sizeof tmp, 1, zf); if (!memcmp (tmp, "AMIROMTYPE1", sizeof tmp)) { zfile_fread (buf, rd->size, 1, zf); decode_cloanto_rom_do (buf, rd->size, rd->size); } else { memcpy (buf, tmp, sizeof tmp); zfile_fread (buf + sizeof tmp, rd->size - sizeof (tmp), 1, zf); } zfile_fclose (zf); return 1; }
int fsimage_close(disk_image_t *image) { fsimage_t *fsimage; fsimage = image->media.fsimage; if (fsimage->fd == NULL) { log_error(fsimage_log, "Cannot close file `%s'.", fsimage->name); return -1; } /* if (image->type == DISK_IMAGE_TYPE_P64) { fsimage_write_p64_image(image); }*/ if (fsimage->error_info.map) { lib_free(fsimage->error_info.map); fsimage->error_info.map = NULL; } zfile_fclose(fsimage->fd); fsimage->fd = NULL; return 0; }
static int unpack2 (const TCHAR *src, const TCHAR *match, int level) { struct zdirectory *h; struct zvolume *zv; int ret; uae_u8 *b; int size; TCHAR fn[MAX_DPATH]; ret = 0; zv = zfile_fopen_archive_root (src, ZFD_ALL); if (zv == NULL) { geterror(); _tprintf (_T("Couldn't open archive '%s'\n"), src); return 0; } h = zfile_opendir_archive (src); if (!h) { geterror(); _tprintf (_T("Couldn't open directory '%s'\n"), src); return 0; } while (zfile_readdir_archive (h, fn)) { TCHAR tmp[MAX_DPATH]; TCHAR *dst; struct zfile *s, *d; int isdir, flags; _tcscpy (tmp, src); _tcscat (tmp, sep); _tcscat (tmp, fn); zfile_fill_file_attrs_archive (tmp, &isdir, &flags, NULL); if (isdir) { TCHAR *p = _tcsstr (fn, _T(".DIR")); if (isdir == ZNODE_VDIR && p && _tcslen (p) == 4) { p[0] = 0; if (pattern_match (fn, match)) continue; p[0] = '.'; } unpack2 (tmp, match, 1); continue; } if (pattern_match (fn, match)) { struct mystat st; if (!zfile_stat_archive (tmp, &st)) { st.mtime.tv_sec = st.mtime.tv_usec = -1; } found = 1; dst = fn; s = zfile_open_archive (tmp, ZFD_NORECURSE); if (!s) { geterror(); _tprintf (_T("Couldn't open '%s' for reading\n"), tmp); continue; } zfile_fseek (s, 0, SEEK_END); size = zfile_ftell (s); zfile_fseek (s, 0, SEEK_SET); b = xcalloc (uae_u8, size); if (b) { if (zfile_fread (b, size, 1, s) == 1) { d = zfile_fopen (dst, _T("wb"), 0); if (d) { if (zfile_fwrite (b, size, 1, d) == 1) { ret = 1; _tprintf (_T("%s extracted, %d bytes\n"), dst, size); } zfile_fclose (d); setdate (dst, st.mtime.tv_sec); } } xfree (b); } zfile_fclose (s); } } geterror (); if (!found && !level) { _tprintf (_T("'%s' not matched\n"), match); } return ret; }
static int unpack (const TCHAR *src, const TCHAR *filename, const TCHAR *dst, int out, int all, int level) { struct zdirectory *h; struct zvolume *zv; int ret; uae_u8 *b; int size; TCHAR fn[MAX_DPATH]; ret = 0; zv = zfile_fopen_archive_root (src, ZFD_ALL); if (zv == NULL) { geterror(); _tprintf (_T("Couldn't open archive '%s'\n"), src); return 0; } h = zfile_opendir_archive (src); if (!h) { geterror(); _tprintf (_T("Couldn't open directory '%s'\n"), src); return 0; } while (zfile_readdir_archive (h, fn)) { if (all || !_tcsicmp (filename, fn)) { TCHAR tmp[MAX_DPATH]; struct zfile *s, *d; struct mystat st; found = 1; _tcscpy (tmp, src); _tcscat (tmp, sep); _tcscat (tmp, fn); if (!zfile_stat_archive (tmp, &st)) { _tprintf (_T("Couldn't stat '%s'\n"), tmp); continue; } if (dst == NULL || all) dst = fn; if (st.mode) { if (all > 0) continue; if (all < 0) { TCHAR oldcur[MAX_DPATH]; my_mkdir (fn); my_setcurrentdir (fn, oldcur); unpack (tmp, fn, dst, out, all, 1); my_setcurrentdir (oldcur, NULL); setdate (dst, st.mtime.tv_sec); continue; } _tprintf (_T("Directory extraction not yet supported\n")); return 0; } s = zfile_open_archive (tmp, ZFD_ARCHIVE | ZFD_NORECURSE); if (!s) { geterror(); _tprintf (_T("Couldn't open '%s' for reading\n"), src); continue; } zfile_fseek (s, 0, SEEK_END); size = zfile_ftell (s); zfile_fseek (s, 0, SEEK_SET); b = xcalloc (uae_u8, size); if (b) { if (zfile_fread (b, size, 1, s) == 1) { if (out) { _tprintf (_T("\n")); fwrite (b, size, 1, stdout); } else { d = zfile_fopen (dst, _T("wb"), 0); if (d) { if (zfile_fwrite (b, size, 1, d) == 1) { ret = 1; _tprintf (_T("%s extracted, %d bytes\n"), dst, size); } zfile_fclose (d); setdate (dst, st.mtime.tv_sec); } } } xfree (b); } zfile_fclose (s); if (!all) break; } } geterror (); if (!found && !level) { if (filename[0]) _tprintf (_T("'%s' not found\n"), filename); else _tprintf (_T("nothing extracted\n")); } return ret; }
static struct zfile *gunzip (struct zfile *z) { uae_u8 header[2 + 1 + 1 + 4 + 1 + 1]; z_stream zs; int i, size, ret, first; uae_u8 flags; long offset; char name[MAX_DPATH]; uae_u8 buffer[8192]; struct zfile *z2; uae_u8 b; if (!zlib_test ()) return z; strcpy (name, z->name); memset (&zs, 0, sizeof (zs)); memset (header, 0, sizeof (header)); zfile_fread (header, sizeof (header), 1, z); flags = header[3]; if (header[0] != 0x1f && header[1] != 0x8b) return z; if (flags & 2) /* multipart not supported */ return z; if (flags & 32) /* encryption not supported */ return z; if (flags & 4) { /* skip extra field */ zfile_fread (&b, 1, 1, z); size = b; zfile_fread (&b, 1, 1, z); size |= b << 8; zfile_fseek (z, size + 2, SEEK_CUR); } if (flags & 8) { /* get original file name */ i = 0; do { zfile_fread (name + i, 1, 1, z); } while (name[i++]); } if (flags & 16) { /* skip comment */ i = 0; do { zfile_fread (&b, 1, 1, z); } while (b); } offset = zfile_ftell (z); zfile_fseek (z, -4, SEEK_END); zfile_fread (&b, 1, 1, z); size = b; zfile_fread (&b, 1, 1, z); size |= b << 8; zfile_fread (&b, 1, 1, z); size |= b << 16; zfile_fread (&b, 1, 1, z); size |= b << 24; if (size < 8 || size > 10000000) /* safety check */ return z; zfile_fseek (z, offset, SEEK_SET); z2 = zfile_fopen_empty (name, size); if (!z2) return z; zs.next_out = z2->data; zs.avail_out = size; first = 1; do { zs.next_in = buffer; zs.avail_in = sizeof (buffer); zfile_fread (buffer, sizeof (buffer), 1, z); if (first) { if (inflateInit2 (&zs, -MAX_WBITS) != Z_OK) break; first = 0; } ret = inflate (&zs, 0); } while (ret == Z_OK); inflateEnd (&zs); if (ret != Z_STREAM_END || first != 0) { zfile_fclose (z2); return z; } zfile_fclose (z); return z2; }
static void parse_cmdline (int argc, TCHAR **argv) { int i; static bool started; bool firstconfig = true; bool loaded = false; // only parse command line when starting for the first time if (started) return; started = true; for (i = 1; i < argc; i++) { if (!_tcsncmp (argv[i], _T("-diskswapper="), 13)) { TCHAR *txt = parsetextpath (argv[i] + 13); parse_diskswapper (txt); xfree (txt); } else if (_tcsncmp (argv[i], _T("-cfgparam="), 10) == 0) { ; } else if (_tcscmp (argv[i], _T("-cfgparam")) == 0) { if (i + 1 < argc) i++; } else if (_tcsncmp (argv[i], _T("-config="), 8) == 0) { TCHAR *txt = parsetextpath (argv[i] + 8); currprefs.mountitems = 0; target_cfgfile_load (&currprefs, txt, firstconfig ? CONFIG_TYPE_ALL : CONFIG_TYPE_HARDWARE | CONFIG_TYPE_HOST | CONFIG_TYPE_NORESET, 0); xfree (txt); firstconfig = false; loaded = true; } else if (_tcsncmp (argv[i], _T("-statefile="), 11) == 0) { TCHAR *txt = parsetextpath (argv[i] + 11); savestate_state = STATE_DORESTORE; _tcscpy (savestate_fname, txt); xfree (txt); loaded = true; } else if (_tcscmp (argv[i], _T("-f")) == 0) { /* Check for new-style "-f xxx" argument, where xxx is config-file */ if (i + 1 == argc) { write_log (_T("Missing argument for '-f' option.\n")); } else { TCHAR *txt = parsetextpath (argv[++i]); currprefs.mountitems = 0; target_cfgfile_load (&currprefs, txt, firstconfig ? CONFIG_TYPE_ALL : CONFIG_TYPE_HARDWARE | CONFIG_TYPE_HOST | CONFIG_TYPE_NORESET, 0); xfree (txt); firstconfig = false; } loaded = true; } else if (_tcscmp (argv[i], _T("-s")) == 0) { if (i + 1 == argc) write_log (_T("Missing argument for '-s' option.\n")); else cfgfile_parse_line (&currprefs, argv[++i], 0); } else if (_tcscmp (argv[i], _T("-h")) == 0 || _tcscmp (argv[i], _T("-help")) == 0) { usage (); exit (0); } else if (_tcsncmp (argv[i], _T("-cdimage="), 9) == 0) { TCHAR *txt = parsetextpath (argv[i] + 9); TCHAR *txt2 = xmalloc(TCHAR, _tcslen(txt) + 2); _tcscpy(txt2, txt); if (_tcsrchr(txt2, ',') != NULL) _tcscat(txt2, _T(",")); cfgfile_parse_option (&currprefs, _T("cdimage0"), txt2, 0); xfree(txt2); xfree(txt); loaded = true; } else if (argv[i][0] == '-' && argv[i][1] != '\0') { const TCHAR *arg = argv[i] + 2; int extra_arg = *arg == '\0'; if (extra_arg) arg = i + 1 < argc ? argv[i + 1] : 0; if (parse_cmdline_option (&currprefs, argv[i][1], arg) && extra_arg) i++; } else if (i == argc - 1) { // if last config entry is an orphan and nothing else was loaded: // check if it is config file or statefile if (!loaded) { TCHAR *txt = parsetextpath(argv[i]); struct zfile *z = zfile_fopen(txt, _T("rb"), ZFD_NORMAL); if (z) { int type = zfile_gettype(z); zfile_fclose(z); if (type == ZFILE_CONFIGURATION) { currprefs.mountitems = 0; target_cfgfile_load(&currprefs, txt, CONFIG_TYPE_ALL, 0); } else if (type == ZFILE_STATEFILE) { savestate_state = STATE_DORESTORE; _tcscpy(savestate_fname, txt); } } xfree(txt); } } } }
static struct zfile *unzip (struct zfile *z) { unzFile uz; unz_file_info file_info; char filename_inzip[2048]; struct zfile *zf; unsigned int err, zipcnt, i, we_have_file = 0; int select; char tmphist[MAX_DPATH]; int first = 1; if (!zlib_test ()) return z; zf = 0; uz = unzOpen (z); if (!uz) return z; if (unzGoToFirstFile (uz) != UNZ_OK) return z; zipcnt = 1; tmphist[0] = 0; for (;;) { err = unzGetCurrentFileInfo(uz,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); if (err != UNZ_OK) return z; if (file_info.uncompressed_size > 0) { i = 0; while (ignoreextensions[i]) { if (strlen(filename_inzip) > strlen (ignoreextensions[i]) && !strcasecmp (ignoreextensions[i], filename_inzip + strlen (filename_inzip) - strlen (ignoreextensions[i]))) break; i++; } if (!ignoreextensions[i]) { if (tmphist[0]) { DISK_history_add (tmphist, -1); tmphist[0] = 0; first = 0; } if (first) { if (isdiskimage (filename_inzip)) sprintf (tmphist,"%s/%s", z->name, filename_inzip); } else { sprintf (tmphist,"%s/%s", z->name, filename_inzip); DISK_history_add (tmphist, -1); tmphist[0] = 0; } select = 0; if (!z->zipname) select = 1; if (z->zipname && !strcasecmp (z->zipname, filename_inzip)) select = -1; if (z->zipname && z->zipname[0] == '#' && atol (z->zipname + 1) == (int)zipcnt) select = -1; if (select && !we_have_file) { unsigned int err = unzOpenCurrentFile (uz); if (err == UNZ_OK) { zf = zfile_fopen_empty (filename_inzip, file_info.uncompressed_size); if (zf) { err = unzReadCurrentFile (uz, zf->data, file_info.uncompressed_size); unzCloseCurrentFile (uz); if (err == 0 || err == file_info.uncompressed_size) { zf = zuncompress (zf); if (select < 0 || zfile_gettype (zf)) { we_have_file = 1; } } } if (!we_have_file) { zfile_fclose (zf); zf = 0; } } } } } zipcnt++; err = unzGoToNextFile (uz); if (err != UNZ_OK) break; } if (zf) { zfile_fclose (z); z = zf; } return z; }