[pcsx_rearmed.git] / deps / libchdr / deps / zlib-1.3.1 / contrib / minizip / iowin32.c

/* iowin32.c -- IO base function header for compress/uncompress .zip
     Version 1.1, February 14h, 2010
     part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )

         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )

         Modifications for Zip64 support
         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )

     For more info read MiniZip_info.txt

*/

#include <stdlib.h>

#include "zlib.h"
#include "ioapi.h"
#include "iowin32.h"

#ifndef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
#endif

#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif


// see Include/shared/winapifamily.h in the Windows Kit
#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))

#if !defined(WINAPI_FAMILY_ONE_PARTITION)
#define WINAPI_FAMILY_ONE_PARTITION(PartitionSet, Partition) ((WINAPI_FAMILY & PartitionSet) == Partition)
#endif

#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
#define IOWIN32_USING_WINRT_API 1
#endif
#endif

typedef struct
{
    HANDLE hf;
    int error;
} WIN32FILE_IOWIN;


static void win32_translate_open_mode(int mode,
                                      DWORD* lpdwDesiredAccess,
                                      DWORD* lpdwCreationDisposition,
                                      DWORD* lpdwShareMode,
                                      DWORD* lpdwFlagsAndAttributes) {
    *lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0;

    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
    {
        *lpdwDesiredAccess = GENERIC_READ;
        *lpdwCreationDisposition = OPEN_EXISTING;
        *lpdwShareMode = FILE_SHARE_READ;
    }
    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
    {
        *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
        *lpdwCreationDisposition = OPEN_EXISTING;
    }
    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
    {
        *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
        *lpdwCreationDisposition = CREATE_ALWAYS;
    }
}

static voidpf win32_build_iowin(HANDLE hFile) {
    voidpf ret=NULL;

    if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
    {
        WIN32FILE_IOWIN w32fiow;
        w32fiow.hf = hFile;
        w32fiow.error = 0;
        ret = malloc(sizeof(WIN32FILE_IOWIN));

        if (ret==NULL)
            CloseHandle(hFile);
        else
            *((WIN32FILE_IOWIN*)ret) = w32fiow;
    }
    return ret;
}

voidpf ZCALLBACK win32_open64_file_func(voidpf opaque, const void* filename, int mode) {
    const char* mode_fopen = NULL;
    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
    HANDLE hFile = NULL;

    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);

#ifdef IOWIN32_USING_WINRT_API
#ifdef UNICODE
    if ((filename!=NULL) && (dwDesiredAccess != 0))
        hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
#else
    if ((filename!=NULL) && (dwDesiredAccess != 0))
    {
        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
    }
#endif
#else
    if ((filename!=NULL) && (dwDesiredAccess != 0))
        hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
#endif

    return win32_build_iowin(hFile);
}


voidpf ZCALLBACK win32_open64_file_funcA(voidpf opaque, const void* filename, int mode) {
    const char* mode_fopen = NULL;
    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
    HANDLE hFile = NULL;

    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);

#ifdef IOWIN32_USING_WINRT_API
    if ((filename!=NULL) && (dwDesiredAccess != 0))
    {
        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
    }
#else
    if ((filename!=NULL) && (dwDesiredAccess != 0))
        hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
#endif

    return win32_build_iowin(hFile);
}


voidpf ZCALLBACK win32_open64_file_funcW(voidpf opaque, const void* filename, int mode) {
    const char* mode_fopen = NULL;
    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
    HANDLE hFile = NULL;

    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);

#ifdef IOWIN32_USING_WINRT_API
    if ((filename!=NULL) && (dwDesiredAccess != 0))
        hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL);
#else
    if ((filename!=NULL) && (dwDesiredAccess != 0))
        hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
#endif

    return win32_build_iowin(hFile);
}


voidpf ZCALLBACK win32_open_file_func(voidpf opaque, const char* filename, int mode) {
    const char* mode_fopen = NULL;
    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
    HANDLE hFile = NULL;

    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);

#ifdef IOWIN32_USING_WINRT_API
#ifdef UNICODE
    if ((filename!=NULL) && (dwDesiredAccess != 0))
        hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
#else
    if ((filename!=NULL) && (dwDesiredAccess != 0))
    {
        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
    }
#endif
#else
    if ((filename!=NULL) && (dwDesiredAccess != 0))
        hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
