1  | 
     | 
     | 
    /*	$OpenBSD: uncompr.c,v 1.5 2003/12/16 22:33:02 henning Exp $	*/  | 
    
    
    2  | 
     | 
     | 
    /* uncompr.c -- decompress a memory buffer  | 
    
    
    3  | 
     | 
     | 
     * Copyright (C) 1995-2003 Jean-loup Gailly.  | 
    
    
    4  | 
     | 
     | 
     * For conditions of distribution and use, see copyright notice in zlib.h  | 
    
    
    5  | 
     | 
     | 
     */  | 
    
    
    6  | 
     | 
     | 
     | 
    
    
    7  | 
     | 
     | 
     | 
    
    
    8  | 
     | 
     | 
    #define ZLIB_INTERNAL  | 
    
    
    9  | 
     | 
     | 
    #include "zlib.h"  | 
    
    
    10  | 
     | 
     | 
     | 
    
    
    11  | 
     | 
     | 
    /* ===========================================================================  | 
    
    
    12  | 
     | 
     | 
         Decompresses the source buffer into the destination buffer.  sourceLen is  | 
    
    
    13  | 
     | 
     | 
       the byte length of the source buffer. Upon entry, destLen is the total  | 
    
    
    14  | 
     | 
     | 
       size of the destination buffer, which must be large enough to hold the  | 
    
    
    15  | 
     | 
     | 
       entire uncompressed data. (The size of the uncompressed data must have  | 
    
    
    16  | 
     | 
     | 
       been saved previously by the compressor and transmitted to the decompressor  | 
    
    
    17  | 
     | 
     | 
       by some mechanism outside the scope of this compression library.)  | 
    
    
    18  | 
     | 
     | 
       Upon exit, destLen is the actual size of the compressed buffer.  | 
    
    
    19  | 
     | 
     | 
         This function can be used to decompress a whole file at once if the  | 
    
    
    20  | 
     | 
     | 
       input file is mmap'ed.  | 
    
    
    21  | 
     | 
     | 
     | 
    
    
    22  | 
     | 
     | 
         uncompress returns Z_OK if success, Z_MEM_ERROR if there was not  | 
    
    
    23  | 
     | 
     | 
       enough memory, Z_BUF_ERROR if there was not enough room in the output  | 
    
    
    24  | 
     | 
     | 
       buffer, or Z_DATA_ERROR if the input data was corrupted.  | 
    
    
    25  | 
     | 
     | 
    */  | 
    
    
    26  | 
     | 
     | 
    int ZEXPORT uncompress (dest, destLen, source, sourceLen)  | 
    
    
    27  | 
     | 
     | 
        Bytef *dest;  | 
    
    
    28  | 
     | 
     | 
        uLongf *destLen;  | 
    
    
    29  | 
     | 
     | 
        const Bytef *source;  | 
    
    
    30  | 
     | 
     | 
        uLong sourceLen;  | 
    
    
    31  | 
     | 
     | 
    { | 
    
    
    32  | 
     | 
     | 
        z_stream stream;  | 
    
    
    33  | 
     | 
     | 
        int err;  | 
    
    
    34  | 
     | 
     | 
     | 
    
    
    35  | 
     | 
     | 
        stream.next_in = (Bytef*)source;  | 
    
    
    36  | 
     | 
     | 
        stream.avail_in = (uInt)sourceLen;  | 
    
    
    37  | 
     | 
     | 
        /* Check for source > 64K on 16-bit machine: */  | 
    
    
    38  | 
     | 
     | 
        if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;  | 
    
    
    39  | 
     | 
     | 
     | 
    
    
    40  | 
     | 
     | 
        stream.next_out = dest;  | 
    
    
    41  | 
     | 
     | 
        stream.avail_out = (uInt)*destLen;  | 
    
    
    42  | 
     | 
     | 
        if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;  | 
    
    
    43  | 
     | 
     | 
     | 
    
    
    44  | 
     | 
     | 
        stream.zalloc = (alloc_func)0;  | 
    
    
    45  | 
     | 
     | 
        stream.zfree = (free_func)0;  | 
    
    
    46  | 
     | 
     | 
     | 
    
    
    47  | 
     | 
     | 
        err = inflateInit(&stream);  | 
    
    
    48  | 
     | 
     | 
        if (err != Z_OK) return err;  | 
    
    
    49  | 
     | 
     | 
     | 
    
    
    50  | 
     | 
     | 
        err = inflate(&stream, Z_FINISH);  | 
    
    
    51  | 
     | 
     | 
        if (err != Z_STREAM_END) { | 
    
    
    52  | 
     | 
     | 
            inflateEnd(&stream);  | 
    
    
    53  | 
     | 
     | 
            if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))  | 
    
    
    54  | 
     | 
     | 
                return Z_DATA_ERROR;  | 
    
    
    55  | 
     | 
     | 
            return err;  | 
    
    
    56  | 
     | 
     | 
        }  | 
    
    
    57  | 
     | 
     | 
        *destLen = stream.total_out;  | 
    
    
    58  | 
     | 
     | 
     | 
    
    
    59  | 
     | 
     | 
        err = inflateEnd(&stream);  | 
    
    
    60  | 
     | 
     | 
        return err;  | 
    
    
    61  | 
     | 
     | 
    }  |