mirror of
https://github.com/mauiaaron/apple2.git
synced 2024-09-27 09:56:08 +00:00
246 lines
6.4 KiB
C
246 lines
6.4 KiB
C
/*
|
|
* Apple // emulator for *ix
|
|
*
|
|
* This software package is subject to the GNU General Public License
|
|
* version 3 or later (your choice) as published by the Free Software
|
|
* Foundation.
|
|
*
|
|
* Copyright 2013-2015 Aaron Culliney
|
|
*
|
|
*/
|
|
|
|
/* zpipe.c: example of proper use of zlib's inflate() and deflate()
|
|
Not copyrighted -- provided to the public domain
|
|
Version 1.4 11 December 2005 Mark Adler */
|
|
|
|
/* Version history:
|
|
1.0 30 Oct 2004 First version
|
|
1.1 8 Nov 2004 Add void casting for unused return values
|
|
Use switch statement for inflate() return values
|
|
1.2 9 Nov 2004 Add assertions to document zlib guarantees
|
|
1.3 6 Apr 2005 Remove incorrect assertion in inf()
|
|
1.4 11 Dec 2005 Add hack to avoid MSDOS end-of-line conversions
|
|
Avoid some compiler warnings for input and output buffers
|
|
...
|
|
xxx 1 Dec 2013 Added to Apple2ix emulator, replaced assertions with error value returns
|
|
xxx 22 Dec 2013 Switched to gz...() routines for simplicity and to be compatible with gzip
|
|
*/
|
|
|
|
#include "common.h"
|
|
|
|
#ifdef ANDROID
|
|
#warning do newer androids dream of gzbuffer() ?
|
|
// Ugh, why is gzbuffer() symbol not part of zlib.h on Android? I guess maybe we should just go with the published
|
|
// default buffer size? Yay, GJ Goog!
|
|
#define CHUNK 8192
|
|
#else
|
|
#define CHUNK 16384
|
|
#endif
|
|
|
|
/* report a zlib or i/o error */
|
|
static const char* const _gzerr(gzFile gzf) {
|
|
if (gzf == NULL) {
|
|
return NULL;
|
|
}
|
|
int err_num = 0;
|
|
const char *reason = gzerror(gzf, &err_num);
|
|
if (err_num == Z_ERRNO) {
|
|
return strerror(err_num);
|
|
} else {
|
|
return reason;
|
|
}
|
|
}
|
|
|
|
/* Compress some_file to some_file.gz
|
|
*
|
|
* If expected_bytecount > 0, check that byte count written matches expected.
|
|
*
|
|
* Return NULL on success, or error string (possibly from zlib) on failure.
|
|
*/
|
|
const char *zlib_deflate(const char* const src, const int expected_bytecount) {
|
|
unsigned char buf[CHUNK];
|
|
int fd = -1;
|
|
gzFile gzdest = NULL;
|
|
|
|
if (src == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
int bytecount = 0;
|
|
char *err = NULL;
|
|
char dst[PATH_MAX] = { 0 };
|
|
do {
|
|
TEMP_FAILURE_RETRY(fd = open(src, O_RDONLY));
|
|
if (fd == -1) {
|
|
ERRLOG("Cannot open file '%s' for reading", src);
|
|
err = ZERR_DEFLATE_OPEN_SOURCE;
|
|
break;
|
|
}
|
|
|
|
snprintf(dst, PATH_MAX-1, "%s%s", src, EXT_GZ);
|
|
|
|
gzdest = gzopen(dst, "wb");
|
|
if (gzdest == NULL) {
|
|
ERRLOG("Cannot open file '%s' for writing", dst);
|
|
break;
|
|
}
|
|
|
|
#if !defined(ANDROID)
|
|
if (gzbuffer(gzdest, CHUNK) != Z_OK) {
|
|
ERRLOG("Cannot set bufsize on gz output");
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
// deflate ...
|
|
do {
|
|
ssize_t buflen = 0;
|
|
TEMP_FAILURE_RETRY(buflen = read(fd, buf, CHUNK));
|
|
|
|
if (buflen < 0) {
|
|
ERRLOG("OOPS read ...");
|
|
err = ZERR_DEFLATE_READ_SOURCE;
|
|
break;
|
|
} else if (buflen == 0) {
|
|
break; // DONE
|
|
}
|
|
|
|
size_t written = gzwrite(gzdest, buf, buflen);
|
|
if (written < buflen) {
|
|
ERRLOG("OOPS gzwrite ...");
|
|
break;
|
|
}
|
|
bytecount += written;
|
|
} while (1);
|
|
|
|
} while (0);
|
|
|
|
if (expected_bytecount && bytecount != expected_bytecount) {
|
|
ERRLOG("OOPS did not write expected_bytecount of %d ... apparently wrote %d", expected_bytecount, bytecount);
|
|
if (gzdest) {
|
|
err = (char *)_gzerr(gzdest);
|
|
}
|
|
if (!err) {
|
|
err = ZERR_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
// clean up
|
|
|
|
if (fd) {
|
|
TEMP_FAILURE_RETRY(close(fd));
|
|
}
|
|
|
|
if (gzdest) {
|
|
gzclose(gzdest);
|
|
}
|
|
|
|
if (err) {
|
|
unlink(dst);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/* Decompress some_file.gz to some_file
|
|
*
|
|
* If expected_bytecount > 0, check that byte count read matches expected.
|
|
*
|
|
* Return NULL on success, or error string (possibly from zlib) on failure.
|
|
*/
|
|
const char *zlib_inflate(const char* const src, const int expected_bytecount) {
|
|
gzFile gzsource = NULL;
|
|
int fd = -1;
|
|
|
|
if (src == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
int bytecount = 0;
|
|
char *err = NULL;
|
|
char dst[PATH_MAX] = { 0 };
|
|
do {
|
|
gzsource = gzopen(src, "rb");
|
|
if (gzsource == NULL) {
|
|
ERRLOG("Cannot open file '%s' for reading", src);
|
|
break;
|
|
}
|
|
|
|
size_t len = strlen(src);
|
|
snprintf(dst, PATH_MAX-1, "%s", src);
|
|
if (!is_gz(dst)) {
|
|
ERRLOG("Expected filename ending in %s", EXT_GZ);
|
|
break;
|
|
}
|
|
dst[len-3] = '\0';
|
|
|
|
TEMP_FAILURE_RETRY(fd = open(dst, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR));
|
|
if (fd == -1) {
|
|
err = ZERR_INFLATE_OPEN_DEST;
|
|
ERRLOG("Cannot open file '%s' for writing", dst);
|
|
break;
|
|
}
|
|
|
|
// inflate ...
|
|
do {
|
|
unsigned char buf[CHUNK];
|
|
int buflen = gzread(gzsource, buf, CHUNK-1); // hmmm ... valgrind complains of a buffer read overflow in zlib inffast()?
|
|
if (buflen < 0) {
|
|
ERRLOG("OOPS, gzip read ...");
|
|
break;
|
|
} else if (buflen == 0) {
|
|
break; // DONE
|
|
}
|
|
|
|
ssize_t idx = 0;
|
|
size_t chunk = buflen;
|
|
do {
|
|
ssize_t outlen = 0;
|
|
TEMP_FAILURE_RETRY(outlen = write(fd, buf+idx, chunk));
|
|
if (outlen <= 0) {
|
|
break;
|
|
}
|
|
idx += outlen;
|
|
chunk -= outlen;
|
|
} while (idx < buflen);
|
|
|
|
if (idx != buflen) {
|
|
ERRLOG("OOPS, write");
|
|
err = ZERR_INFLATE_WRITE_DEST;
|
|
break;
|
|
}
|
|
|
|
bytecount += buflen;
|
|
} while (1);
|
|
|
|
} while (0);
|
|
|
|
if (expected_bytecount && bytecount != expected_bytecount) {
|
|
ERRLOG("OOPS did not write expected_bytecount of %d ... apparently wrote %d", expected_bytecount, bytecount);
|
|
if (gzsource) {
|
|
err = (char *)_gzerr(gzsource);
|
|
}
|
|
if (!err) {
|
|
err = ZERR_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
// clean up
|
|
|
|
if (gzsource) {
|
|
gzclose(gzsource);
|
|
}
|
|
|
|
if (fd) {
|
|
TEMP_FAILURE_RETRY(fsync(fd));
|
|
TEMP_FAILURE_RETRY(close(fd));
|
|
}
|
|
|
|
if (err) {
|
|
unlink(dst);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|