#endif

    return win32_build_iowin(hFile);
}


uLong ZCALLBACK win32_read_file_func(voidpf opaque, voidpf stream, void* buf,uLong size) {
    uLong ret=0;
    HANDLE hFile = NULL;
    if (stream!=NULL)
        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;

    if (hFile != NULL)
    {
        if (!ReadFile(hFile, buf, size, &ret, NULL))
        {
            DWORD dwErr = GetLastError();
            if (dwErr == ERROR_HANDLE_EOF)
                dwErr = 0;
            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
        }
    }

    return ret;
}


uLong ZCALLBACK win32_write_file_func(voidpf opaque, voidpf stream, const void* buf, uLong size) {
    uLong ret=0;
    HANDLE hFile = NULL;
    if (stream!=NULL)
        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;

    if (hFile != NULL)
    {
        if (!WriteFile(hFile, buf, size, &ret, NULL))
        {
            DWORD dwErr = GetLastError();
            if (dwErr == ERROR_HANDLE_EOF)
                dwErr = 0;
            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
        }
    }

    return ret;
}

static BOOL MySetFilePointerEx(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod) {
#ifdef IOWIN32_USING_WINRT_API
    return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
#else
    LONG lHigh = pos.HighPart;
    DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod);
    BOOL fOk = TRUE;
    if (dwNewPos == 0xFFFFFFFF)
        if (GetLastError() != NO_ERROR)
            fOk = FALSE;
    if ((newPos != NULL) && (fOk))
    {
        newPos->LowPart = dwNewPos;
        newPos->HighPart = lHigh;
    }
    return fOk;
#endif
}

long ZCALLBACK win32_tell_file_func(voidpf opaque, voidpf stream) {
    long ret=-1;
    HANDLE hFile = NULL;
    if (stream!=NULL)
        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
    if (hFile != NULL)
    {
        LARGE_INTEGER pos;
        pos.QuadPart = 0;

        if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
        {
            DWORD dwErr = GetLastError();
            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
            ret = -1;
        }
        else
            ret=(long)pos.LowPart;
    }
    return ret;
}

ZPOS64_T ZCALLBACK win32_tell64_file_func(voidpf opaque, voidpf stream) {
    ZPOS64_T ret= (ZPOS64_T)-1;
    HANDLE hFile = NULL;
    if (stream!=NULL)
        hFile = ((WIN32FILE_IOWIN*)stream)->hf;

    if (hFile)
    {
        LARGE_INTEGER pos;
        pos.QuadPart = 0;

        if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
        {
            DWORD dwErr = GetLastError();
            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
            ret = (ZPOS64_T)-1;
        }
        else
            ret=pos.QuadPart;
    }
    return ret;
}


long ZCALLBACK win32_seek_file_func(voidpf opaque, voidpf stream, uLong offset, int origin) {
    DWORD dwMoveMethod=0xFFFFFFFF;
    HANDLE hFile = NULL;

    long ret=-1;
    if (stream!=NULL)
        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
    switch (origin)
    {
    case ZLIB_FILEFUNC_SEEK_CUR :
        dwMoveMethod = FILE_CURRENT;
        break;
    case ZLIB_FILEFUNC_SEEK_END :
        dwMoveMethod = FILE_END;
        break;
    case ZLIB_FILEFUNC_SEEK_SET :
        dwMoveMethod = FILE_BEGIN;
        break;
    default: return -1;
    }

    if (hFile != NULL)
    {
        LARGE_INTEGER pos;
        pos.QuadPart = offset;
        if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
        {
            DWORD dwErr = GetLastError();
            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
            ret = -1;
        }
        else
            ret=0;
    }
    return ret;
}

long ZCALLBACK win32_seek64_file_func(voidpf opaque, voidpf stream, ZPOS64_T offset, int origin) {
    DWORD dwMoveMethod=0xFFFFFFFF;
    HANDLE hFile = NULL;
    long ret=-1;

    if (stream!=NULL)
        hFile = ((WIN32FILE_IOWIN*)stream)->hf;

    switch (origin)
    {
        case ZLIB_FILEFUNC_SEEK_CUR :
            dwMoveMethod = FILE_CURRENT;
            break;
        case ZLIB_FILEFUNC_SEEK_END :
            dwMoveMethod = FILE_END;
            break;
        case ZLIB_FILEFUNC_SEEK_SET :
            dwMoveMethod = FILE_BEGIN;
            break;
        default: return -1;
    }

    if (hFile)
    {
        LARGE_INTEGER pos;
        pos.QuadPart = offset;
        if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
        {
            DWORD dwErr = GetLastError();
            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
            ret = -1;
        }
        else
            ret=0;
    }
    return ret;
}

