Home | History | Annotate | Download | only in minizip
      1 /* zip.h -- IO on .zip files using zlib
      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    Condition of use and distribution are the same than zlib :
     15 
     16   This software is provided 'as-is', without any express or implied
     17   warranty.  In no event will the authors be held liable for any damages
     18   arising from the use of this software.
     19 
     20   Permission is granted to anyone to use this software for any purpose,
     21   including commercial applications, and to alter it and redistribute it
     22   freely, subject to the following restrictions:
     23 
     24   1. The origin of this software must not be misrepresented; you must not
     25      claim that you wrote the original software. If you use this software
     26      in a product, an acknowledgment in the product documentation would be
     27      appreciated but is not required.
     28   2. Altered source versions must be plainly marked as such, and must not be
     29      misrepresented as being the original software.
     30   3. This notice may not be removed or altered from any source distribution.
     31 
     32         ---------------------------------------------------------------------------
     33 
     34         Changes
     35 
     36         See header of zip.h
     37 
     38 */
     39 
     40 #ifndef _zip12_H
     41 #define _zip12_H
     42 
     43 #ifdef __cplusplus
     44 extern "C" {
     45 #endif
     46 
     47 //#define HAVE_BZIP2
     48 
     49 #ifndef _ZLIB_H
     50 #include "zlib.h"
     51 #endif
     52 
     53 #ifndef _ZLIBIOAPI_H
     54 #include "ioapi.h"
     55 #endif
     56 
     57 #ifdef HAVE_BZIP2
     58 #include "bzlib.h"
     59 #endif
     60 
     61 #define Z_BZIP2ED 12
     62 
     63 #if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
     64 /* like the STRICT of WIN32, we define a pointer that cannot be converted
     65     from (void*) without cast */
     66 typedef struct TagzipFile__ { int unused; } zipFile__;
     67 typedef zipFile__ *zipFile;
     68 #else
     69 typedef voidp zipFile;
     70 #endif
     71 
     72 #define ZIP_OK                          (0)
     73 #define ZIP_EOF                         (0)
     74 #define ZIP_ERRNO                       (Z_ERRNO)
     75 #define ZIP_PARAMERROR                  (-102)
     76 #define ZIP_BADZIPFILE                  (-103)
     77 #define ZIP_INTERNALERROR               (-104)
     78 
     79 #ifndef DEF_MEM_LEVEL
     80 #  if MAX_MEM_LEVEL >= 8
     81 #    define DEF_MEM_LEVEL 8
     82 #  else
     83 #    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
     84 #  endif
     85 #endif
     86 /* default memLevel */
     87 
     88 /* tm_zip contain date/time info */
     89 typedef struct tm_zip_s
     90 {
     91     uInt tm_sec;            /* seconds after the minute - [0,59] */
     92     uInt tm_min;            /* minutes after the hour - [0,59] */
     93     uInt tm_hour;           /* hours since midnight - [0,23] */
     94     uInt tm_mday;           /* day of the month - [1,31] */
     95     uInt tm_mon;            /* months since January - [0,11] */
     96     uInt tm_year;           /* years - [1980..2044] */
     97 } tm_zip;
     98 
     99 typedef struct
    100 {
    101     tm_zip      tmz_date;       /* date in understandable format           */
    102     uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
    103 /*    uLong       flag;        */   /* general purpose bit flag        2 bytes */
    104 
    105     uLong       internal_fa;    /* internal file attributes        2 bytes */
    106     uLong       external_fa;    /* external file attributes        4 bytes */
    107 } zip_fileinfo;
    108 
    109 typedef const char* zipcharpc;
    110 
    111 
    112 #define APPEND_STATUS_CREATE        (0)
    113 #define APPEND_STATUS_CREATEAFTER   (1)
    114 #define APPEND_STATUS_ADDINZIP      (2)
    115 
    116 extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
    117 extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
    118 /*
    119   Create a zipfile.
    120      pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
    121        an Unix computer "zlib/zlib113.zip".
    122      if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
    123        will be created at the end of the file.
    124          (useful if the file contain a self extractor code)
    125      if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
    126        add files in existing zip (be sure you don't add file that doesn't exist)
    127      If the zipfile cannot be opened, the return value is NULL.
    128      Else, the return value is a zipFile Handle, usable with other function
    129        of this zip package.
    130 */
    131 
    132 /* Note : there is no delete function into a zipfile.
    133    If you want delete file into a zipfile, you must open a zipfile, and create another
    134    Of couse, you can use RAW reading and writing to copy the file you did not want delte
    135 */
    136 
    137 extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
    138                                    int append,
    139                                    zipcharpc* globalcomment,
    140                                    zlib_filefunc_def* pzlib_filefunc_def));
    141 
    142 extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
    143                                    int append,
    144                                    zipcharpc* globalcomment,
    145                                    zlib_filefunc64_def* pzlib_filefunc_def));
    146 
    147 extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
    148                        const char* filename,
    149                        const zip_fileinfo* zipfi,
    150                        const void* extrafield_local,
    151                        uInt size_extrafield_local,
    152                        const void* extrafield_global,
    153                        uInt size_extrafield_global,
    154                        const char* comment,
    155                        int method,
    156                        int level));
    157 
    158 extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
    159                        const char* filename,
    160                        const zip_fileinfo* zipfi,
    161                        const void* extrafield_local,
    162                        uInt size_extrafield_local,
    163                        const void* extrafield_global,
    164                        uInt size_extrafield_global,
    165                        const char* comment,
    166                        int method,
    167                        int level,
    168                        int zip64));
    169 
    170 /*
    171   Open a file in the ZIP for writing.
    172   filename : the filename in zip (if NULL, '-' without quote will be used
    173   *zipfi contain supplemental information
    174   if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
    175     contains the extrafield data the the local header
    176   if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
    177     contains the extrafield data the the local header
    178   if comment != NULL, comment contain the comment string
    179   method contain the compression method (0 for store, Z_DEFLATED for deflate)
    180   level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
    181   zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
    182                     this MUST be '1' if the uncompressed size is >= 0xffffffff.
    183 
    184 */
    185 
    186 
    187 extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
    188                                             const char* filename,
    189                                             const zip_fileinfo* zipfi,
    190                                             const void* extrafield_local,
    191                                             uInt size_extrafield_local,
    192                                             const void* extrafield_global,
    193                                             uInt size_extrafield_global,
    194                                             const char* comment,
    195                                             int method,
    196                                             int level,
    197                                             int raw));
    198 
    199 
    200 extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
    201                                             const char* filename,
    202                                             const zip_fileinfo* zipfi,
    203                                             const void* extrafield_local,
    204                                             uInt size_extrafield_local,
    205                                             const void* extrafield_global,
    206                                             uInt size_extrafield_global,
    207                                             const char* comment,
    208                                             int method,
    209                                             int level,
    210                                             int raw,
    211                                             int zip64));
    212 /*
    213   Same than zipOpenNewFileInZip, except if raw=1, we write raw file
    214  */
    215 
    216 extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
    217                                             const char* filename,
    218                                             const zip_fileinfo* zipfi,
    219                                             const void* extrafield_local,
    220                                             uInt size_extrafield_local,
    221                                             const void* extrafield_global,
    222                                             uInt size_extrafield_global,
    223                                             const char* comment,
    224                                             int method,
    225                                             int level,
    226                                             int raw,
    227                                             int windowBits,
    228                                             int memLevel,
    229                                             int strategy,
    230                                             const char* password,
    231                                             uLong crcForCrypting));
    232 
    233 extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
    234                                             const char* filename,
    235                                             const zip_fileinfo* zipfi,
    236                                             const void* extrafield_local,
    237                                             uInt size_extrafield_local,
    238                                             const void* extrafield_global,
    239                                             uInt size_extrafield_global,
    240                                             const char* comment,
    241                                             int method,
    242                                             int level,
    243                                             int raw,
    244                                             int windowBits,
    245                                             int memLevel,
    246                                             int strategy,
    247                                             const char* password,
    248                                             uLong crcForCrypting,
    249                                             int zip64
    250                                             ));
    251 
    252 /*
    253   Same than zipOpenNewFileInZip2, except
    254     windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
    255     password : crypting password (NULL for no crypting)
    256     crcForCrypting : crc of file to compress (needed for crypting)
    257  */
    258 
    259 extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
    260                                             const char* filename,
    261                                             const zip_fileinfo* zipfi,
    262                                             const void* extrafield_local,
    263                                             uInt size_extrafield_local,
    264                                             const void* extrafield_global,
    265                                             uInt size_extrafield_global,
    266                                             const char* comment,
    267                                             int method,
    268                                             int level,
    269                                             int raw,
    270                                             int windowBits,
    271                                             int memLevel,
    272                                             int strategy,
    273                                             const char* password,
    274                                             uLong crcForCrypting,
    275                                             uLong versionMadeBy,
    276                                             uLong flagBase
    277                                             ));
    278 
    279 
    280 extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
    281                                             const char* filename,
    282                                             const zip_fileinfo* zipfi,
    283                                             const void* extrafield_local,
    284                                             uInt size_extrafield_local,
    285                                             const void* extrafield_global,
    286                                             uInt size_extrafield_global,
    287                                             const char* comment,
    288                                             int method,
    289                                             int level,
    290                                             int raw,
    291                                             int windowBits,
    292                                             int memLevel,
    293                                             int strategy,
    294                                             const char* password,
    295                                             uLong crcForCrypting,
    296                                             uLong versionMadeBy,
    297                                             uLong flagBase,
    298                                             int zip64
    299                                             ));
    300 /*
    301   Same than zipOpenNewFileInZip4, except
    302     versionMadeBy : value for Version made by field
    303     flag : value for flag field (compression level info will be added)
    304  */
    305 
    306 
    307 extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
    308                        const void* buf,
    309                        unsigned len));
    310 /*
    311   Write data in the zipfile
    312 */
    313 
    314 extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
    315 /*
    316   Close the current file in the zipfile
    317 */
    318 
    319 extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
    320                                             uLong uncompressed_size,
    321                                             uLong crc32));
    322 
    323 extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
    324                                             ZPOS64_T uncompressed_size,
    325                                             uLong crc32));
    326 
    327 /*
    328   Close the current file in the zipfile, for file opened with
    329     parameter raw=1 in zipOpenNewFileInZip2
    330   uncompressed_size and crc32 are value for the uncompressed size
    331 */
    332 
    333 extern int ZEXPORT zipClose OF((zipFile file,
    334                 const char* global_comment));
    335 /*
    336   Close the zipfile
    337 */
    338 
    339 
    340 extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
    341 /*
    342   zipRemoveExtraInfoBlock -  Added by Mathias Svensson
    343 
    344   Remove extra information block from a extra information data for the local file header or central directory header
    345 
    346   It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
    347 
    348   0x0001 is the signature header for the ZIP64 extra information blocks
    349 
    350   usage.
    351                         Remove ZIP64 Extra information from a central director extra field data
    352               zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
    353 
    354                         Remove ZIP64 Extra information from a Local File Header extra field data
    355         zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
    356 */
    357 
    358 #ifdef __cplusplus
    359 }
    360 #endif
    361 
    362 #endif /* _zip64_H */
    363