/*--------------------------------------------------------------------------*/
int mem_compress_stdin_open(char *filename, int rwmode, int *hdl)
/*
This routine reads the compressed input stream and creates an empty memory
buffer, then calls mem_uncompress2mem.
*/
{
int status;
char *ptr;
if (rwmode != READONLY)
{
ffpmsg(
"cannot open compressed input stream with WRITE access (mem_compress_stdin_open)");
return(READONLY_FILE);
}
/* create a memory file for the uncompressed file */
status = mem_createmem(28800, hdl);
if (status)
{
ffpmsg("failed to create empty memory file (compress_stdin_open)");
return(status);
}
/* uncompress file into memory */
status = mem_uncompress2mem(filename, stdin, *hdl);
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to uncompress stdin into memory (compress_stdin_open)");
return(status);
}
/* if we allocated too much memory initially, then free it */
if (*(memTable[*hdl].memsizeptr) >
(( (size_t) memTable[*hdl].fitsfilesize) + 256L) )
{
ptr = realloc(*(memTable[*hdl].memaddrptr),
memTable[*hdl].fitsfilesize);
if (!ptr)
{
ffpmsg("Failed to reduce size of allocated memory (compress_stdin_open)");
return(MEMORY_ALLOCATION);
}
*(memTable[*hdl].memaddrptr) = ptr;
*(memTable[*hdl].memsizeptr) = memTable[*hdl].fitsfilesize;
}
return(0);
}
/*--------------------------------------------------------------------------*/
int mem_compress_open(char *filename, int rwmode, int *hdl)
/*
This routine opens the compressed diskfile and creates an empty memory
buffer with an appropriate size, then calls mem_uncompress2mem.
*/
{
FILE *diskfile;
int status, estimated = 1;
unsigned char buffer[4];
size_t finalsize;
char *ptr;
if (rwmode != READONLY)
{
ffpmsg(
"cannot open compressed file with WRITE access (mem_compress_open)");
ffpmsg(filename);
return(READONLY_FILE);
}
/* open the compressed disk file */
status = file_openfile(filename, READONLY, &diskfile);
if (status)
{
ffpmsg("failed to open compressed disk file (compress_open)");
ffpmsg(filename);
return(status);
}
if (fread(buffer, 1, 2, diskfile) != 2) /* read 2 bytes */
{
fclose(diskfile);
return(READ_ERROR);
}
if (memcmp(buffer, "\037\213", 2) == 0) /* GZIP */
{
/* the uncompressed file size is give at the end of the file */
fseek(diskfile, 0, 2); /* move to end of file */
fseek(diskfile, -4L, 1); /* move back 4 bytes */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
finalsize = buffer[0];
finalsize |= buffer[1] << 8;
finalsize |= buffer[2] << 16;
finalsize |= buffer[3] << 24;
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\120\113", 2) == 0) /* PKZIP */
{
/* the uncompressed file size is give at byte 22 the file */
fseek(diskfile, 22L, 0); /* move to byte 22 */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
finalsize = buffer[0];
finalsize |= buffer[1] << 8;
finalsize |= buffer[2] << 16;
finalsize |= buffer[3] << 24;
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\037\036", 2) == 0) /* PACK */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\235", 2) == 0) /* LZW */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\240", 2) == 0) /* LZH */
finalsize = 0; /* for most methods we can't determine final size */
else
{
/* not a compressed file; this should never happen */
fclose(diskfile);
return(1);
}
if (finalsize == 0) /* estimate uncompressed file size */
{
fseek(diskfile, 0, 2); /* move to end of the compressed file */
finalsize = ftell(diskfile); /* position = size of file */
finalsize = finalsize * 3; /* assume factor of 3 compression */
}
fseek(diskfile, 0, 0); /* move back to beginning of file */
/* create a memory file big enough (hopefully) for the uncompressed file */
status = mem_createmem(finalsize, hdl);
if (status && estimated)
{
/* memory allocation failed, so try a smaller estimated size */
finalsize = finalsize / 3;
status = mem_createmem(finalsize, hdl);
}
if (status)
{
fclose(diskfile);
ffpmsg("failed to create empty memory file (compress_open)");
return(status);
}
/* uncompress file into memory */
status = mem_uncompress2mem(filename, diskfile, *hdl);
fclose(diskfile);
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to uncompress file into memory (compress_open)");
return(status);
}
/* if we allocated too much memory initially, then free it */
if (*(memTable[*hdl].memsizeptr) >
(( (size_t) memTable[*hdl].fitsfilesize) + 256L) )
{
ptr = realloc(*(memTable[*hdl].memaddrptr),
memTable[*hdl].fitsfilesize);
if (!ptr)
{
ffpmsg("Failed to reduce size of allocated memory (compress_open)");
return(MEMORY_ALLOCATION);
}
*(memTable[*hdl].memaddrptr) = ptr;
*(memTable[*hdl].memsizeptr) = memTable[*hdl].fitsfilesize;
}
return(0);
}
/*--------------------------------------------------------------------------*/
int mem_compress_open(char *filename, int rwmode, int *hdl)
/*
This routine opens the compressed diskfile and creates an empty memory
buffer with an appropriate size, then calls mem_uncompress2mem.
*/
{
FILE *diskfile;
int status, estimated = 1;
unsigned char buffer[4];
size_t finalsize, filesize;
LONGLONG llsize = 0;
unsigned int modulosize;
char *ptr;
if (rwmode != READONLY)
{
ffpmsg(
"cannot open compressed file with WRITE access (mem_compress_open)");
ffpmsg(filename);
return(READONLY_FILE);
}
/* open the compressed disk file */
status = file_openfile(filename, READONLY, &diskfile);
if (status)
{
ffpmsg("failed to open compressed disk file (compress_open)");
ffpmsg(filename);
return(status);
}
if (fread(buffer, 1, 2, diskfile) != 2) /* read 2 bytes */
{
fclose(diskfile);
return(READ_ERROR);
}
if (memcmp(buffer, "\037\213", 2) == 0) /* GZIP */
{
/* the uncompressed file size is give at the end */
/* of the file in the ISIZE field (modulo 2^32) */
fseek(diskfile, 0, 2); /* move to end of file */
filesize = ftell(diskfile); /* position = size of file */
fseek(diskfile, -4L, 1); /* move back 4 bytes */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
modulosize = buffer[0];
modulosize |= buffer[1] << 8;
modulosize |= buffer[2] << 16;
modulosize |= buffer[3] << 24;
/*
the field ISIZE in the gzipped file header only stores 4 bytes and contains
the uncompressed file size modulo 2^32. If the uncompressed file size
is less than the compressed file size (filesize), then one probably needs to
add 2^32 = 4294967296 to the uncompressed file size, assuming that the gzip
produces a compressed file that is smaller than the original file.
But one must allow for the case of very small files, where the
gzipped file may actually be larger then the original uncompressed file.
Therefore, only perform the modulo 2^32 correction test if the compressed
file is greater than 10,000 bytes in size. (Note: this threhold would
fail only if the original file was greater than 2^32 bytes in size AND gzip
was able to compress it by more than a factor of 400,000 (!) which seems
highly unlikely.)
Also, obviously, this 2^32 modulo correction cannot be performed if the
finalsize variable is only 32-bits long. Typically, the 'size_t' integer
type must be 8 bytes or larger in size to support data files that are
greater than 2 GB (2^31 bytes) in size.
*/
finalsize = modulosize;
if (sizeof(size_t) > 4 && filesize > 10000) {
llsize = (LONGLONG) finalsize;
/* use LONGLONG variable to suppress compiler warning */
while (llsize < (LONGLONG) filesize) llsize += 4294967296;
finalsize = (size_t) llsize;
}
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\120\113", 2) == 0) /* PKZIP */
{
/* the uncompressed file size is give at byte 22 the file */
fseek(diskfile, 22L, 0); /* move to byte 22 */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
modulosize = buffer[0];
modulosize |= buffer[1] << 8;
modulosize |= buffer[2] << 16;
modulosize |= buffer[3] << 24;
finalsize = modulosize;
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\037\036", 2) == 0) /* PACK */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\235", 2) == 0) /* LZW */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\240", 2) == 0) /* LZH */
finalsize = 0; /* for most methods we can't determine final size */
else
{
/* not a compressed file; this should never happen */
fclose(diskfile);
return(1);
}
if (finalsize == 0) /* estimate uncompressed file size */
{
fseek(diskfile, 0, 2); /* move to end of the compressed file */
finalsize = ftell(diskfile); /* position = size of file */
finalsize = finalsize * 3; /* assume factor of 3 compression */
}
fseek(diskfile, 0, 0); /* move back to beginning of file */
/* create a memory file big enough (hopefully) for the uncompressed file */
status = mem_createmem(finalsize, hdl);
if (status && estimated)
{
/* memory allocation failed, so try a smaller estimated size */
finalsize = finalsize / 3;
status = mem_createmem(finalsize, hdl);
}
if (status)
{
fclose(diskfile);
ffpmsg("failed to create empty memory file (compress_open)");
return(status);
}
/* uncompress file into memory */
status = mem_uncompress2mem(filename, diskfile, *hdl);
fclose(diskfile);
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to uncompress file into memory (compress_open)");
return(status);
}
/* if we allocated too much memory initially, then free it */
if (*(memTable[*hdl].memsizeptr) >
(( (size_t) memTable[*hdl].fitsfilesize) + 256L) )
{
ptr = realloc(*(memTable[*hdl].memaddrptr),
((size_t) memTable[*hdl].fitsfilesize) );
if (!ptr)
{
ffpmsg("Failed to reduce size of allocated memory (compress_open)");
return(MEMORY_ALLOCATION);
}
*(memTable[*hdl].memaddrptr) = ptr;
*(memTable[*hdl].memsizeptr) = (size_t) (memTable[*hdl].fitsfilesize);
}
return(0);
}