int ZCALLBACK win32_close_file_func(voidpf opaque, voidpf stream) {
    int ret=-1;

    if (stream!=NULL)
    {
        HANDLE hFile;
        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
        if (hFile != NULL)
        {
            CloseHandle(hFile);
            ret=0;
        }
        free(stream);
    }
    return ret;
}

int ZCALLBACK win32_error_file_func(voidpf opaque, voidpf stream) {
    int ret=-1;
    if (stream!=NULL)
    {
        ret = ((WIN32FILE_IOWIN*)stream) -> error;
    }
    return ret;
}

void fill_win32_filefunc(zlib_filefunc_def* pzlib_filefunc_def) {
    pzlib_filefunc_def->zopen_file = win32_open_file_func;
    pzlib_filefunc_def->zread_file = win32_read_file_func;
    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
    pzlib_filefunc_def->ztell_file = win32_tell_file_func;
    pzlib_filefunc_def->zseek_file = win32_seek_file_func;
    pzlib_filefunc_def->zclose_file = win32_close_file_func;
    pzlib_filefunc_def->zerror_file = win32_error_file_func;
    pzlib_filefunc_def->opaque = NULL;
}

void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def) {
    pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
    pzlib_filefunc_def->zread_file = win32_read_file_func;
    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
    pzlib_filefunc_def->zclose_file = win32_close_file_func;
    pzlib_filefunc_def->zerror_file = win32_error_file_func;
    pzlib_filefunc_def->opaque = NULL;
}


void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def) {
    pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
    pzlib_filefunc_def->zread_file = win32_read_file_func;
    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
    pzlib_filefunc_def->zclose_file = win32_close_file_func;
    pzlib_filefunc_def->zerror_file = win32_error_file_func;
    pzlib_filefunc_def->opaque = NULL;
}


void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def) {
    pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
    pzlib_filefunc_def->zread_file = win32_read_file_func;
    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
    pzlib_filefunc_def->zclose_file = win32_close_file_func;
    pzlib_filefunc_def->zerror_file = win32_error_file_func;
    pzlib_filefunc_def->opaque = NULL;
}
Commit	Line	Data
9e052883	1	/* iowin32.c -- IO base function header for compress/uncompress .zip
	2	Version 1.1, February 14h, 2010
	3	part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
	4
	5	Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
	6
	7	Modifications for Zip64 support
	8	Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
	9
	10	For more info read MiniZip_info.txt
	11
	12	*/
	13
	14	#include <stdlib.h>
	15
	16	#include "zlib.h"
	17	#include "ioapi.h"
	18	#include "iowin32.h"
	19
	20	#ifndef INVALID_HANDLE_VALUE
	21	#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
	22	#endif
	23
	24	#ifndef INVALID_SET_FILE_POINTER
	25	#define INVALID_SET_FILE_POINTER ((DWORD)-1)
	26	#endif
	27
	28
	29	// see Include/shared/winapifamily.h in the Windows Kit
	30	#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
	31
	32	#if !defined(WINAPI_FAMILY_ONE_PARTITION)
	33	#define WINAPI_FAMILY_ONE_PARTITION(PartitionSet, Partition) ((WINAPI_FAMILY & PartitionSet) == Partition)
	34	#endif
	35
	36	#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
	37	#define IOWIN32_USING_WINRT_API 1
	38	#endif
	39	#endif
	40
