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 hdf_read_2 (struct hardfiledata *hfd, void *buffer, uae_u64 offset, int len)
{
long outlen = 0;
int coffset;
if (offset == 0)
hfd->cache_valid = 0;
coffset = isincache (hfd, offset, len);
if (coffset >= 0) {
memcpy (buffer, hfd->cache + coffset, len);
return len;
}
hfd->cache_offset = offset;
if (offset + CACHE_SIZE > hfd->offset + (hfd->physsize - hfd->virtual_size))
hfd->cache_offset = hfd->offset + (hfd->physsize - hfd->virtual_size) - CACHE_SIZE;
hdf_seek (hfd, hfd->cache_offset);
poscheck (hfd, CACHE_SIZE);
if (hfd->handle_valid == HDF_HANDLE_LINUX)
outlen = fread (hfd->cache, 1, CACHE_SIZE, hfd->handle->h);
else if (hfd->handle_valid == HDF_HANDLE_ZFILE)
outlen = zfile_fread (hfd->cache, 1, CACHE_SIZE, hfd->handle->zf);
hfd->cache_valid = 0;
if (outlen != CACHE_SIZE)
return 0;
hfd->cache_valid = 1;
coffset = isincache (hfd, offset, len);
if (coffset >= 0) {
memcpy (buffer, hfd->cache + coffset, len);
return len;
}
write_log ("hdf_read: cache bug! offset=0x%llx len=%d\n", offset, len);
hfd->cache_valid = 0;
return 0;
}
/*
Get the global comment string of the ZipFile, in the szComment buffer.
uSizeBuf is the size of the szComment buffer.
return the number of byte copied or an error code <0
*/
extern int ZEXPORT unzGetGlobalComment (unzFile file, char *szComment, uLong uSizeBuf)
{
// int err=UNZ_OK;
unz_s* s;
uLong uReadThis ;
if (file==NULL)
return UNZ_PARAMERROR;
s=(unz_s*)file;
uReadThis = uSizeBuf;
if (uReadThis>s->gi.size_comment)
uReadThis = s->gi.size_comment;
if (zfile_fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
return UNZ_ERRNO;
if (uReadThis>0)
{
*szComment='\0';
if (zfile_fread(szComment,(uInt)uReadThis,1,s->file)!=1)
return UNZ_ERRNO;
}
if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
*(szComment+s->gi.size_comment)='\0';
return (int)uReadThis;
}
int zfile_zuncompress (void *dst, int dstsize, struct zfile *src, int srcsize)
{
z_stream zs;
int v;
uae_u8 inbuf[4096];
int incnt;
if (!zlib_test ())
return 0;
memset (&zs, 0, sizeof(zs));
if (inflateInit (&zs) != Z_OK)
return 0;
zs.next_out = dst;
zs.avail_out = dstsize;
incnt = 0;
v = Z_OK;
while (v == Z_OK && zs.avail_out > 0) {
if (zs.avail_in == 0) {
int left = srcsize - incnt;
if (left == 0)
break;
if (left > (int)sizeof (inbuf)) left = sizeof (inbuf);
zs.next_in = inbuf;
zs.avail_in = zfile_fread (inbuf, 1, left, src);
incnt += left;
}
v = inflate (&zs, 0);
}
inflateEnd (&zs);
return 0;
}
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 FLAC__StreamDecoderReadStatus file_read_callback (const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
{
struct cdtoc *t = (struct cdtoc*)client_data;
if (zfile_ftell (t->handle) >= zfile_size (t->handle))
return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
return zfile_fread (buffer, *bytes, 1, t->handle) ? FLAC__STREAM_DECODER_READ_STATUS_CONTINUE : FLAC__STREAM_DECODER_READ_STATUS_ABORT;
}
int caps_loadimage (struct zfile *zf, unsigned int drv, unsigned int *num_tracks)
{
struct CapsImageInfo ci;
int len, ret;
uae_u8 *buf;
char s1[100];
struct CapsDateTimeExt *cdt;
if (!caps_init ())
return 0;
caps_unloadimage (drv);
zfile_fseek (zf, 0, SEEK_END);
len = zfile_ftell (zf);
zfile_fseek (zf, 0, SEEK_SET);
buf = xmalloc (uae_u8, len);
if (!buf)
return 0;
if (zfile_fread (buf, len, 1, zf) == 0)
return 0;
ret = CAPSLockImageMemory (caps_cont[drv], buf, len, 0);
xfree (buf);
if (ret != imgeOk)
return 0;
caps_locked[drv] = 1;
CAPSGetImageInfo (&ci, caps_cont[drv]);
*num_tracks = (ci.maxcylinder - ci.mincylinder + 1) * (ci.maxhead - ci.minhead + 1);
CAPSLoadImage (caps_cont[drv], caps_flags);
cdt = &ci.crdt;
sprintf (s1, "%d.%d.%d %d:%d:%d", cdt->day, cdt->month, cdt->year, cdt->hour, cdt->min, cdt->sec);
write_log ("CAPS: type:%d date:%s rel:%d rev:%d\n",
ci.type, s1, ci.release, ci.revision);
return 1;
}
int caps_loadimage (struct zfile *zf, int drv, int *num_tracks)
{
static int notified;
struct CapsImageInfo ci;
int len, ret;
uae_u8 *buf;
TCHAR s1[100];
struct CapsDateTimeExt *cdt;
if (!caps_init ())
return 0;
caps_unloadimage (drv);
zfile_fseek (zf, 0, SEEK_END);
len = zfile_ftell (zf);
zfile_fseek (zf, 0, SEEK_SET);
buf = xmalloc (uae_u8, len);
if (!buf)
return 0;
if (zfile_fread (buf, len, 1, zf) == 0)
return 0;
ret = pCAPSLockImageMemory (caps_cont[drv], buf, len, 0);
xfree (buf);
if (ret != imgeOk) {
if (ret == imgeIncompatible || ret == imgeUnsupported) {
if (!notified)
notify_user (NUMSG_OLDCAPS);
notified = 1;
}
write_log (L"caps: CAPSLockImageMemory() returned %d\n", ret);
return 0;
}
caps_locked[drv] = 1;
ret = pCAPSGetImageInfo(&ci, caps_cont[drv]);
*num_tracks = (ci.maxcylinder - ci.mincylinder + 1) * (ci.maxhead - ci.minhead + 1);
if (cvi.release < 4) { // pre-4.x bug workaround
struct CapsTrackInfoT1 cit;
cit.type = 1;
if (pCAPSLockTrack ((PCAPSTRACKINFO)&cit, caps_cont[drv], 0, 0, caps_flags) == imgeIncompatible) {
if (!notified)
notify_user (NUMSG_OLDCAPS);
notified = 1;
caps_unloadimage (drv);
return 0;
}
pCAPSUnlockAllTracks (caps_cont[drv]);
}
ret = pCAPSLoadImage(caps_cont[drv], caps_flags);
cdt = &ci.crdt;
_stprintf (s1, L"%d.%d.%d %d:%d:%d", cdt->day, cdt->month, cdt->year, cdt->hour, cdt->min, cdt->sec);
write_log (L"caps: type:%d date:%s rel:%d rev:%d\n",
ci.type, s1, ci.release, ci.revision);
return 1;
}
static int do_read (struct cdunit *cdu, struct cdtoc *t, uae_u8 *data, int sector, int offset, int size)
{
if (t->enctype == ENC_CHD) {
return read_partial_sector(cdu->chd_cdf, data, sector + t->offset, 0, offset, size) == CHDERR_NONE;
} else if (t->handle) {
int ssize = t->size + t->skipsize;
zfile_fseek (t->handle, t->offset + (uae_u64)sector * ssize + offset, SEEK_SET);
return zfile_fread (data, 1, size, t->handle) == size;
}
return 0;
}
/*
Locate the Central directory of a zipfile (at the end, just before
the global comment)
*/
local uLong unzlocal_SearchCentralDir(struct zfile *fin)
{
unsigned char* buf;
uLong uSizeFile;
uLong uBackRead;
uLong uMaxBack=0xffff; /* maximum size of global comment */
uLong uPosFound=0;
if (zfile_fseek(fin,0,SEEK_END) != 0)
return 0;
uSizeFile = zfile_ftell( fin );
if (uMaxBack>uSizeFile)
uMaxBack = uSizeFile;
buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
if (buf==NULL)
return 0;
uBackRead = 4;
while (uBackRead<uMaxBack)
{
uLong uReadSize,uReadPos ;
int i;
if (uBackRead+BUFREADCOMMENT>uMaxBack)
uBackRead = uMaxBack;
else
uBackRead+=BUFREADCOMMENT;
uReadPos = uSizeFile-uBackRead ;
uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
(BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
if (zfile_fseek(fin,uReadPos,SEEK_SET)!=0)
break;
if (zfile_fread(buf,(uInt)uReadSize,1,fin)!=1)
break;
for (i=(int)uReadSize-3; (i--)>0;)
if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
{
uPosFound = uReadPos+i;
break;
}
if (uPosFound!=0)
break;
}
TRYFREE(buf);
return uPosFound;
}
inline void chd_file::file_read(UINT64 offset, void *dest, UINT32 length)
{
// no file = failure
if (m_file == NULL)
throw CHDERR_NOT_OPEN;
// seek and read
zfile_fseek(m_file, offset, SEEK_SET);
UINT32 count = zfile_fread(dest, 1, length, m_file);
if (count != length)
throw CHDERR_READ_ERROR;
}
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;
}
int32_t inprec_open(char *fname, int32_t record)
{
uint32_t t = (uint32_t)time(0);
int32_t i;
inprec_close();
inprec_zf = zfile_fopen(fname, record > 0 ? "wb" : "rb");
if (inprec_zf == NULL)
return 0;
inprec_size = 10000;
inprec_div = 1;
if (record < 0) {
uint32_t id;
zfile_fseek (inprec_zf, 0, SEEK_END);
inprec_size = zfile_ftell (inprec_zf);
zfile_fseek (inprec_zf, 0, SEEK_SET);
inprec_buffer = inprec_p = (uint8_t*)xmalloc (inprec_size);
zfile_fread (inprec_buffer, inprec_size, 1, inprec_zf);
inprec_plastptr = inprec_buffer;
id = inprec_pu32();
if (id != 'UAE\0') {
inprec_close();
return 0;
}
inprec_pu32();
t = inprec_pu32();
i = inprec_pu32();
while (i-- > 0)
inprec_pu8();
inprec_p = inprec_plastptr;
oldbuttons[0] = oldbuttons[1] = oldbuttons[2] = oldbuttons[3] = 0;
oldjoy[0] = oldjoy[1] = 0;
if (record < -1)
inprec_div = maxvpos;
} else if (record > 0) {
inprec_buffer = inprec_p = (uint8_t*)xmalloc (inprec_size);
inprec_ru32('UAE\0');
inprec_ru8(1);
inprec_ru8(UAEMAJOR);
inprec_ru8(UAEMINOR);
inprec_ru8(UAESUBREV);
inprec_ru32(t);
inprec_ru32(0); // extra header size
} else {
return 0;
}
input_recording = record;
srand(t);
CIA_inprec_prepare();
write_log ("inprec initialized '%s', mode=%d\n", fname, input_recording);
return 1;
}
local int unzlocal_getByte(struct zfile *fin,int32_t *pi)
{
uint8_t c;
int32_t err = zfile_fread(&c, 1, 1, fin);
if (err==1)
{
*pi = (int32_t)c;
return UNZ_OK;
}
else
{
return UNZ_EOF;
}
}
local int unzlocal_getByte(struct zfile *fin,int *pi)
{
unsigned char c;
int err = zfile_fread(&c, 1, 1, fin);
if (err==1)
{
*pi = (int)c;
return UNZ_OK;
}
else
{
return UNZ_EOF;
}
}
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;
}
static int getsub_deinterleaved (uae_u8 *dst, struct cdunit *cdu, struct cdtoc *t, int sector)
{
int ret = 0;
uae_sem_wait (&cdu->sub_sem);
if (t->subcode) {
if (t->enctype == ENC_CHD) {
const cdrom_track_info *cti = t->chdtrack;
ret = do_read (cdu, t, dst, sector, cti->datasize, cti->subsize);
if (ret)
ret = t->subcode;
} else if (t->subhandle) {
int offset = 0;
int totalsize = SUB_CHANNEL_SIZE;
if (t->skipsize) {
totalsize += t->size;
offset = t->size;
}
zfile_fseek (t->subhandle, (uae_u64)sector * totalsize + t->suboffset + offset, SEEK_SET);
if (zfile_fread (dst, SUB_CHANNEL_SIZE, 1, t->subhandle) > 0)
ret = t->subcode;
} else {
memcpy (dst, t->subdata + sector * SUB_CHANNEL_SIZE + t->suboffset, SUB_CHANNEL_SIZE);
ret = t->subcode;
}
}
if (!ret) {
memset (dst, 0, SUB_CHANNEL_SIZE);
// regenerate Q-subchannel
uae_u8 *s = dst + 12;
s[0] = (t->ctrl << 4) | (t->adr << 0);
s[1] = tobcd (t - &cdu->toc[0] + 1);
s[2] = tobcd (1);
int msf = lsn2msf (sector);
tolongbcd (s + 7, msf);
msf = lsn2msf (sector - t->address - 150);
tolongbcd (s + 3, msf);
ret = 2;
}
if (ret == 1) {
uae_u8 tmp[SUB_CHANNEL_SIZE];
memcpy (tmp, dst, SUB_CHANNEL_SIZE);
sub_to_deinterleaved (tmp, dst);
ret = 2;
}
uae_sem_post (&cdu->sub_sem);
return ret;
}
static void *cdda_unpack_func (void *v)
{
cdimage_unpack_thread = 1;
mp3decoder *mp3dec = NULL;
for (;;) {
uae_u32 cduidx = read_comm_pipe_u32_blocking (&unpack_pipe);
if (cdimage_unpack_thread == 0)
break;
uae_u32 tocidx = read_comm_pipe_u32_blocking (&unpack_pipe);
struct cdunit *cdu = &cdunits[cduidx];
struct cdtoc *t = &cdu->toc[tocidx];
if (t->handle) {
// force unpack if handle points to delayed zipped file
uae_s64 pos = zfile_ftell (t->handle);
zfile_fseek (t->handle, -1, SEEK_END);
uae_u8 b;
zfile_fread (&b, 1, 1, t->handle);
zfile_fseek (t->handle, pos, SEEK_SET);
if (!t->data && (t->enctype == AUDENC_MP3 || t->enctype == AUDENC_FLAC)) {
t->data = xcalloc (uae_u8, t->filesize + 2352);
cdimage_unpack_active = 1;
if (t->data) {
if (t->enctype == AUDENC_MP3) {
if (!mp3dec) {
try {
mp3dec = new mp3decoder();
} catch (exception) { };
}
if (mp3dec)
t->data = mp3dec->get (t->handle, t->data, t->filesize);
} else if (t->enctype == AUDENC_FLAC) {
flac_get_data (t);
}
}
}
}
cdimage_unpack_active = 2;
}
delete mp3dec;
cdimage_unpack_thread = -1;
return 0;
}
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);
}
int hdf_read_target (struct hardfiledata *hfd, void *buffer, uae_u64 offset, int len)
{
int got = 0;
uae_u8 *p = (uae_u8*)buffer;
if (hfd->drive_empty)
return 0;
if (offset < hfd->virtual_size) {
uae_u64 len2 = offset + len <= hfd->virtual_size ? len : hfd->virtual_size - offset;
if (!hfd->virtual_rdb)
return 0;
memcpy (buffer, hfd->virtual_rdb + offset, len2);
return len2;
}
offset -= hfd->virtual_size;
while (len > 0) {
int maxlen;
int ret = 0;
if (hfd->physsize < CACHE_SIZE) {
hfd->cache_valid = 0;
hdf_seek (hfd, offset);
poscheck (hfd, len);
if (hfd->handle_valid == HDF_HANDLE_LINUX) {
ret = fread (hfd->cache, 1, len, hfd->handle->h);
memcpy (buffer, hfd->cache, ret);
} else if (hfd->handle_valid == HDF_HANDLE_ZFILE) {
ret = zfile_fread (buffer, 1, len, hfd->handle->zf);
}
maxlen = len;
} else {
maxlen = len > CACHE_SIZE ? CACHE_SIZE : len;
ret = hdf_read_2 (hfd, p, offset, maxlen);
}
got += ret;
if (ret != maxlen)
return got;
offset += maxlen;
p += maxlen;
len -= maxlen;
}
return got;
}
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);
}
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;
}
int zfile_gettype (struct zfile *z)
{
uae_u8 buf[8];
char *ext;
if (!z)
return ZFILE_UNKNOWN;
ext = strrchr (z->name, '.');
if (ext != NULL) {
ext++;
if (strcasecmp (ext, "adf") == 0)
return ZFILE_DISKIMAGE;
if (strcasecmp (ext, "adz") == 0)
return ZFILE_DISKIMAGE;
if (strcasecmp (ext, "roz") == 0)
return ZFILE_ROM;
if (strcasecmp (ext, "ipf") == 0)
return ZFILE_DISKIMAGE;
if (strcasecmp (ext, "fdi") == 0)
return ZFILE_DISKIMAGE;
if (strcasecmp (ext, "uss") == 0)
return ZFILE_STATEFILE;
if (strcasecmp (ext, "dms") == 0)
return ZFILE_DISKIMAGE;
if (strcasecmp (ext, "rom") == 0)
return ZFILE_ROM;
if (strcasecmp (ext, "key") == 0)
return ZFILE_KEY;
if (strcasecmp (ext, "nvr") == 0)
return ZFILE_NVR;
if (strcasecmp (ext, "uae") == 0)
return ZFILE_CONFIGURATION;
}
memset (buf, 0, sizeof (buf));
zfile_fread (buf, 8, 1, z);
zfile_fseek (z, -8, SEEK_CUR);
if (!memcmp (buf, exeheader, sizeof(buf)))
return ZFILE_DISKIMAGE;
return ZFILE_UNKNOWN;
}
/*
Read extra field from the current file (opened by unzOpenCurrentFile)
This is the local-header version of the extra field (sometimes, there is
more info in the local-header version than in the central-header)
if buf==NULL, it return the size of the local extra field that can be read
if buf!=NULL, len is the size of the buffer, the extra header is copied in
buf.
the return value is the number of bytes copied in buf, or (if <0)
the error code
*/
extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned int len)
{
unz_s* s;
file_in_zip_read_info_s* pfile_in_zip_read_info;
uInt read_now;
uLong size_to_read;
if (file==NULL)
return UNZ_PARAMERROR;
s=(unz_s*)file;
pfile_in_zip_read_info=s->pfile_in_zip_read;
if (pfile_in_zip_read_info==NULL)
return UNZ_PARAMERROR;
size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
pfile_in_zip_read_info->pos_local_extrafield);
if (buf==NULL)
return (int)size_to_read;
if (len>size_to_read)
read_now = (uInt)size_to_read;
else
read_now = (uInt)len ;
if (read_now==0)
return 0;
if (zfile_fseek(pfile_in_zip_read_info->file,
pfile_in_zip_read_info->offset_local_extrafield +
pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
return UNZ_ERRNO;
if (zfile_fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
return UNZ_ERRNO;
return (int)read_now;
}
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;
}
struct romdata *getromdatabyzfile (struct zfile *f)
{
int pos, size;
uae_u8 *p;
struct romdata *rd;
pos = zfile_ftell (f);
zfile_fseek (f, 0, SEEK_END);
size = zfile_ftell (f);
if (size > 2048 * 1024)
return NULL;
p = xmalloc (uae_u8, size);
if (!p)
return NULL;
memset (p, 0, size);
zfile_fseek (f, 0, SEEK_SET);
zfile_fread (p, 1, size, f);
zfile_fseek (f, pos, SEEK_SET);
rd = getromdatabydata (p, size);
xfree (p);
return rd;
}
struct zfile *archive_access_lha (struct znode *zn)
{
struct zfile *zf = zn->volume->archive;
struct zfile *out = zfile_fopen_empty (zf, zn->name, zn->size);
struct interfacing lhinterface;
zfile_fseek(zf, zn->offset, SEEK_SET);
lhinterface.method = zn->method;
lhinterface.dicbit = 13; /* method + 8; -lh5- */
lhinterface.infile = zf;
lhinterface.outfile = out;
lhinterface.original = zn->size;
lhinterface.packed = zn->packedsize;
switch (zn->method) {
case LZHUFF0_METHOD_NUM:
case LARC4_METHOD_NUM:
zfile_fread(out->data, zn->size, 1, zf);
break;
case LARC_METHOD_NUM: /* -lzs- */
lhinterface.dicbit = 11;
decode(&lhinterface);
break;
case LZHUFF1_METHOD_NUM: /* -lh1- */
case LZHUFF4_METHOD_NUM: /* -lh4- */
case LARC5_METHOD_NUM: /* -lz5- */
lhinterface.dicbit = 12;
decode(&lhinterface);
break;
case LZHUFF6_METHOD_NUM: /* -lh6- */ /* Added N.Watazaki (^_^) */
case LZHUFF7_METHOD_NUM: /* -lh7- */
lhinterface.dicbit = (zn->method - LZHUFF6_METHOD_NUM) + 15;
default:
decode(&lhinterface);
}
return out;
}
uae_u32 zfile_crc32 (struct zfile *f)
{
uae_u8 *p;
int pos, size;
uae_u32 crc;
if (!f)
return 0;
if (f->data)
return get_crc32 (f->data, f->size);
pos = zfile_ftell (f);
zfile_fseek (f, 0, SEEK_END);
size = zfile_ftell (f);
p = xmalloc (size);
if (!p)
return 0;
memset (p, 0, size);
zfile_fseek (f, 0, SEEK_SET);
zfile_fread (p, 1, size, f);
zfile_fseek (f, pos, SEEK_SET);
crc = get_crc32 (p, size);
free (p);
return crc;
}
static struct zfile *zuncompress (struct zfile *z)
{
char *name = z->name;
char *ext = strrchr (name, '.');
uae_u8 header[4];
if (ext != NULL) {
ext++;
if (strcasecmp (ext, "zip") == 0 && zlib_test ())
return unzip (z);
if (strcasecmp (ext, "gz") == 0)
return gunzip (z);
if (strcasecmp (ext, "adz") == 0)
// thinkp adz-file support
return unzip (z);
// thinkp adz-file support
if (strcasecmp (ext, "roz") == 0)
return gunzip (z);
if (strcasecmp (ext, "dms") == 0)
return dms (z);
if (strcasecmp (ext, "lha") == 0
|| strcasecmp (ext, "lzh") == 0)
return lha (z);
memset (header, 0, sizeof (header));
zfile_fseek (z, 0, SEEK_SET);
zfile_fread (header, sizeof (header), 1, z);
zfile_fseek (z, 0, SEEK_SET);
if (header[0] == 0x1f && header[1] == 0x8b)
return gunzip (z);
if (header[0] == 'P' && header[1] == 'K')
return unzip (z);
if (header[0] == 'D' && header[1] == 'M' && header[2] == 'S' && header[3] == '!')
return dms (z);
}
return z;
}
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;
}