void maa_shutdown( void )
{
if (dbg_test(MAA_MEMORY) || dbg_test(MAA_TIME))
fprintf( stderr, "%s\n", maa_version() );
if (dbg_test(MAA_MEMORY)) {
str_print_stats( stderr );
}
_pr_shutdown();
str_destroy();
_lst_shutdown();
_sl_shutdown();
tim_stop( "total" );
if (dbg_test(MAA_TIME)) {
tim_print_timers( stderr );
}
_tim_shutdown();
flg_destroy();
dbg_destroy();
}
int dict_data_zip( const char *inFilename, const char *outFilename,
const char *preFilter, const char *postFilter )
{
char inBuffer[IN_BUFFER_SIZE];
char outBuffer[OUT_BUFFER_SIZE];
int count;
unsigned long inputCRC = crc32( 0L, Z_NULL, 0 );
z_stream zStream;
FILE *outStr;
FILE *inStr;
int len;
struct stat st;
char *header;
int headerLength;
int dataLength;
int extraLength;
int chunkLength;
#if HEADER_CRC
int headerCRC;
#endif
unsigned long chunks;
unsigned long chunk = 0;
unsigned long total = 0;
int i;
char tail[8];
char *pt, *origFilename;
/* Open files */
if (!(inStr = fopen( inFilename, "r" )))
err_fatal_errno( __func__,
"Cannot open \"%s\" for read\n", inFilename );
if (!(outStr = fopen( outFilename, "w" )))
err_fatal_errno( __func__,
"Cannot open \"%s\"for write\n", outFilename );
origFilename = xmalloc( strlen( inFilename ) + 1 );
if ((pt = strrchr( inFilename, '/' )))
strcpy( origFilename, pt + 1 );
else
strcpy( origFilename, inFilename );
/* Initialize compression engine */
zStream.zalloc = NULL;
zStream.zfree = NULL;
zStream.opaque = NULL;
zStream.next_in = NULL;
zStream.avail_in = 0;
zStream.next_out = NULL;
zStream.avail_out = 0;
if (deflateInit2( &zStream,
Z_BEST_COMPRESSION,
Z_DEFLATED,
-15, /* Suppress zlib header */
Z_BEST_COMPRESSION,
Z_DEFAULT_STRATEGY ) != Z_OK)
err_internal( __func__,
"Cannot initialize deflation engine: %s\n", zStream.msg );
/* Write initial header information */
chunkLength = (preFilter ? PREFILTER_IN_BUFFER_SIZE : IN_BUFFER_SIZE );
fstat( fileno( inStr ), &st );
chunks = st.st_size / chunkLength;
if (st.st_size % chunkLength) ++chunks;
PRINTF(DBG_VERBOSE,("%lu chunks * %u per chunk = %lu (filesize = %lu)\n",
chunks, chunkLength, chunks * chunkLength,
(unsigned long) st.st_size ));
dataLength = chunks * 2;
extraLength = 10 + dataLength;
headerLength = GZ_FEXTRA_START
+ extraLength /* FEXTRA */
+ strlen( origFilename ) + 1 /* FNAME */
+ (HEADER_CRC ? 2 : 0); /* FHCRC */
PRINTF(DBG_VERBOSE,("(data = %d, extra = %d, header = %d)\n",
dataLength, extraLength, headerLength ));
header = xmalloc( headerLength );
for (i = 0; i < headerLength; i++) header[i] = 0;
header[GZ_ID1] = GZ_MAGIC1;
header[GZ_ID2] = GZ_MAGIC2;
header[GZ_CM] = Z_DEFLATED;
header[GZ_FLG] = GZ_FEXTRA | GZ_FNAME;
#if HEADER_CRC
header[GZ_FLG] |= GZ_FHCRC;
#endif
header[GZ_MTIME+3] = (st.st_mtime & 0xff000000) >> 24;
header[GZ_MTIME+2] = (st.st_mtime & 0x00ff0000) >> 16;
header[GZ_MTIME+1] = (st.st_mtime & 0x0000ff00) >> 8;
header[GZ_MTIME+0] = (st.st_mtime & 0x000000ff) >> 0;
header[GZ_XFL] = GZ_MAX;
header[GZ_OS] = GZ_OS_UNIX;
header[GZ_XLEN+1] = (extraLength & 0xff00) >> 8;
header[GZ_XLEN+0] = (extraLength & 0x00ff) >> 0;
header[GZ_SI1] = GZ_RND_S1;
header[GZ_SI2] = GZ_RND_S2;
header[GZ_SUBLEN+1] = ((extraLength - 4) & 0xff00) >> 8;
header[GZ_SUBLEN+0] = ((extraLength - 4) & 0x00ff) >> 0;
header[GZ_VERSION+1] = 0;
header[GZ_VERSION+0] = 1;
header[GZ_CHUNKLEN+1] = (chunkLength & 0xff00) >> 8;
header[GZ_CHUNKLEN+0] = (chunkLength & 0x00ff) >> 0;
header[GZ_CHUNKCNT+1] = (chunks & 0xff00) >> 8;
header[GZ_CHUNKCNT+0] = (chunks & 0x00ff) >> 0;
strcpy( &header[GZ_FEXTRA_START + extraLength], origFilename );
xfwrite( header, 1, headerLength, outStr );
/* Read, compress, write */
while (!feof( inStr )) {
if ((count = fread( inBuffer, 1, chunkLength, inStr ))) {
dict_data_filter( inBuffer, &count, IN_BUFFER_SIZE, preFilter );
inputCRC = crc32( inputCRC, (const Bytef *) inBuffer, count );
zStream.next_in = (Bytef *) inBuffer;
zStream.avail_in = count;
zStream.next_out = (Bytef *) outBuffer;
zStream.avail_out = OUT_BUFFER_SIZE;
if (deflate( &zStream, Z_FULL_FLUSH ) != Z_OK)
err_fatal( __func__, "deflate: %s\n", zStream.msg );
assert( zStream.avail_in == 0 );
len = OUT_BUFFER_SIZE - zStream.avail_out;
assert( len <= 0xffff );
dict_data_filter( outBuffer, &len, OUT_BUFFER_SIZE, postFilter );
assert( len <= 0xffff );
header[GZ_RNDDATA + chunk*2 + 1] = (len & 0xff00) >> 8;
header[GZ_RNDDATA + chunk*2 + 0] = (len & 0x00ff) >> 0;
xfwrite( outBuffer, 1, len, outStr );
++chunk;
total += count;
if (dbg_test( DBG_VERBOSE )) {
printf( "chunk %5lu: %lu of %lu total\r",
chunk, total, (unsigned long) st.st_size );
xfflush( stdout );
}
}
}
int dbg_cmd(int argc, char *argv[])
{
char* cmd = NULL;
char* arg1 = NULL;
char* arg2 = NULL;
if (argc > 1) {
cmd = argv[1];
if ( argc > 2 ) {
arg1 = argv[2];
if ( argc > 3 ) {
arg2 = argv[3];
}
}
}
else {
DEBUGF("usage: fat command [options]\n"
"commands:\n"
" dir <dir>\n"
" ds <sector> - display sector\n"
" type <file>\n"
" head <file>\n"
" tail <file>\n"
" mkfile <file> <size (KB)>\n"
" chkfile <file>\n"
" del <file>\n"
" rmdir <dir>\n"
" dump <file> <offset>\n"
" mkdir <dir>\n"
" trunc <file> <size>\n"
" wrtest <file>\n"
" append <file>\n"
" test <file>\n"
" ren <file> <newname>\n"
);
return -1;
}
if (!strcasecmp(cmd, "dir"))
{
if ( arg1 )
dbg_dir(arg1);
else
dbg_dir("/");
}
if (!strcasecmp(cmd, "ds"))
{
if ( arg1 ) {
DEBUGF("secnum: %ld\n", strtol(arg1, NULL, 0));
dbg_dump_sector(strtol(arg1, NULL, 0));
}
}
if (!strcasecmp(cmd, "type"))
{
if (arg1)
dbg_type(arg1);
}
if (!strcasecmp(cmd, "head"))
{
if (arg1)
return dbg_head(arg1);
}
if (!strcasecmp(cmd, "tail"))
{
if (arg1)
dbg_tail(arg1);
}
if (!strcasecmp(cmd, "mkfile"))
{
if (arg1) {
if (arg2)
return dbg_mkfile(arg1,strtol(arg2, NULL, 0));
else
return dbg_mkfile(arg1,1);
}
}
if (!strcasecmp(cmd, "chkfile"))
{
if (arg1) {
if (arg2)
return dbg_chkfile(arg1, strtol(arg2, NULL, 0));
else
return dbg_chkfile(arg1, 0);
}
}
if (!strcasecmp(cmd, "mkdir"))
{
if (arg1) {
return dbg_mkdir(arg1);
}
}
if (!strcasecmp(cmd, "del"))
{
if (arg1)
return remove(arg1);
}
if (!strcasecmp(cmd, "rmdir"))
{
if (arg1)
return rmdir(arg1);
}
if (!strcasecmp(cmd, "dump"))
{
if (arg1) {
if (arg2)
return dbg_dump(arg1, strtol(arg2, NULL, 0));
else
return dbg_dump(arg1, 0);
}
}
if (!strcasecmp(cmd, "wrtest"))
{
if (arg1)
return dbg_wrtest(arg1);
}
if (!strcasecmp(cmd, "append"))
{
if (arg1)
return dbg_append(arg1);
}
if (!strcasecmp(cmd, "test"))
{
if (arg1)
return dbg_test(arg1);
}
if (!strcasecmp(cmd, "trunc"))
{
if (arg1 && arg2)
return dbg_trunc(arg1, strtol(arg2, NULL, 0));
}
if (!strcasecmp(cmd, "ren"))
{
if (arg1 && arg2)
return rename(arg1, arg2);
}
return 0;
}