9e052883	41	typedef struct
	42	{
	43	HANDLE hf;
	44	int error;
	45	} WIN32FILE_IOWIN;
	46
	47
	48	static void win32_translate_open_mode(int mode,
	49	DWORD* lpdwDesiredAccess,
	50	DWORD* lpdwCreationDisposition,
	51	DWORD* lpdwShareMode,
648db22b	52	DWORD* lpdwFlagsAndAttributes) {
9e052883	53	lpdwDesiredAccess = lpdwShareMode = lpdwFlagsAndAttributes = lpdwCreationDisposition = 0;
	54
	55	if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
	56	{
	57	*lpdwDesiredAccess = GENERIC_READ;
	58	*lpdwCreationDisposition = OPEN_EXISTING;
	59	*lpdwShareMode = FILE_SHARE_READ;
	60	}
	61	else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
	62	{
	63	*lpdwDesiredAccess = GENERIC_WRITE \| GENERIC_READ;
	64	*lpdwCreationDisposition = OPEN_EXISTING;
	65	}
	66	else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
	67	{
	68	*lpdwDesiredAccess = GENERIC_WRITE \| GENERIC_READ;
	69	*lpdwCreationDisposition = CREATE_ALWAYS;
	70	}
	71	}
	72
648db22b	73	static voidpf win32_build_iowin(HANDLE hFile) {
9e052883	74	voidpf ret=NULL;
	75
	76	if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
	77	{
	78	WIN32FILE_IOWIN w32fiow;
	79	w32fiow.hf = hFile;
	80	w32fiow.error = 0;
	81	ret = malloc(sizeof(WIN32FILE_IOWIN));
	82
	83	if (ret==NULL)
	84	CloseHandle(hFile);
	85	else
	86	((WIN32FILE_IOWIN)ret) = w32fiow;
	87	}
	88	return ret;
	89	}
	90
648db22b	91	voidpf ZCALLBACK win32_open64_file_func(voidpf opaque, const void* filename, int mode) {
9e052883	92	const char* mode_fopen = NULL;
	93	DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
	94	HANDLE hFile = NULL;
	95
	96	win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
	97
	98	#ifdef IOWIN32_USING_WINRT_API
	99	#ifdef UNICODE
	100	if ((filename!=NULL) && (dwDesiredAccess != 0))
	101	hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
	102	#else
	103	if ((filename!=NULL) && (dwDesiredAccess != 0))
	104	{
	105	WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
	106	MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
	107	hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
	108	}
	109	#endif
	110	#else
	111	if ((filename!=NULL) && (dwDesiredAccess != 0))
	112	hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
	113	#endif
	114
	115	return win32_build_iowin(hFile);
	116	}
	117
	118
648db22b	119	voidpf ZCALLBACK win32_open64_file_funcA(voidpf opaque, const void* filename, int mode) {
9e052883	120	const char* mode_fopen = NULL;
	121	DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
	122	HANDLE hFile = NULL;
	123
	124	win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
	125
	126	#ifdef IOWIN32_USING_WINRT_API
	127	if ((filename!=NULL) && (dwDesiredAccess != 0))
	128	{
	129	WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
	130	MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
	131	hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
	132	}
	133	#else
	134	if ((filename!=NULL) && (dwDesiredAccess != 0))
	135	hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
	136	#endif
	137
	138	return win32_build_iowin(hFile);
	139	}
	140
	141
648db22b	142	voidpf ZCALLBACK win32_open64_file_funcW(voidpf opaque, const void* filename, int mode) {
9e052883	143	const char* mode_fopen = NULL;
	144	DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
	145	HANDLE hFile = NULL;
	146
	147	win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
	148
	149	#ifdef IOWIN32_USING_WINRT_API
	150	if ((filename!=NULL) && (dwDesiredAccess != 0))
	151	hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL);
	152	#else
	153	if ((filename!=NULL) && (dwDesiredAccess != 0))
	154	hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
	155	#endif
	156
	157	return win32_build_iowin(hFile);
	158	}
	159
	160
648db22b	161	voidpf ZCALLBACK win32_open_file_func(voidpf opaque, const char* filename, int mode) {
9e052883	162	const char* mode_fopen = NULL;
	163	DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
	164	HANDLE hFile = NULL;
	165
	166	win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
	167
	168	#ifdef IOWIN32_USING_WINRT_API
	169	#ifdef UNICODE
	170	if ((filename!=NULL) && (dwDesiredAccess != 0))
	171	hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
	172	#else
	173	if ((filename!=NULL) && (dwDesiredAccess != 0))
	174	{
	175	WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
	176	MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
	177	hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
	178	}
	179	#endif
	180	#else
	181	if ((filename!=NULL) && (dwDesiredAccess != 0))
	182	hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
	183	#endif
	184
	185	return win32_build_iowin(hFile);
	186	}
	187
	188
