vfdzip.c File Reference

#include <windows.h>
#include "vfdtypes.h"
#include "vfdio.h"
#include "vfdlib.h"
#include "zlib.h"

Include dependency graph for vfdzip.c:

Go to the source code of this file.

Classes
struct	_zip_local_file_header

Macros
#define	WIN32_LEAN_AND_MEAN
#define	ZLIB_WINAPI
#define	ZIP_LOCAL_SIGNATURE   0x04034b50
#define	ZIP_FLAG_ENCRYPTED   0x01
#define	ZIP_FLAG_DEFLATE_NORMAL   0x00
#define	ZIP_FLAG_DEFLATE_MAX   0x02
#define	ZIP_FLAG_DEFLATE_FAST   0x04
#define	ZIP_FLAG_DEFLATE_SUPER   0x06
#define	ZIP_FLAG_DEFLATE_MASK   0x06
#define	ZIP_FLAG_SIZE_IN_DESC   0x08
#define	ZIP_METHOD_STORED   0
#define	ZIP_METHOD_SHRUNK   1
#define	ZIP_METHOD_REDUCED1   2
#define	ZIP_METHOD_REDUCED2   3
#define	ZIP_METHOD_REDUCED3   4
#define	ZIP_METHOD_REDUCED4   5
#define	ZIP_METHOD_IMPLODED   6
#define	ZIP_METHOD_TOKENIZED   7
#define	ZIP_METHOD_DEFLATED   8
#define	ZIP_METHOD_DEFLATE64   9
#define	ZIP_METHOD_PKWARE_IMP   10
#define	ZIP_METHOD_RESERVED   11
#define	ZIP_METHOD_BZIP2   12

Typedefs
typedef struct _zip_local_file_header	ZIP_HEADER
typedef struct _zip_local_file_header *	PZIP_HEADER

Functions
voidpf zcalloc	OF ((voidpf opaque, unsigned items, unsigned size))
void zcfree	OF ((voidpf opaque, voidpf ptr))
DWORD	ExtractZipInfo (HANDLE hFile, ULONG *pSize)
DWORD	ExtractZipImage (HANDLE hFile, PUCHAR *pBuffer, PULONG pLength)

Macro Definition Documentation

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 15 of file vfdzip.c.

ZIP_FLAG_DEFLATE_FAST

#define ZIP_FLAG_DEFLATE_FAST   0x04

Definition at line 91 of file vfdzip.c.

ZIP_FLAG_DEFLATE_MASK

#define ZIP_FLAG_DEFLATE_MASK   0x06

Definition at line 93 of file vfdzip.c.

ZIP_FLAG_DEFLATE_MAX

#define ZIP_FLAG_DEFLATE_MAX   0x02

Definition at line 90 of file vfdzip.c.

ZIP_FLAG_DEFLATE_NORMAL

#define ZIP_FLAG_DEFLATE_NORMAL   0x00

Definition at line 89 of file vfdzip.c.

ZIP_FLAG_DEFLATE_SUPER

#define ZIP_FLAG_DEFLATE_SUPER   0x06

Definition at line 92 of file vfdzip.c.

ZIP_FLAG_ENCRYPTED

#define ZIP_FLAG_ENCRYPTED   0x01

Definition at line 87 of file vfdzip.c.

ZIP_FLAG_SIZE_IN_DESC

#define ZIP_FLAG_SIZE_IN_DESC   0x08

Definition at line 95 of file vfdzip.c.

ZIP_LOCAL_SIGNATURE

#define ZIP_LOCAL_SIGNATURE   0x04034b50

Definition at line 85 of file vfdzip.c.

ZIP_METHOD_BZIP2

#define ZIP_METHOD_BZIP2   12

Definition at line 109 of file vfdzip.c.

ZIP_METHOD_DEFLATE64

#define ZIP_METHOD_DEFLATE64   9

Definition at line 106 of file vfdzip.c.

ZIP_METHOD_DEFLATED

#define ZIP_METHOD_DEFLATED   8

Definition at line 105 of file vfdzip.c.

ZIP_METHOD_IMPLODED

#define ZIP_METHOD_IMPLODED   6

Definition at line 103 of file vfdzip.c.

ZIP_METHOD_PKWARE_IMP

#define ZIP_METHOD_PKWARE_IMP   10

Definition at line 107 of file vfdzip.c.

ZIP_METHOD_REDUCED1

#define ZIP_METHOD_REDUCED1   2

Definition at line 99 of file vfdzip.c.

ZIP_METHOD_REDUCED2

#define ZIP_METHOD_REDUCED2   3

Definition at line 100 of file vfdzip.c.

ZIP_METHOD_REDUCED3

#define ZIP_METHOD_REDUCED3   4

Definition at line 101 of file vfdzip.c.

ZIP_METHOD_REDUCED4

#define ZIP_METHOD_REDUCED4   5

Definition at line 102 of file vfdzip.c.

