zlib 实现gzip的压缩和解压

    本代码实例为了记录zlib的解压和压缩gzip文件，是最简单的实现。
   类头文件：
   

#define ZLIB_COPY_BUFFER_SIZE (1024*2)
class vozlib
{
public:
    vozlib();
    ~vozlib();
    VO_GZIP_ERROR_CODE ungzip(VO_PBYTE pInputbuf,VO_U32 inputlen , VO_PBYTE* pOutputbuf,VO_U32 *pOutputlen);
    VO_GZIP_ERROR_CODE gzip(VO_PBYTE pInputbuf,VO_U32 inputlen , VO_PBYTE* pOutputbuf,VO_U32 *pOutputlen);
private:
    VO_VOID init();
    VO_VOID recoverInitBuffer();
protected:
    vozlib(const vozlib& tmp);
    VO_VOID operator=(vozlib& tmp);
private:
    VO_BYTE m_copybuf[ZLIB_COPY_BUFFER_SIZE];
    VO_U32 m_maxoutbufsize;
    VO_PBYTE m_pOutputbuf;

};

    代码实现：
 

vozlib::vozlib():m_pOutputbuf(NULL),
                 m_maxoutbufsize(0)
{
    init();
}

vozlib::~vozlib()
{
    if(m_pOutputbuf)
    {
        delete[] m_pOutputbuf;
        m_pOutputbuf = NULL;
    }
}

vozlib::vozlib(const vozlib& tmp)
{

}

VO_VOID vozlib::operator=(vozlib& tmp)
{

}


VO_VOID vozlib::init()
{
    memset(m_copybuf,0,sizeof(VO_BYTE)*ZLIB_COPY_BUFFER_SIZE);
    m_pOutputbuf = new VO_BYTE[ZLIB_COPY_BUFFER_SIZE];
    memset(m_pOutputbuf,0,sizeof(VO_BYTE)*ZLIB_COPY_BUFFER_SIZE);
    m_maxoutbufsize = ZLIB_COPY_BUFFER_SIZE;
}

VO_VOID vozlib::recoverInitBuffer()
{
    memset(m_copybuf,0,sizeof(VO_BYTE)*ZLIB_COPY_BUFFER_SIZE);
    if(m_pOutputbuf)
    {
        delete[] m_pOutputbuf;
        m_pOutputbuf = NULL;
    }
    init();
}

VO_GZIP_ERROR_CODE vozlib::gzip(VO_PBYTE pInputbuf,VO_U32 inputlen , VO_PBYTE* pOutputbuf,VO_U32 *pOutputlen)
{
    int ret = 0,have = 0;
    int offset=0;
    z_stream d_stream;
    (*pOutputbuf) = m_pOutputbuf;
    uLong comprLen, uncomprLen;
    uncomprLen =inputlen;
    comprLen =ZLIB_COPY_BUFFER_SIZE;

    strcpy((char*)m_pOutputbuf, "garbage");
    d_stream.zalloc = Z_NULL;
    d_stream.zfree = Z_NULL;
    d_stream.opaque = Z_NULL;
    d_stream.next_in = Z_NULL;
    d_stream.avail_in = 0;

    if(deflateInit2(&d_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
        MAX_WBITS+16, 6, Z_DEFAULT_STRATEGY) != Z_OK)
        return VO_GZIP_INIT_ERROR;
    d_stream.next_in=pInputbuf;
    d_stream.avail_in=uncomprLen;
    do
    {
        d_stream.next_out=m_copybuf;
        d_stream.avail_out=comprLen;
        ret = deflate(&d_stream,Z_FINISH);
        if(ret == Z_STREAM_ERROR)
        {
            return VO_GZIP_STREAM_ERROR;
        }

        switch (ret)
        {
        case Z_NEED_DICT:
            {
                return VO_GZIP_NEED_DICT;
            }break;
        case Z_DATA_ERROR:
            {
                (void)deflateEnd(&d_stream);
                return VO_GZIP_DATA_ERROR;
            }break;
        case Z_MEM_ERROR:
            {
                (void)deflateEnd(&d_stream);
                return VO_GZIP_MEMORY_ERROR;
            }break;
        }
        have=comprLen-d_stream.avail_out;
        int    length = offset + have;
        if(length > m_maxoutbufsize)
        {
            m_maxoutbufsize = length + ZLIB_COPY_BUFFER_SIZE;
            VO_PBYTE newoutputbuf = (VO_PBYTE)realloc((*pOutputbuf),sizeof(VO_BYTE) * m_maxoutbufsize);
            if(newoutputbuf != (*pOutputbuf))
            {
                (*pOutputbuf) = (VO_PBYTE)newoutputbuf;
                m_pOutputbuf = (*pOutputbuf);
            }
        }
        memcpy((*pOutputbuf)+offset,m_copybuf,have);
        offset+=have;
    }while(d_stream.avail_out==0);
    (void)deflateEnd(&d_stream);
    *pOutputlen = offset/*+sizeof(uLong)*/;
    return VO_GZIP_OK;
}


VO_GZIP_ERROR_CODE vozlib::ungzip(VO_PBYTE pInputbuf,VO_U32 inputlen , VO_PBYTE* pOutputbuf,VO_U32 *pOutputlen)
{
    recoverInitBuffer();
    int ret = 0,have = 0;
    int offset=0;
    z_stream d_stream;
    (*pOutputbuf) = m_pOutputbuf;

    uLong comprLen, uncomprLen;
    comprLen =inputlen;
    uncomprLen =ZLIB_COPY_BUFFER_SIZE;

    strcpy((char*)m_pOutputbuf, "garbage");
    d_stream.zalloc = Z_NULL;
    d_stream.zfree = Z_NULL;
    d_stream.opaque = Z_NULL;
    d_stream.next_in = Z_NULL;
    d_stream.avail_in = 0;
    ret = inflateInit2(&d_stream,47);

    if(ret!=Z_OK)
    {
        return VO_GZIP_INIT_ERROR;
    }

    d_stream.next_in=pInputbuf;
    d_stream.avail_in=comprLen;

    do
    {
        d_stream.next_out=m_copybuf;
        d_stream.avail_out=uncomprLen;
        ret = inflate(&d_stream,Z_NO_FLUSH);
        if(ret == Z_STREAM_ERROR)
        {
            return VO_GZIP_STREAM_ERROR;
        }

        switch (ret)
        {
        case Z_NEED_DICT:
            {
                return VO_GZIP_NEED_DICT;
            }break;
        case Z_DATA_ERROR:
            {
                (void)inflateEnd(&d_stream);
                return VO_GZIP_DATA_ERROR;
            }break;
        case Z_MEM_ERROR:
            {
                (void)inflateEnd(&d_stream);
                return VO_GZIP_MEMORY_ERROR;
            }break;
        }
        have=uncomprLen-d_stream.avail_out;
        int    length = offset + have;
        if(length > m_maxoutbufsize)
        {
            m_maxoutbufsize = length + ZLIB_COPY_BUFFER_SIZE;
            VO_PBYTE newoutputbuf = (VO_PBYTE)realloc((*pOutputbuf),sizeof(VO_BYTE) * m_maxoutbufsize);
            if(newoutputbuf != (*pOutputbuf))
            {
                (*pOutputbuf) = (VO_PBYTE)newoutputbuf;
                m_pOutputbuf = (*pOutputbuf);
            }
        }
        memcpy((*pOutputbuf)+offset,m_copybuf,have);
        offset+=have;
    }while(d_stream.avail_out==0);

    inflateEnd(&d_stream);
    *pOutputlen = offset;
    return VO_GZIP_OK;

}