648db22b	189	uLong ZCALLBACK win32_read_file_func(voidpf opaque, voidpf stream, void* buf,uLong size) {
9e052883	190	uLong ret=0;
	191	HANDLE hFile = NULL;
	192	if (stream!=NULL)
	193	hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
	194
	195	if (hFile != NULL)
	196	{
	197	if (!ReadFile(hFile, buf, size, &ret, NULL))
	198	{
	199	DWORD dwErr = GetLastError();
	200	if (dwErr == ERROR_HANDLE_EOF)
	201	dwErr = 0;
	202	((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
	203	}
	204	}
	205
	206	return ret;
	207	}
	208
	209
648db22b	210	uLong ZCALLBACK win32_write_file_func(voidpf opaque, voidpf stream, const void* buf, uLong size) {
9e052883	211	uLong ret=0;
	212	HANDLE hFile = NULL;
	213	if (stream!=NULL)
	214	hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
	215
	216	if (hFile != NULL)
	217	{
	218	if (!WriteFile(hFile, buf, size, &ret, NULL))
	219	{
	220	DWORD dwErr = GetLastError();
	221	if (dwErr == ERROR_HANDLE_EOF)
	222	dwErr = 0;
	223	((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
	224	}
	225	}
	226
	227	return ret;
	228	}
	229
648db22b	230	static BOOL MySetFilePointerEx(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod) {
9e052883	231	#ifdef IOWIN32_USING_WINRT_API
	232	return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
	233	#else
	234	LONG lHigh = pos.HighPart;
	235	DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod);
	236	BOOL fOk = TRUE;
	237	if (dwNewPos == 0xFFFFFFFF)
	238	if (GetLastError() != NO_ERROR)
	239	fOk = FALSE;
	240	if ((newPos != NULL) && (fOk))
	241	{
	242	newPos->LowPart = dwNewPos;
	243	newPos->HighPart = lHigh;
	244	}
	245	return fOk;
	246	#endif
	247	}
	248
648db22b	249	long ZCALLBACK win32_tell_file_func(voidpf opaque, voidpf stream) {
9e052883	250	long ret=-1;
	251	HANDLE hFile = NULL;
	252	if (stream!=NULL)
	253	hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
	254	if (hFile != NULL)
	255	{
	256	LARGE_INTEGER pos;
	257	pos.QuadPart = 0;
	258
	259	if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
	260	{
	261	DWORD dwErr = GetLastError();
	262	((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
	263	ret = -1;
	264	}
	265	else
	266	ret=(long)pos.LowPart;
	267	}
	268	return ret;
	269	}
	270
648db22b	271	ZPOS64_T ZCALLBACK win32_tell64_file_func(voidpf opaque, voidpf stream) {
9e052883	272	ZPOS64_T ret= (ZPOS64_T)-1;
	273	HANDLE hFile = NULL;
	274	if (stream!=NULL)
	275	hFile = ((WIN32FILE_IOWIN*)stream)->hf;
	276
	277	if (hFile)
	278	{
	279	LARGE_INTEGER pos;
	280	pos.QuadPart = 0;
	281
	282	if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
	283	{
	284	DWORD dwErr = GetLastError();
	285	((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
	286	ret = (ZPOS64_T)-1;
	287	}
	288	else
	289	ret=pos.QuadPart;
	290	}
	291	return ret;
	292	}
	293
	294
648db22b	295	long ZCALLBACK win32_seek_file_func(voidpf opaque, voidpf stream, uLong offset, int origin) {
9e052883	296	DWORD dwMoveMethod=0xFFFFFFFF;
	297	HANDLE hFile = NULL;
	298
	299	long ret=-1;
	300	if (stream!=NULL)
	301	hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
	302	switch (origin)
	303	{
	304	case ZLIB_FILEFUNC_SEEK_CUR :
	305	dwMoveMethod = FILE_CURRENT;
	306	break;
	307	case ZLIB_FILEFUNC_SEEK_END :
	308	dwMoveMethod = FILE_END;
	309	break;
	310	case ZLIB_FILEFUNC_SEEK_SET :
	311	dwMoveMethod = FILE_BEGIN;
	312	break;
	313	default: return -1;
	314	}
	315
	316	if (hFile != NULL)
	317	{
	318	LARGE_INTEGER pos;
	319	pos.QuadPart = offset;
	320	if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
	321	{
	322	DWORD dwErr = GetLastError();
	323	((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
	324	ret = -1;
	325	}
	326	else
	327	ret=0;
	328	}
	329	return ret;
	330	}
	331
648db22b	332	long ZCALLBACK win32_seek64_file_func(voidpf opaque, voidpf stream, ZPOS64_T offset, int origin) {
9e052883	333	DWORD dwMoveMethod=0xFFFFFFFF;
	334	HANDLE hFile = NULL;
	335	long ret=-1;
	336
	337	if (stream!=NULL)
	338	hFile = ((WIN32FILE_IOWIN*)stream)->hf;
	339
	340	switch (origin)
	341	{
	342	case ZLIB_FILEFUNC_SEEK_CUR :
	343	dwMoveMethod = FILE_CURRENT;
	344	break;
	345	case ZLIB_FILEFUNC_SEEK_END :
	346	dwMoveMethod = FILE_END;
	347	break;
	348	case ZLIB_FILEFUNC_SEEK_SET :
	349	dwMoveMethod = FILE_BEGIN;
	350	break;
	351	default: return -1;
	352	}
	353
	354	if (hFile)
	355	{
	356	LARGE_INTEGER pos;
	357	pos.QuadPart = offset;
	358	if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
	359	{
	360	DWORD dwErr = GetLastError();
	361	((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
	362	ret = -1;
	363	}
	364	else
	365	ret=0;
	366	}
	367	return ret;
	368	}
	369
648db22b	370	int ZCALLBACK win32_close_file_func(voidpf opaque, voidpf stream) {
9e052883	371	int ret=-1;
	372
	373	if (stream!=NULL)
	374	{
	375	HANDLE hFile;
	376	hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
	377	if (hFile != NULL)
	378	{
	379	CloseHandle(hFile);
	380	ret=0;
	381	}
	382	free(stream);
	383	}
	384	return ret;
	385	}
	386
648db22b	387	int ZCALLBACK win32_error_file_func(voidpf opaque, voidpf stream) {
9e052883	388	int ret=-1;
	389	if (stream!=NULL)
	390	{
	391	ret = ((WIN32FILE_IOWIN*)stream) -> error;
	392	}
	393	return ret;
	394	}
	395
648db22b	396	void fill_win32_filefunc(zlib_filefunc_def* pzlib_filefunc_def) {
9e052883	397	pzlib_filefunc_def->zopen_file = win32_open_file_func;
	398	pzlib_filefunc_def->zread_file = win32_read_file_func;
	399	pzlib_filefunc_def->zwrite_file = win32_write_file_func;
	400	pzlib_filefunc_def->ztell_file = win32_tell_file_func;
	401	pzlib_filefunc_def->zseek_file = win32_seek_file_func;
	402	pzlib_filefunc_def->zclose_file = win32_close_file_func;
	403	pzlib_filefunc_def->zerror_file = win32_error_file_func;
	404	pzlib_filefunc_def->opaque = NULL;
	405	}
	406
648db22b	407	void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def) {
9e052883	408	pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
	409	pzlib_filefunc_def->zread_file = win32_read_file_func;
	410	pzlib_filefunc_def->zwrite_file = win32_write_file_func;
	411	pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
	412	pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
	413	pzlib_filefunc_def->zclose_file = win32_close_file_func;
	414	pzlib_filefunc_def->zerror_file = win32_error_file_func;
	415	pzlib_filefunc_def->opaque = NULL;
	416	}
	417
	418
648db22b	419	void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def) {
9e052883	420	pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
	421	pzlib_filefunc_def->zread_file = win32_read_file_func;
	422	pzlib_filefunc_def->zwrite_file = win32_write_file_func;
	423	pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
	424	pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
	425	pzlib_filefunc_def->zclose_file = win32_close_file_func;
	426	pzlib_filefunc_def->zerror_file = win32_error_file_func;
	427	pzlib_filefunc_def->opaque = NULL;
	428	}
	429
	430
648db22b	431	void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def) {
9e052883	432	pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
	433	pzlib_filefunc_def->zread_file = win32_read_file_func;
	434	pzlib_filefunc_def->zwrite_file = win32_write_file_func;
	435	pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
	436	pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
	437	pzlib_filefunc_def->zclose_file = win32_close_file_func;
	438	pzlib_filefunc_def->zerror_file = win32_error_file_func;
	439	pzlib_filefunc_def->opaque = NULL;
	440	}