Line data    Source code

       1           0 : /* ioapi.h -- IO base function header for compress/uncompress .zip
       2             :    part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
       3             : 
       4             :          Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
       5             : 
       6             :          Modifications for Zip64 support
       7             :          Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
       8             : 
       9             :          For more info read MiniZip_info.txt
      10             : 
      11             : */
      12             : 
      13             : #if (defined(_WIN32))
      14             :         #define _CRT_SECURE_NO_WARNINGS
      15             : #endif
      16             : 
      17             : #if (defined(__APPLE__))
      18             :     // I/O is always 64-bit on Darwin
      19             :         #define fopen64 fopen
      20             :         #define ftello64 ftello
      21             :         #define fseeko64 fseeko
      22             : #endif
      23             : 
      24             : #include "ioapi.h"
      25             : 
      26           0 : voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
      27             : {
      28             :     if (pfilefunc->zfile_func64.zopen64_file != NULL)
      29             :         return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
      30             :     else
      31             :     {
      32             :         return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
      33             :     }
      34             : }
      35             : 
      36           0 : long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
      37             : {
      38             :     if (pfilefunc->zfile_func64.zseek64_file != NULL)
      39             :         return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
      40             :     else
      41             :     {
      42             :         uLong offsetTruncated = (uLong)offset;
      43             :         if (offsetTruncated != offset)
      44             :             return -1;
      45             :         else
      46             :             return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
      47             :     }
      48             : }
      49             : 
      50           0 : ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
      51             : {
      52             :     if (pfilefunc->zfile_func64.zseek64_file != NULL)
      53             :         return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
      54             :     else
      55             :     {
      56             :         uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
      57             :         if ((tell_uLong) == ((uLong)-1))
      58             :             return (ZPOS64_T)-1;
      59             :         else
      60             :             return tell_uLong;
      61             :     }
      62             : }
      63             : 
      64           0 : void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
      65             : {
      66             :     p_filefunc64_32->zfile_func64.zopen64_file = NULL;
      67             :     p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
      68             :     p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
      69             :     p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
      70             :     p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
      71             :     p_filefunc64_32->zfile_func64.ztell64_file = NULL;
      72             :     p_filefunc64_32->zfile_func64.zseek64_file = NULL;
      73             :     p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
      74             :     p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
      75             :     p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
      76             :     p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
      77             :     p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
      78             : }
      79             : 
      80             : 
      81             : 
      82           0 : static voidpf  ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
      83           0 : static uLong   ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
      84           0 : static uLong   ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
      85           0 : static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
      86           0 : static long    ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
      87             : static int     ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
      88             : static int     ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
      89             : 
      90           0 : static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
      91             : {
      92             :     FILE* file = NULL;
      93             :     const char* mode_fopen = NULL;
      94             :     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
      95             :         mode_fopen = "rb";
      96             :     else
      97             :     if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
      98             :         mode_fopen = "r+b";
      99             :     else
     100             :     if (mode & ZLIB_FILEFUNC_MODE_CREATE)
     101             :         mode_fopen = "wb";
     102             : 
     103             :     if ((filename!=NULL) && (mode_fopen != NULL))
     104             :         file = fopen(filename, mode_fopen);
     105             :     return file;
     106             : }
     107             : 
     108           0 : static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
     109             : {
     110             :     FILE* file = NULL;
     111             :     const char* mode_fopen = NULL;
     112             :     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
     113             :         mode_fopen = "rb";
     114             :     else
     115             :     if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
     116             :         mode_fopen = "r+b";
     117             :     else
     118             :     if (mode & ZLIB_FILEFUNC_MODE_CREATE)
     119             :         mode_fopen = "wb";
     120             : 
     121             :     if ((filename!=NULL) && (mode_fopen != NULL))
     122             :         file = fopen64((const char*)filename, mode_fopen);
     123             :     return file;
     124             : }
     125             : 
     126             : 
     127           0 : static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
     128             : {
     129             :     uLong ret;
     130             :     ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
     131             :     return ret;
     132             : }
     133             : 
     134           0 : static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
     135             : {
     136             :     uLong ret;
     137             :     ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
     138             :     return ret;
     139             : }
     140             : 
     141           0 : static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
     142             : {
     143             :     long ret;
     144             :     ret = ftell((FILE *)stream);
     145             :     return ret;
     146             : }
     147             : 
     148             : 
     149           0 : static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
     150             : {
     151             :     ZPOS64_T ret;
     152             :     ret = ftello64((FILE *)stream);
     153             :     return ret;
     154             : }
     155             : 
     156           0 : static long ZCALLBACK fseek_file_func (voidpf  opaque, voidpf stream, uLong offset, int origin)
     157             : {
     158             :     int fseek_origin=0;
     159             :     long ret;
     160             :     switch (origin)
     161             :     {
     162             :     case ZLIB_FILEFUNC_SEEK_CUR :
     163             :         fseek_origin = SEEK_CUR;
     164             :         break;
     165             :     case ZLIB_FILEFUNC_SEEK_END :
     166             :         fseek_origin = SEEK_END;
     167             :         break;
     168             :     case ZLIB_FILEFUNC_SEEK_SET :
     169             :         fseek_origin = SEEK_SET;
     170             :         break;
     171             :     default: return -1;
     172             :     }
     173             :     ret = 0;
     174             :     if (fseek((FILE *)stream, offset, fseek_origin) != 0)
     175             :         ret = -1;
     176             :     return ret;
     177             : }
     178             : 
     179           0 : static long ZCALLBACK fseek64_file_func (voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
     180             : {
     181             :     int fseek_origin=0;
     182             :     long ret;
     183             :     switch (origin)
     184             :     {
     185             :     case ZLIB_FILEFUNC_SEEK_CUR :
     186             :         fseek_origin = SEEK_CUR;
     187             :         break;
     188             :     case ZLIB_FILEFUNC_SEEK_END :
     189             :         fseek_origin = SEEK_END;
     190             :         break;
     191             :     case ZLIB_FILEFUNC_SEEK_SET :
     192             :         fseek_origin = SEEK_SET;
     193             :         break;
     194             :     default: return -1;
     195             :     }
     196             :     ret = 0;
     197             : 
     198             :     if(fseeko64((FILE *)stream, offset, fseek_origin) != 0)
     199             :                         ret = -1;
     200             : 
     201             :     return ret;
     202             : }
     203             : 
     204             : 
     205           0 : static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
     206             : {
     207             :     int ret;
     208             :     ret = fclose((FILE *)stream);
     209             :     return ret;
     210             : }
     211             : 
     212           0 : static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
     213             : {
     214             :     int ret;
     215             :     ret = ferror((FILE *)stream);
     216             :     return ret;
     217             : }
     218             : 
     219           0 : void fill_fopen_filefunc (pzlib_filefunc_def)
     220             :   zlib_filefunc_def* pzlib_filefunc_def;
     221             : {
     222             :     pzlib_filefunc_def->zopen_file = fopen_file_func;
     223             :     pzlib_filefunc_def->zread_file = fread_file_func;
     224             :     pzlib_filefunc_def->zwrite_file = fwrite_file_func;
     225             :     pzlib_filefunc_def->ztell_file = ftell_file_func;
     226             :     pzlib_filefunc_def->zseek_file = fseek_file_func;
     227             :     pzlib_filefunc_def->zclose_file = fclose_file_func;
     228             :     pzlib_filefunc_def->zerror_file = ferror_file_func;
     229             :     pzlib_filefunc_def->opaque = NULL;
     230             : }
     231             : 
     232           0 : void fill_fopen64_filefunc (zlib_filefunc64_def*  pzlib_filefunc_def)
     233             : {
     234             :     pzlib_filefunc_def->zopen64_file = fopen64_file_func;
     235             :     pzlib_filefunc_def->zread_file = fread_file_func;
     236             :     pzlib_filefunc_def->zwrite_file = fwrite_file_func;
     237             :     pzlib_filefunc_def->ztell64_file = ftell64_file_func;
     238             :     pzlib_filefunc_def->zseek64_file = fseek64_file_func;
     239             :     pzlib_filefunc_def->zclose_file = fclose_file_func;
     240             :     pzlib_filefunc_def->zerror_file = ferror_file_func;
     241             :     pzlib_filefunc_def->opaque = NULL;
     242             : }