char *zlib_decompress_file(const char *filename, off_t *r_size)
{
gzFile fp;
int errnum;
const char *msg;
char *buf;
off_t size = 0, allocated;
ssize_t result;
dbgprintf("Try gzip decompression.\n");
*r_size = 0;
if (!filename) {
return NULL;
}
fp = gzopen(filename, "rb");
if (fp == 0) {
_gzerror(fp, &errnum, &msg);
dbgprintf("Cannot open `%s': %s\n", filename, msg);
return NULL;
}
if (gzdirect(fp)) {
/* It's not in gzip format */
return NULL;
}
allocated = 65536;
buf = xmalloc(allocated);
do {
if (size == allocated) {
allocated <<= 1;
buf = xrealloc(buf, allocated);
}
result = gzread(fp, buf + size, allocated - size);
if (result < 0) {
if ((errno == EINTR) || (errno == EAGAIN))
continue;
_gzerror(fp, &errnum, &msg);
dbgprintf("Read on %s of %ld bytes failed: %s\n",
filename, (allocated - size) + 0UL, msg);
size = 0;
goto fail;
}
size += result;
} while(result > 0);
fail:
result = gzclose(fp);
if (result != Z_OK) {
_gzerror(fp, &errnum, &msg);
dbgprintf(" Close of %s failed: %s\n", filename, msg);
}
if (size > 0) {
*r_size = size;
} else {
free(buf);
buf = NULL;
}
return buf;
}
static size_t io_get_file_size(char *filename) {
gzFile FILE;
size_t size;
FILE = gzopen(filename, "r");
if (FILE == NULL) {
return(0);
}
if (gzdirect(FILE) == 1) {
gzclose(FILE);
size = io_get_regular_file_size(filename);
} else {
gzclose(FILE);
size = io_get_gz_file_size(filename);
}
return(size);
}
bool CGZIPFile::Open(LPCTSTR pszFilePath)
{
ASSERT( m_gzFile == 0 );
Close();
m_gzFile = gzopen(CT2CA(pszFilePath), "rb");
if (m_gzFile)
{
// Use gzip-uncompress only for real gzip-compressed files and do not let handle it also uncompressed files.
// This way the 'Open' function can be used to check if that file is a 'gzip' file at all.
if (gzdirect(m_gzFile) != 0)
Close();
else
m_strGzFilePath = pszFilePath;
}
return m_gzFile != 0;
}
/**
* Try to uncompress a file. Return immidiately if it is not compressed. Otherwise
* uncompress it to a temporary file and return the (temporary) filename in lpsOutfile.
* The filename is returned in an internal static buffer. Thus any subsequent
* calls destroy the value.<code>free</code> does not need to be called to
* deallocate this pointer
*
* @param lpsInfile
* Pointer to filename of input file
* @param lpsInfile
* Pointer to filename of output file
* @return <code>TRUE</code> if file has been uncompressed, <code>FALSE</code> otherwise.
*/
BOOL dlp_funzip(const char *lpsInfile,char const **lpsOutfile)
{
#ifndef __NOZLIB
char lpsFile[L_PATH];
char lpsDir[L_PATH];
BOOL bSuccess = TRUE;
FILE *lpOutfile = NULL;
gzFile lpInfile = NULL;
/* Do nothing if file is not compressed */
lpInfile = gzopen(lpsInfile, "rb");
if (!lpInfile) return FALSE;
if (gzdirect(lpInfile))
{
gzclose(lpInfile);
return FALSE;
}
/* Create and open temporary output file */
dlp_splitpath(lpsInfile,lpsDir,lpsFile);
*lpsOutfile = dlp_tempnam(NULL,lpsFile);
lpOutfile = fopen(*lpsOutfile, "wb");
if (lpOutfile == NULL)
{
perror(*lpsOutfile);
gzclose(lpInfile);
unlink(*lpsOutfile);
return FALSE;
}
bSuccess = gz_uncompress(lpInfile, lpOutfile);
if(!bSuccess)
{
unlink(*lpsOutfile);
*lpsOutfile=lpsInfile;
return FALSE;
}
return TRUE;
#else /* __NOZLIB */
return FALSE;
#endif
}
static int demofile_read_fileheader(demofile_t* d, demo_vardef_t* vars, const char* filename) {
int i, pos, nvars;
demo_vardef_t *cvardef, *lastvardef;
vartrack_t* cvartrack;
Uint8 hdr[8];
char name[256];
d->gzfil = gzopen(filename, "rb9");
if (!d->gzfil) return 0;
d->compressed = !gzdirect(d->gzfil);
if (demofile_read(d, hdr, 8) < 8)
return 0;
if (memcmp(hdr, "KENDEMO", 7) != 0)
return 0;
d->format = hdr[7];
if (d->format > 1)
return 0;
if (demofile_read(d, hdr, 4) < 4)
return 0;
nvars = get16(hdr);
d->buffer_size = get16(hdr + 2);
if (nvars == 0)
return 0;
cvartrack = d->vars = (vartrack_t*)malloc(nvars * sizeof(vartrack_t));
if (!cvartrack) return 0;
memset(cvartrack, 0, nvars * sizeof(vartrack_t));
cvardef = vars - 1;
pos = 0;
d->nvars = 0;
i = nvars;
do {
int cnt, elemsize;
if (demofile_read(d, hdr, 4) < 4) {
fprintf(stderr, "%s: truncated (%d)\n", filename, d->nvars);
return 0;
}
if (demofile_read(d, name, hdr[0]) < hdr[0]) {
fprintf(stderr, "%s: truncated\n", filename);
return 0;
}
name[hdr[0]] = 0;
lastvardef = cvardef;
elemsize = hdr[1];
cnt = get16(hdr + 2);
if (cnt == 0)
return 0;
/* Alignment & size check */
switch(elemsize) {
case 1: break;
case 2: pos = (pos + 1) & ~1; break;
case 4: pos = (pos + 3) & ~3; break;
case 8: pos = (pos + 7) & ~7; break;
default:
fprintf(stderr, "%s: invalid size for variable '%s': %d\n", filename, name, elemsize);
return 0;
}
/* Most likely scenario is that the variables from the demo are in the
* same order as the variables we have here - so it's likely to match
* the next demo_vardef_t.*/
do {
if (!(++cvardef)->name) cvardef = vars;
} while (cvardef != lastvardef && !(strcmp(name, cvardef->name) == 0 && cvardef->elemsize == elemsize));
if (cvardef == lastvardef) {
fprintf(stderr, "%s: WARNING: unknown variable %s\n", filename, name);
} else {
cvartrack->ptr = cvardef->ptr;
cvartrack->pos = pos;
cvartrack->elemsize = elemsize;
cvartrack->cnt = cnt;
if (cnt > cvardef->cnt) {
fprintf(stderr, "%s: WARNING: array exceeds buffer space %s[%d], alloc = %d\n", filename, name, cnt, cvardef->cnt);
cvartrack->cnt = cvardef->cnt;
}
cvartrack++;
d->nvars++;
}
pos += cnt * elemsize;
if (pos > d->buffer_size) {
fprintf(stderr, "%s: ERROR: variable %s extends beyond buffer size\n", filename, name);
return 0;
}
} while (--i);
if (d->format == 1) {
demofile_read(d, hdr, 2);
}
/* Align the buffers on a 64-bit boundary so bulk XOR can use 64-bit operations */
pos = (d->buffer_size + 7) & ~7;
d->cur_data = malloc(pos * 3);
if (!d->cur_data) return 0;
memset(d->cur_data, 0, pos);
d->delta_buf = d->cur_data + pos;
d->rle_buf = d->delta_buf + pos;
return 1;
}
/**
* Insert a file into the buffer at the point.
* Leaves the point at the start of the inserted file.
* @param buff The buffer to read the file into.
* @param fname The file to read.
* @param[out] compressed Was the file compressed? Only if ZLIB enabled. Can be NULL.
* @return 0 on success, -1 on file error, 1 on zlib error.
*/
int breadfile(struct buff *buff, const char *fname, int *compressed)
{
char buf[PGSIZE];
struct mark start;
int fd, len;
fd = open(fname, O_RDONLY | O_BINARY);
if (fd < 0)
return -errno;
#if ZLIB
gzFile gz = gzdopen(fd, "rb");
if (!gz) {
close(fd);
return 1;
}
if (compressed)
*compressed = gzdirect(gz) == 0;
#else
if (compressed)
*compressed = 0;
#endif
/* Deal with point in the middle of a page. */
if (curplen(buff) && buff->curchar < PGSIZE) {
pagesplit(buff, buff->curchar);
if (!newpage(buff->curpage))
return -ENOMEM;
makecur(buff, buff->curpage->nextp, 0);
}
bmrktopnt(buff, &start);
while ((len = fileread(fd, buf, PGSIZE)) > 0) {
if (curplen(buff)) {
if (!newpage(buff->curpage)) {
fileclose(fd);
return -ENOMEM;
}
makecur(buff, buff->curpage->nextp, 0);
}
memcpy(buff->curcptr, buf, len);
curplen(buff) = len;
}
fileclose(fd);
bpnttomrk(buff, &start);
#if ZLIB
/* Ubuntu 12.04 has a bug where zero length files are reported as
* compressed.
*/
if (compressed && curplen(buff) == 0)
*compressed = 0;
#endif
buff->bmodf = 0;
return 0;
}
