src/libgame/zip/iowin32.c

   1 /* iowin32.c -- IO base function header for compress/uncompress .zip
   2    Version 1.2.0, September 16th, 2017
   3    part of the MiniZip project
   4
   5    Copyright (C) 2012-2017 Nathan Moinvaziri
   6      https://github.com/nmoinvaz/minizip
   7    Copyright (C) 2009-2010 Mathias Svensson
   8      Modifications for Zip64 support
   9      http://result42.com
  10    Copyright (C) 1998-2010 Gilles Vollant
  11      http://www.winimage.com/zLibDll/minizip.html
  12
  13    This program is distributed under the terms of the same license as zlib.
  14    See the accompanying LICENSE file for the full text of the license.
  15 */
  16
  17 #ifdef _WIN32
  18
  19 #include <stdlib.h>
  20 #include <tchar.h>
  21
  22 #include "zlib.h"
  23 #include "ioapi.h"
  24 #include "iowin32.h"
  25
  26 #ifndef INVALID_HANDLE_VALUE
  27 #  define INVALID_HANDLE_VALUE (0xFFFFFFFF)
  28 #endif
  29
  30 #ifndef INVALID_SET_FILE_POINTER
  31 #  define INVALID_SET_FILE_POINTER ((DWORD)-1)
  32 #endif
  33
  34 #if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
  35 #  if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
  36 #    define IOWIN32_USING_WINRT_API 1
  37 #  endif
  38 #endif
  39
  40 voidpf   ZCALLBACK win32_open_file_func     (voidpf opaque, const char *filename, int mode);
  41 uint32_t ZCALLBACK win32_read_file_func     (voidpf opaque, voidpf stream, void* buf, uint32_t size);
  42 uint32_t ZCALLBACK win32_write_file_func    (voidpf opaque, voidpf stream, const void *buf, uint32_t size);
  43 uint64_t ZCALLBACK win32_tell64_file_func   (voidpf opaque, voidpf stream);
  44 long     ZCALLBACK win32_seek64_file_func   (voidpf opaque, voidpf stream, uint64_t offset, int origin);
  45 int      ZCALLBACK win32_close_file_func    (voidpf opaque, voidpf stream);
  46 int      ZCALLBACK win32_error_file_func    (voidpf opaque, voidpf stream);
  47
  48 typedef struct
  49 {
  50     HANDLE hf;
  51     int error;
  52     void *filename;
  53     int filenameLength;
  54 } WIN32FILE_IOWIN;
  55
  56
  57 static void win32_translate_open_mode(int mode,
  58                                       DWORD* lpdwDesiredAccess,
  59                                       DWORD* lpdwCreationDisposition,
  60                                       DWORD* lpdwShareMode,
  61                                       DWORD* lpdwFlagsAndAttributes)
  62 {
  63     *lpdwDesiredAccess = 0;
  64     *lpdwShareMode = 0;
  65     *lpdwCreationDisposition = 0;
  66     *lpdwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
  67
  68     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
  69     {
  70         *lpdwDesiredAccess = GENERIC_READ;
  71         *lpdwCreationDisposition = OPEN_EXISTING;
  72         *lpdwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
  73     }
  74     else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
  75     {
  76         *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
  77         *lpdwCreationDisposition = OPEN_EXISTING;
  78     }
  79     else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
  80     {
  81         *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
  82         *lpdwCreationDisposition = CREATE_ALWAYS;
  83     }
  84 }
  85
  86 static voidpf win32_build_iowin(HANDLE hFile)
  87 {
  88     WIN32FILE_IOWIN *iowin = NULL;
  89
  90     if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
  91     {
  92         iowin = (WIN32FILE_IOWIN *)malloc(sizeof(WIN32FILE_IOWIN));
  93         if (iowin == NULL)
  94         {
  95             CloseHandle(hFile);
  96             return NULL;
  97         }
  98         memset(iowin, 0, sizeof(WIN32FILE_IOWIN));
  99         iowin->hf = hFile;
 100     }
 101     return (voidpf)iowin;
 102 }
 103
 104 static voidpf ZCALLBACK win32_open64_file_func(voidpf opaque, const void *filename, int mode)
 105 {
 106     DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes;
 107     HANDLE hFile = NULL;
 108     WIN32FILE_IOWIN *iowin = NULL;
 109
 110     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
 111
 112     if ((filename != NULL) && (dwDesiredAccess != 0))
 113     {
 114 #ifdef IOWIN32_USING_WINRT_API
 115 #ifdef UNICODE
 116         hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
 117 #else
 118         WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
 119         MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200);
 120         hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
 121 #endif
 122 #else
 123         hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
 124 #endif
 125     }
 126
 127     iowin = win32_build_iowin(hFile);
 128     if (iowin == NULL)
 129         return NULL;
 130     iowin->filenameLength = _tcslen(filename) + 1;
 131     iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(TCHAR));
 132     _tcsncpy(iowin->filename, filename, iowin->filenameLength);
 133     return iowin;
 134 }
 135
 136 static voidpf ZCALLBACK win32_open64_file_funcA(voidpf opaque, const void *filename, int mode)
 137 {
 138     DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes ;
 139     HANDLE hFile = NULL;
 140     WIN32FILE_IOWIN *iowin = NULL;
 141
 142     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
 143
 144     if ((filename != NULL) && (dwDesiredAccess != 0))
 145     {
 146 #ifdef IOWIN32_USING_WINRT_API
 147         WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
 148         MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200);
 149         hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
 150 #else
 151         hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
 152 #endif
 153     }
 154
 155     iowin = win32_build_iowin(hFile);
 156     if (iowin == NULL)
 157         return NULL;
 158     iowin->filenameLength = strlen(filename) + 1;
 159     iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(char));
 160     strncpy(iowin->filename, filename, iowin->filenameLength);
 161     return iowin;
 162 }
 163
 164 static voidpf ZCALLBACK win32_open64_file_funcW(voidpf opaque, const void *filename, int mode)
 165 {
 166     DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes;
 167     HANDLE hFile = NULL;
 168     WIN32FILE_IOWIN *iowin = NULL;
 169
 170     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
 171
 172     if ((filename != NULL) && (dwDesiredAccess != 0))
 173     {
 174 #ifdef IOWIN32_USING_WINRT_API
 175         hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
 176 #else
 177         hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
 178 #endif
 179     }
 180
 181     iowin = win32_build_iowin(hFile);
 182     if (iowin == NULL)
 183         return NULL;
 184     if (iowin->filename == NULL)
 185     {
 186         iowin->filenameLength = wcslen(filename) + 1;
 187         iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(WCHAR));
 188         wcsncpy(iowin->filename, filename, iowin->filenameLength);
 189     }
 190     return iowin;
 191 }
 192
 193 voidpf ZCALLBACK win32_open_file_func(voidpf opaque, const char *filename, int mode)
 194 {
 195     DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes ;
 196     HANDLE hFile = NULL;
 197     WIN32FILE_IOWIN *iowin = NULL;
 198
 199     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
 200
 201     if ((filename != NULL) && (dwDesiredAccess != 0))
 202     {
 203 #ifdef IOWIN32_USING_WINRT_API
 204 #ifdef UNICODE
 205         hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
 206 #else
 207         WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
 208         MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200);
 209         hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
 210 #endif
 211 #else
 212         hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
 213 #endif
 214     }
 215
 216     iowin = win32_build_iowin(hFile);
 217     if (iowin == NULL)
 218         return NULL;
 219     iowin->filenameLength = _tcslen((TCHAR*)filename) + 1;
 220     iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(TCHAR));
 221     _tcsncpy(iowin->filename, (TCHAR*)filename, iowin->filenameLength);
 222     return iowin;
 223 }
 224
 225 static voidpf ZCALLBACK win32_opendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
 226 {
 227     WIN32FILE_IOWIN *iowin = NULL;
 228     TCHAR *diskFilename = NULL;
 229     voidpf ret = NULL;
 230     int i = 0;
 231
 232     if (stream == NULL)
 233         return NULL;
 234     iowin = (WIN32FILE_IOWIN*)stream;
 235     diskFilename = (TCHAR*)malloc(iowin->filenameLength * sizeof(TCHAR));
 236     _tcsncpy(diskFilename, iowin->filename, iowin->filenameLength);
 237     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
 238     {
 239         if (diskFilename[i] != _T('.'))
 240             continue;
 241         _sntprintf(&diskFilename[i], iowin->filenameLength - i, _T(".z%02d"), number_disk + 1);
 242         break;
 243     }
 244     if (i >= 0)
 245         ret = win32_open64_file_func(opaque, (char*)diskFilename, mode);
 246     free(diskFilename);
 247     return ret;
 248 }
 249
 250 static voidpf ZCALLBACK win32_opendisk64_file_funcW(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
 251 {
 252     WIN32FILE_IOWIN *iowin = NULL;
 253     WCHAR *diskFilename = NULL;
 254     voidpf ret = NULL;
 255     int i = 0;
 256
 257     if (stream == NULL)
 258         return NULL;
 259     iowin = (WIN32FILE_IOWIN*)stream;
 260     diskFilename = (WCHAR*)malloc((iowin->filenameLength + 10) * sizeof(WCHAR));
 261     wcsncpy(diskFilename, iowin->filename, iowin->filenameLength);
 262     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
 263     {
 264         if (diskFilename[i] != L'.')
 265             continue;
 266         _snwprintf(&diskFilename[i], (iowin->filenameLength + 10) - i, L".z%02d", number_disk + 1);
 267         break;
 268     }
 269     if (i >= 0)
 270         ret = win32_open64_file_funcW(opaque, diskFilename, mode);
 271     free(diskFilename);
 272     return ret;
 273 }
 274
 275 static voidpf ZCALLBACK win32_opendisk64_file_funcA(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
 276 {
 277     WIN32FILE_IOWIN *iowin = NULL;
 278     char *diskFilename = NULL;
 279     voidpf ret = NULL;
 280     int i = 0;
 281
 282     if (stream == NULL)
 283         return NULL;
 284     iowin = (WIN32FILE_IOWIN*)stream;
 285     diskFilename = (char*)malloc(iowin->filenameLength * sizeof(char));
 286     strncpy(diskFilename, iowin->filename, iowin->filenameLength);
 287     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
 288     {
 289         if (diskFilename[i] != '.')
 290             continue;
 291         _snprintf(&diskFilename[i], iowin->filenameLength - i, ".z%02d", number_disk + 1);
 292         break;
 293     }
 294     if (i >= 0)
 295         ret = win32_open64_file_funcA(opaque, diskFilename, mode);
 296     free(diskFilename);
 297     return ret;
 298 }
 299
 300 static voidpf ZCALLBACK win32_opendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
 301 {
 302     WIN32FILE_IOWIN *iowin = NULL;
 303     TCHAR *diskFilename = NULL;
 304     voidpf ret = NULL;
 305     int i = 0;
 306
 307     if (stream == NULL)
 308         return NULL;
 309     iowin = (WIN32FILE_IOWIN*)stream;
 310     diskFilename = (TCHAR*)malloc(iowin->filenameLength * sizeof(TCHAR));
 311     _tcsncpy(diskFilename, iowin->filename, iowin->filenameLength);
 312     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
 313     {
 314         if (diskFilename[i] != _T('.'))
 315             continue;
 316         _sntprintf(&diskFilename[i], iowin->filenameLength - i, _T(".z%02d"), number_disk + 1);
 317         break;
 318     }
 319     if (i >= 0)
 320         ret = win32_open_file_func(opaque, (char*)diskFilename, mode);
 321     free(diskFilename);
 322     return ret;
 323 }
 324
 325 uint32_t ZCALLBACK win32_read_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size)
 326 {
 327     DWORD ret = 0;
 328     HANDLE hFile = NULL;
 329     if (stream != NULL)
 330         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
 331
 332     if (hFile != NULL)
 333     {
 334         if (!ReadFile(hFile, buf, size, &ret, NULL))
 335         {
 336             DWORD dwErr = GetLastError();
 337             if (dwErr == ERROR_HANDLE_EOF)
 338                 dwErr = 0;
 339             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
 340         }
 341     }
 342
 343     return (uint32_t)ret;
 344 }
 345
 346 uint32_t ZCALLBACK win32_write_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size)
 347 {
 348     DWORD ret = 0;
 349     HANDLE hFile = NULL;
 350     if (stream != NULL)
 351         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
 352
 353     if (hFile != NULL)
 354     {
 355         if (!WriteFile(hFile, buf, size, &ret, NULL))
 356         {
 357             DWORD dwErr = GetLastError();
 358             if (dwErr == ERROR_HANDLE_EOF)
 359                 dwErr = 0;
 360             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
 361         }
 362     }
 363
 364     return (uint32_t)ret;
 365 }
 366
 367 static BOOL win32_setfilepointer_internal(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod)
 368 {
 369 #ifdef IOWIN32_USING_WINRT_API
 370     return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
 371 #else
 372     LONG lHigh = pos.HighPart;
 373     BOOL ret = TRUE;
 374     DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod);
 375     if ((dwNewPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
 376         ret = FALSE;
 377     if ((newPos != NULL) && (ret))
 378     {
 379         newPos->LowPart = dwNewPos;
 380         newPos->HighPart = lHigh;
 381     }
 382     return ret;
 383 #endif
 384 }
 385
 386 static long ZCALLBACK win32_tell_file_func(voidpf opaque, voidpf stream)
 387 {
 388     long ret = -1;
 389     HANDLE hFile = NULL;
 390     if (stream != NULL)
 391         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
 392     if (hFile != NULL)
 393     {
 394         LARGE_INTEGER pos;
 395         pos.QuadPart = 0;
 396         if (!win32_setfilepointer_internal(hFile, pos, &pos, FILE_CURRENT))
 397         {
 398             DWORD dwErr = GetLastError();
 399             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
 400             ret = -1;
 401         }
 402         else
 403             ret = (long)pos.LowPart;
 404     }
 405     return ret;
 406 }
 407
 408 uint64_t ZCALLBACK win32_tell64_file_func(voidpf opaque, voidpf stream)
 409 {
 410     uint64_t ret = (uint64_t)-1;
 411     HANDLE hFile = NULL;
 412     if (stream != NULL)
 413         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
 414
 415     if (hFile)
 416     {
 417         LARGE_INTEGER pos;
 418         pos.QuadPart = 0;
 419         if (!win32_setfilepointer_internal(hFile, pos, &pos, FILE_CURRENT))
 420         {
 421             DWORD dwErr = GetLastError();
 422             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
 423             ret = (uint64_t)-1;
 424         }
 425         else
 426             ret = pos.QuadPart;
 427     }
 428     return ret;
 429 }
 430
 431 static long ZCALLBACK win32_seek_file_func(voidpf opaque, voidpf stream, uint32_t offset, int origin)
 432 {
 433     DWORD dwMoveMethod = 0xFFFFFFFF;
 434     HANDLE hFile = NULL;
 435     long ret = -1;
 436
 437     if (stream != NULL)
 438         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
 439
 440     switch (origin)
 441     {
 442         case ZLIB_FILEFUNC_SEEK_CUR:
 443             dwMoveMethod = FILE_CURRENT;
 444             break;
 445         case ZLIB_FILEFUNC_SEEK_END:
 446             dwMoveMethod = FILE_END;
 447             break;
 448         case ZLIB_FILEFUNC_SEEK_SET:
 449             dwMoveMethod = FILE_BEGIN;
 450             break;
 451         default:
 452             return -1;
 453     }
 454
 455     if (hFile != NULL)
 456     {
 457         LARGE_INTEGER pos;
 458         pos.QuadPart = offset;
 459         if (!win32_setfilepointer_internal(hFile, pos, NULL, dwMoveMethod))
 460         {
 461             DWORD dwErr = GetLastError();
 462             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
 463             ret = -1;
 464         }
 465         else
 466             ret = 0;
 467     }
 468     return ret;
 469 }
 470
 471 long ZCALLBACK win32_seek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin)
 472 {
 473     DWORD dwMoveMethod = 0xFFFFFFFF;
 474     HANDLE hFile = NULL;
 475     long ret = -1;
 476
 477     if (stream != NULL)
 478         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
 479
 480     switch (origin)
 481     {
 482         case ZLIB_FILEFUNC_SEEK_CUR:
 483             dwMoveMethod = FILE_CURRENT;
 484             break;
 485         case ZLIB_FILEFUNC_SEEK_END:
 486             dwMoveMethod = FILE_END;
 487             break;
 488         case ZLIB_FILEFUNC_SEEK_SET:
 489             dwMoveMethod = FILE_BEGIN;
 490             break;
 491         default:
 492             return -1;
 493     }
 494
 495     if (hFile)
 496     {
 497         LARGE_INTEGER pos;
 498         pos.QuadPart = offset;
 499         if (!win32_setfilepointer_internal(hFile, pos, NULL, dwMoveMethod))
 500         {
 501             DWORD dwErr = GetLastError();
 502             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
 503             ret = -1;
 504         }
 505         else
 506             ret = 0;
 507     }
 508     return ret;
 509 }
 510
 511 int ZCALLBACK win32_close_file_func(voidpf opaque, voidpf stream)
 512 {
 513     WIN32FILE_IOWIN* iowin = NULL;
 514     int ret = -1;
 515
 516     if (stream == NULL)
 517         return ret;
 518     iowin = ((WIN32FILE_IOWIN*)stream);
 519     if (iowin->filename != NULL)
 520         free(iowin->filename);
 521     if (iowin->hf != NULL)
 522     {
 523         CloseHandle(iowin->hf);
 524         ret=0;
 525     }
 526     free(stream);
 527     return ret;
 528 }
 529
 530 int ZCALLBACK win32_error_file_func(voidpf opaque, voidpf stream)
 531 {
 532     int ret = -1;
 533     if (stream == NULL)
 534         return ret;
 535     ret = ((WIN32FILE_IOWIN*)stream)->error;
 536     return ret;
 537 }
 538
 539 void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
 540 {
 541     pzlib_filefunc_def->zopen_file = win32_open_file_func;
 542     pzlib_filefunc_def->zopendisk_file = win32_opendisk_file_func;
 543     pzlib_filefunc_def->zread_file = win32_read_file_func;
 544     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
 545     pzlib_filefunc_def->ztell_file = win32_tell_file_func;
 546     pzlib_filefunc_def->zseek_file = win32_seek_file_func;
 547     pzlib_filefunc_def->zclose_file = win32_close_file_func;
 548     pzlib_filefunc_def->zerror_file = win32_error_file_func;
 549     pzlib_filefunc_def->opaque = NULL;
 550 }
 551
 552 void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def)
 553 {
 554     pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
 555     pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_func;
 556     pzlib_filefunc_def->zread_file = win32_read_file_func;
 557     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
 558     pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
 559     pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
 560     pzlib_filefunc_def->zclose_file = win32_close_file_func;
 561     pzlib_filefunc_def->zerror_file = win32_error_file_func;
 562     pzlib_filefunc_def->opaque = NULL;
 563 }
 564
 565 void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def)
 566 {
 567     pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
 568     pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_funcA;
 569     pzlib_filefunc_def->zread_file = win32_read_file_func;
 570     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
 571     pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
 572     pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
 573     pzlib_filefunc_def->zclose_file = win32_close_file_func;
 574     pzlib_filefunc_def->zerror_file = win32_error_file_func;
 575     pzlib_filefunc_def->opaque = NULL;
 576 }
 577
 578 void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def)
 579 {
 580     pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
 581     pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_funcW;
 582     pzlib_filefunc_def->zread_file = win32_read_file_func;
 583     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
 584     pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
 585     pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
 586     pzlib_filefunc_def->zclose_file = win32_close_file_func;
 587     pzlib_filefunc_def->zerror_file = win32_error_file_func;
 588     pzlib_filefunc_def->opaque = NULL;
 589 }
 590
 591 #endif // _WIN32