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