Welcome!

Join our community of MMO enthusiasts and game developers! By registering, you'll gain access to discussions on the latest developments in MMO server files and collaborate with like-minded individuals. Join us today and unlock the potential of MMO server development!

Join Today!

My windows ZPIPE.C outputting wrong file size?

Skilled Illusionist
Joined
Feb 6, 2009
Messages
327
Reaction score
56
Does anyone know how or why im getting incorrect file sizes for decompressed files?
This is the EXACT code im using. And im using LCC32 windows to compile.
When I de-compress my file(s), the file sizes come up as 1kb.
So for example, a 20mb file outputs to 1kb????

I think there has been a post regarding file size for windows?? But I don't understand it. Could someone show me what part of the code to change??

Code:
/* zpipe.c: example of proper use of zlib's inflate() and deflate()
   Not copyrighted -- provided to the public domain
   Version 1.2  9 November 2004  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()
 */
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "zlib.h"
#include <sys/types.h>
#include <sys/stat.h>
#define CHUNK 16384
/* Compress from file source to file dest until EOF on source.
   def() returns Z_OK on success, Z_MEM_ERROR if memory could not be
   allocated for processing, Z_STREAM_ERROR if an invalid compression
   level is supplied, Z_VERSION_ERROR if the version of zlib.h and the
   version of the library linked do not match, or Z_ERRNO if there is
   an error reading or writing the files. */
int def(FILE *source, FILE *dest, int level)
{
    int ret, flush;
    unsigned have;
    z_stream strm;
    char in[CHUNK];
    char out[CHUNK];
    char *buf;
    unsigned long dest_size;
    unsigned long indx = 0;
    struct stat sb;
    have = fileno(source);
    if (fstat(have, &sb) < 0)
        return Z_ERRNO;
    if (!S_ISREG(sb.st_mode))
        return Z_ERRNO;
    if ((dest_size = (unsigned long)sb.st_size) <= 0)
        return Z_ERRNO;
    if (fwrite(&dest_size, 4, 1, dest) != 1 || ferror(dest))
        return Z_ERRNO;
    /* allocate deflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    ret = deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY);
    if (ret != Z_OK)
        return ret;
    /* compress until end of file */
    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)deflateEnd(&strm);
            return Z_ERRNO;
        }
        flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
        strm.next_in = in;
        /* run deflate() on input until output buffer not full, finish
           compression if all of source has been read in */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = deflate(&strm, flush);    /* no bad return value */
            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
            have = CHUNK - strm.avail_out;
            if (have > 0) {
                buf = out;
                do {
                    if (dest_size > indx++) {
                        switch (indx) {
                        case 1:
                            *buf ^= 0x10;
                            break;
                        case 2:
                            *buf ^= 0x20;
                            break;
                        case 3:
                            *buf ^= 0x30;
                            break;
                        case 4:
                            *buf ^= 0x40;
                           }
                    }
                } while (*buf++);
                if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                    (void)deflateEnd(&strm);
                    return Z_ERRNO;
                }
            }
        } while (strm.avail_out == 0);
        assert(strm.avail_in == 0);     /* all input will be used */
        /* done when last data in file processed */
    } while (flush != Z_FINISH);
    assert(ret == Z_STREAM_END);        /* stream will be complete */
    /* clean up and return */
    (void)deflateEnd(&strm);
    return Z_OK;
}
/* Decompress from file source to file dest until stream ends or EOF.
   inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be
   allocated for processing, Z_DATA_ERROR if the deflate data is
   invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and
   the version of the library linked do not match, or Z_ERRNO if there
   is an error reading or writing the files. */