ZIP_METHOD_RESERVED

#define ZIP_METHOD_RESERVED   11

Definition at line 108 of file vfdzip.c.

ZIP_METHOD_SHRUNK

#define ZIP_METHOD_SHRUNK   1

Definition at line 98 of file vfdzip.c.

ZIP_METHOD_STORED

#define ZIP_METHOD_STORED   0

Definition at line 97 of file vfdzip.c.

ZIP_METHOD_TOKENIZED

#define ZIP_METHOD_TOKENIZED   7

Definition at line 104 of file vfdzip.c.

ZLIB_WINAPI

#define ZLIB_WINAPI

Definition at line 23 of file vfdzip.c.

Typedef Documentation

PZIP_HEADER

typedef struct _zip_local_file_header * PZIP_HEADER

ZIP_HEADER

typedef struct _zip_local_file_header ZIP_HEADER

Function Documentation

ExtractZipImage()

DWORD ExtractZipImage	(	HANDLE	hFile,
		PUCHAR *	pBuffer,
		PULONG	pLength
	)

Definition at line 182 of file vfdzip.c.

{
    UCHAR           buf[VFD_BYTES_PER_SECTOR];
    DWORD           result;
    DWORD           ret;
 
    PZIP_HEADER     zip_hdr;
    ULONG           compressed;
    ULONG           uncompressed;
    PUCHAR          file_cache;
    z_stream        stream;
    int             zlib_ret;
 
    VFDTRACE(0,
        ("[VFD] VfdExtractImz - IN\n"));
 
    *pBuffer = NULL;
    *pLength = 0;
 
    //
    //  Read PKZIP local file header of the first file in the file
    //  -- An IMZ file actually is just a ZIP file with a different
    //  extension, which contains a single floppy image file
    //
    if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) != 0) {
        ret = GetLastError();
 
        VFDTRACE(0,(
            "SetFilePointer - %s", SystemMessage(ret)));;
 
        return ret;
    }
 
    if (!ReadFile(hFile, buf, VFD_BYTES_PER_SECTOR, &result, NULL) ||
        result < VFD_BYTES_PER_SECTOR) {
 
        ret = GetLastError();
 
        VFDTRACE(0,(
            "ReadFile - %s", SystemMessage(ret)));;
 
        return ret;
    }
 
    zip_hdr = (PZIP_HEADER)buf;
 
    //  check local file header signature
 
    if (zip_hdr->header_signature != ZIP_LOCAL_SIGNATURE) {
 
        VFDTRACE(0,
            ("[VFD] PKZIP header signature not found.\n"));
 
        return ERROR_INVALID_DATA;
    }
 
    //  check compression method
 
    if (zip_hdr->compression_method != Z_DEFLATED) {
 
        VFDTRACE(0,
            ("[VFD] Bad PKZIP compression method.\n"));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    if (zip_hdr->general_flags & 0x01) {
        //  encrypted zip not supported
 
        VFDTRACE(0,
            ("[VFD] PKZIP encrypted.\n"));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    //  check uncompressed image size
 
    compressed = zip_hdr->compressed_size;
    uncompressed = zip_hdr->uncompressed_size;
 
    switch (uncompressed) {
    case VFD_SECTOR_TO_BYTE(320):
    case VFD_SECTOR_TO_BYTE(360):
    case VFD_SECTOR_TO_BYTE(640):
    case VFD_SECTOR_TO_BYTE(720):
    case VFD_SECTOR_TO_BYTE(1280):
    case VFD_SECTOR_TO_BYTE(1440):
    case VFD_SECTOR_TO_BYTE(1640):
    case VFD_SECTOR_TO_BYTE(2400):
    case VFD_SECTOR_TO_BYTE(2880):
    case VFD_SECTOR_TO_BYTE(3360):
    case VFD_SECTOR_TO_BYTE(3444):
    case VFD_SECTOR_TO_BYTE(5760):
        break;
 
    default:
        VFDTRACE(0,
            ("[VFD] Unsupported image size %lu.\n",
            uncompressed));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    //  check local file header length
    //  -- Just for simplicity, the compressed data must start in the
    //  first sector in the file:  this is not a problem in most cases.
 
    if (FIELD_OFFSET(ZIP_HEADER, file_name) +
        zip_hdr->file_name_length +
        zip_hdr->extra_field_length >= VFD_BYTES_PER_SECTOR) {
 
        VFDTRACE(0,
            ("[VFD] PKZIP header too long.\n"));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    //  allocate memory to store uncompressed data
 
    file_cache = (PUCHAR)LocalAlloc(LPTR, uncompressed);
 
    if (!file_cache) {
 
        VFDTRACE(0,
            ("[VFD] Failed to allocate file cache.\n"));
 
        return ERROR_OUTOFMEMORY;
    }
 
    //  initialize the zlib stream
 
    ZeroMemory(&stream, sizeof(stream));
 
    //  set initial input data information
 
    stream.next_in      = (PUCHAR)zip_hdr->file_name +
        zip_hdr->file_name_length + zip_hdr->extra_field_length;
 
    stream.avail_in     = VFD_BYTES_PER_SECTOR -
        FIELD_OFFSET(ZIP_HEADER, file_name) -
        zip_hdr->file_name_length - zip_hdr->extra_field_length;
 
    //  set output buffer information
 
    stream.next_out     = file_cache;
    stream.avail_out    = uncompressed;
 
    zlib_ret = inflateInit2(&stream, -MAX_WBITS);
 
    //  negative MAX_WBITS value passed to the inflateInit2() function
    //  indicates that there is no zlib header.
    //  In this case inflate() function requires an extra "dummy" byte
    //  after the compressed stream in order to complete decompression
    //  and return Z_STREAM_END.  However, both compressed and uncompressed
    //  data size are already known from the pkzip header, Z_STREAM_END
    //  is not absolutely necessary to know the completion of the operation.
 
    if (zlib_ret != Z_OK) {
        LocalFree(file_cache);
 
        VFDTRACE(0,
            ("[VFD] inflateInit2() failed - %s.\n",
            ZLIB_ERROR(zlib_ret)));
 
        return ERROR_INVALID_FUNCTION;
    }
 
    for (;;) {
 
        //  uncompress current block
 
        zlib_ret = inflate(&stream, Z_NO_FLUSH);
 
        if (zlib_ret != Z_OK) {
            if (zlib_ret == Z_STREAM_END) {
                ret = ERROR_SUCCESS;
            }
            else {
                VFDTRACE(0,
                    ("[VFD] inflate() failed - %s.\n",
                    ZLIB_ERROR(zlib_ret)));
 
                ret = ERROR_INVALID_FUNCTION;
            }
            break;
        }
 
        if (stream.total_out >= uncompressed) {
            //  uncompress completed - no need to wait for Z_STREAM_END
            //  (inflate() would return Z_STREAM_END on the next call)
            ret = ERROR_SUCCESS;
            break;
        }
 
        if (stream.total_in >= compressed) {
            //  somehow there is not enought compressed data
            ret = ERROR_INVALID_FUNCTION;
            break;
        }
 
        //  read next block from file
 
        if (!ReadFile(hFile, buf, VFD_BYTES_PER_SECTOR, &result, NULL) ||
            result <= 0) {
 
            ret = GetLastError();
 
            VFDTRACE(0,
                ("[VFD] Read compressed data - %s.\n",
                SystemMessage(ret)));
            break;
        }
 
        stream.avail_in = result;
        stream.next_in  = buf;
    }
 
    //  cleanup the zlib stream
 
    inflateEnd(&stream);
 
    //  set the return information
 
    if (ret == ERROR_SUCCESS) {
        *pBuffer    = file_cache;
        *pLength    = uncompressed;
    }
    else {
        LocalFree(file_cache);
    }
 
    VFDTRACE(0,
        ("[VFD] VfdExtractImz - OUT\n"));
 
    return ret;
}

Referenced by VfdOpenImage().

ExtractZipInfo()

DWORD ExtractZipInfo	(	HANDLE	hFile,
		ULONG *	pSize
	)

Definition at line 133 of file vfdzip.c.

{
    ZIP_HEADER      zip_hdr;
    DWORD           result;
    DWORD           ret;
 
    if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) != 0) {
        ret = GetLastError();
 
        VFDTRACE(0,
            ("SetFilePointer() - %s\n",
            SystemMessage(ret)));
 
        return ret;
    }
 
    if (!ReadFile(hFile, &zip_hdr, sizeof(zip_hdr), &result, NULL)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            ("ReadFile() - %s\n",
            SystemMessage(ret)));
 
        return ret;
    }
 
    if (result != sizeof(zip_hdr)                           ||
        zip_hdr.header_signature != ZIP_LOCAL_SIGNATURE     ||
        zip_hdr.compression_method != ZIP_METHOD_DEFLATED   ||
        (zip_hdr.general_flags & ZIP_FLAG_ENCRYPTED)) {
 
        VFDTRACE(0,
            ("[VFD] Invalid ZIP file\n"));
 
        return ERROR_INVALID_DATA;
    }
 
    //  correct (and supported) ZIP header detected
 
    *pSize = zip_hdr.uncompressed_size;
 
    return ERROR_SUCCESS;
}

Referenced by VfdCheckImageFile().

OF() [1/2]

voidpf zcalloc OF

(

(voidpf opaque, unsigned items, unsigned size)

)

Definition at line 73 of file vfdzip.c.

{
    UNREFERENCED_PARAMETER(opaque);
    return LocalAlloc(LPTR, items * size);
}

OF() [2/2]

void zcfree OF

(

(voidpf opaque, voidpf ptr)

)

Definition at line 79 of file vfdzip.c.

{
    UNREFERENCED_PARAMETER(opaque);
    LocalFree(ptr);
}