Zlib inflate and deflate errors

Question

Hi everyone I am basically trying to use the zlib library, but I am having troubles when I try to inflate a self-deflated file , although when I inflate other zlib´d files it works fine.

The compressing code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef unsigned char BYTE;
typedef unsigned int  UINT; 
#include "zlib.h"
#define HEADERSIZE (1024)
#define CHUNKSIZE 4096
#define SWAPINT(x) (((x)&0xFF) << 24)|(((x)&0xFF00) << 8) | (((x)&0xFF0000) >> 8) | (((x)&0xFF000000) >> 24)
#define DEFLATESIZE 65536
const char *mz_error(int err)
{
  static struct { int m_err; const char *m_pDesc; } s_error_descs[] =
  {
    { Z_OK, "" }, { Z_STREAM_END, "stream end" }, { Z_NEED_DICT, "need dictionary" }, { Z_ERRNO, "file error" }, { Z_STREAM_ERROR, "stream error" },
    { Z_DATA_ERROR, "data error" }, { Z_MEM_ERROR, "out of memory" }, { Z_BUF_ERROR, "buf error" }, { Z_VERSION_ERROR, "version error" }
  };
  UINT i; for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i) if (s_error_descs[i].m_err == err) return s_error_descs[i].m_pDesc;
  return NULL;
}

char* myinflate(char* buffer, int bufsize, int* inflatedSize)
{
    BYTE tmpinf[DEFLATESIZE];
    char* inflated=(char*)malloc(DEFLATESIZE);
    int ret,have;
    z_stream strm;
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = bufsize;
    strm.next_in = (Bytef*)buffer;
    strm.avail_out = sizeof(tmpinf);
    strm.next_out = tmpinf;
    ret = inflateInit(&strm);
    printf("%s",mz_error(ret));
    ret = inflate(&strm, Z_FINISH);
    printf("%s",mz_error(ret));
    if(ret == Z_DATA_ERROR)
        printf(strm.msg);
    inflateEnd(&strm);
    have = strm.total_out;
    printf("%d\n",have);
    memcpy(inflated,tmpinf,have);
    *inflatedSize = have;
    return inflated;
}
char* mydeflate(char* buffer, int bufsize, int* deflatedSize)
{
    BYTE tmpdef[CHUNKSIZE*4];
    char* deflated=(char*)malloc(DEFLATESIZE);
    int have,ret;
    z_stream strm;
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = bufsize;
    strm.next_in = (Bytef*)buffer;
    strm.avail_out = sizeof(tmpdef);
    strm.next_out = tmpdef;
    ret = deflateInit(&strm,Z_DEFAULT_COMPRESSION);
    printf("%s",mz_error(ret));
    ret = deflate(&strm, Z_FINISH);
    printf("%s",mz_error(ret));
    ret = deflateEnd(&strm);
    printf("%s",mz_error(ret));
    have = strm.total_out;
    printf("%d\n",have);
    memcpy(deflated,tmpdef,have);
    *deflatedSize = have;
    return deflated;
}
int main()
{
    FILE* fptr = fopen("test.in","rb");
    fseek (fptr, 0, SEEK_END);
    int size  = ftell(fptr);
    fseek (fptr, 0, SEEK_SET);
    char* buffer = (char*)malloc(size);
    fread(buffer,1,size,fptr);
    int infsize,defsize;
    char* buf = myinflate(buffer,size,&infsize);
    FILE* out = fopen("testinf.hex","wb");
    fwrite(buf,1,infsize,out);
    fclose(out);
    char* buf2 = mydeflate(buf,infsize,&defsize);
    out  = fopen("testdef.hex","wb");
    fwrite(buf2,1,defsize,out);
    fclose(out);
    int buf3size;
    char* buf3 = myinflate(buf2,defsize,&buf3size);
    out  = fopen("testinfdef.hex","wb");
    fwrite(buf3,1,buf3size,out);
}

http://www.filehosting.org/file/details/364574/eEyzAbMuCp93MmGk/test.in

Answer 1

You're not checking any return codes. How could you possibly expect to know what's going on? Check the return codes from all functions that can return errors!

There may simply not be enough space provided for compression and/or decompression. The return codes from inflate() and compress() indicate whether that is the case or not.

By the way, you malloc() inflated twice, overwriting the first one resulting in a massive memory leak.

Also you blithely convert an int pointer to an unsigned long pointer. If they have different lengths, then you will have a problem.

Answer 2

Actually, I had to define ZLIB_WINAPI to get the things to work with http://www.winimage.com/zLibDll/zlib125dll.zip . Now it works