int inf(FILE *source, FILE *dest)
{
    int ret;
    unsigned have;
    z_stream strm;
    char in[CHUNK];
    char out[CHUNK];
    char *buf;
    unsigned long dest_size;
    unsigned long indx = 0;
    have = fread(in, 1, 4, source);
    if (have != 4 || ferror(source)) {
        return Z_ERRNO;
    }
    dest_size = ((unsigned long)in[0]) |
                ((unsigned long)in[1] << 8) |
                ((unsigned long)in[2] << 16) |
                ((unsigned long)in[3] << 24);
    /* allocate inflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit2(&strm, -MAX_WBITS);
    if (ret != Z_OK)
        return ret;
    /* decompress until deflate stream ends or end of file */
    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)inflateEnd(&strm);
            return Z_ERRNO;
        }
        if (strm.avail_in == 0)
            break;
        buf = in;
        do {
            if (dest_size > indx++) {
                switch (indx) {
                case 1:
                            *buf ^= 0x10;
                            break;
                        case 2:
                            *buf ^= 0x20;
                            break;
                        case 3:
                            *buf ^= 0x30;
                            break;
                        case 4:
                            *buf ^= 0x40;
                }
            }
        } while (*buf++);
        strm.next_in = in;
        /* run inflate() on input until output buffer not full */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = inflate(&strm, Z_NO_FLUSH);
            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
            switch (ret) {
            case Z_NEED_DICT:
                ret = Z_DATA_ERROR;     /* and fall through */
            case Z_DATA_ERROR:
            case Z_MEM_ERROR:
                (void)inflateEnd(&strm);
                return ret;
            }
            have = CHUNK - strm.avail_out;
            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                (void)inflateEnd(&strm);
                return Z_ERRNO;
            }
        } while (strm.avail_out == 0);
        /* done when inflate() says it's done */
    } while (ret != Z_STREAM_END);
    /* clean up and return */
    (void)inflateEnd(&strm);
    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
}
/* report a zlib or i/o error */
void zerr(int ret)
{
    fputs("zpipe: ", stderr);
    switch (ret) {
    case Z_ERRNO:
        if (ferror(stdin))
            fputs("error reading stdin\n", stderr);
        if (ferror(stdout))
            fputs("error writing stdout\n", stderr);
        break;
    case Z_STREAM_ERROR:
        fputs("invalid compression level\n", stderr);
        break;
    case Z_DATA_ERROR:
        fputs("invalid or incomplete deflate data\n", stderr);
        break;
    case Z_MEM_ERROR:
        fputs("out of memory\n", stderr);
        break;
    case Z_VERSION_ERROR:
        fputs("zlib version mismatch!\n", stderr);
    }
}
/* compress or decompress from stdin to stdout */
int main(int argc, char **argv)
{
    int ret;
    /* do compression if -c specified */
    if (argc == 2 && strcmp(argv[1], "-c") == 0) {
        ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);
        if (ret != Z_OK)
            zerr(ret);
        return ret;
    }
    /* do decompression if -d specified */
    else if (argc == 2 && strcmp(argv[1], "-d") == 0) {
        ret = inf(stdin, stdout);
        if (ret != Z_OK)
            zerr(ret);
        return ret;
    }
    /* otherwise, report usage */
    else {
        fputs("encpack usage: encpack [-c|-d] < source > dest\n", stderr);
        fputs("E.g: encpack -c < cabal.txt > cabal.enc\n\n", stderr);
        return 1;
    }
}

Im basically using ZPIPE for other purposes not used for cabal. I have other 2d platform games that I would like to secure files for and this seems quite a good program/code to use. But also would come in handy to make my own cabal enc packer I suppose too! Add a nice GUI and stuff! :wink:
Any help would be MUCH appreciated.
 
The Dinosaur
Loyal Member
Joined
Jun 29, 2008
Messages
5,028
Reaction score
999
It fails because the code that works out the size is for linux only. I never got it to work in windows, but then my C sucks.
 
Upvote 0
Skilled Illusionist
Joined
Feb 6, 2009
Messages
327
Reaction score
56
Im sure this is a work around but I cant fathom it out either!

Code:
HANDLE hFile;

hFile = GetStdHandle(STD_INPUT_HANDLE);

if (GetFileSizeEx(hFile, &dest_size) == 0)
return Z_ERRNO;

:*:
 
Upvote 0
Back
Top