contrib/minizip/zip.h

   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     int tm_sec;             /* seconds after the minute - [0,59] */
  92     int tm_min;             /* minutes after the hour - [0,59] */
  93     int tm_hour;            /* hours since midnight - [0,23] */
  94     int tm_mday;            /* day of the month - [1,31] */
  95     int tm_mon;             /* months since January - [0,11] */
  96     int 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 zipFile ZEXPORT zipOpen3 OF((const void *pathname,
 148                                     int append,
 149                                     zipcharpc* globalcomment,
 150                                     zlib_filefunc64_32_def* pzlib_filefunc64_32_def));
 151
 152 extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
 153                        const char* filename,
 154                        const zip_fileinfo* zipfi,
 155                        const void* extrafield_local,
 156                        uInt size_extrafield_local,
 157                        const void* extrafield_global,
 158                        uInt size_extrafield_global,
 159                        const char* comment,
 160                        int method,
 161                        int level));
 162
 163 extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
 164                        const char* filename,
 165                        const zip_fileinfo* zipfi,
 166                        const void* extrafield_local,
 167                        uInt size_extrafield_local,
 168                        const void* extrafield_global,
 169                        uInt size_extrafield_global,
 170                        const char* comment,
 171                        int method,
 172                        int level,
 173                        int zip64));
 174
 175 /*
 176   Open a file in the ZIP for writing.
 177   filename : the filename in zip (if NULL, '-' without quote will be used
 178   *zipfi contain supplemental information
 179   if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
 180     contains the extrafield data the the local header
 181   if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
 182     contains the extrafield data the the local header
 183   if comment != NULL, comment contain the comment string
 184   method contain the compression method (0 for store, Z_DEFLATED for deflate)
 185   level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
 186   zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
 187                     this MUST be '1' if the uncompressed size is >= 0xffffffff.
 188
 189 */
 190
 191
 192 extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
 193                                             const char* filename,
 194                                             const zip_fileinfo* zipfi,
 195                                             const void* extrafield_local,
 196                                             uInt size_extrafield_local,
 197                                             const void* extrafield_global,
 198                                             uInt size_extrafield_global,
 199                                             const char* comment,
 200                                             int method,
 201                                             int level,
 202                                             int raw));
 203
 204
 205 extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
 206                                             const char* filename,
 207                                             const zip_fileinfo* zipfi,
 208                                             const void* extrafield_local,
 209                                             uInt size_extrafield_local,
 210                                             const void* extrafield_global,
 211                                             uInt size_extrafield_global,
 212                                             const char* comment,
 213                                             int method,
 214                                             int level,
 215                                             int raw,
 216                                             int zip64));
 217 /*
 218   Same than zipOpenNewFileInZip, except if raw=1, we write raw file
 219  */
 220
 221 extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
 222                                             const char* filename,
 223                                             const zip_fileinfo* zipfi,
 224                                             const void* extrafield_local,
 225                                             uInt size_extrafield_local,
 226                                             const void* extrafield_global,
 227                                             uInt size_extrafield_global,
 228                                             const char* comment,
 229                                             int method,
 230                                             int level,
 231                                             int raw,
 232                                             int windowBits,
 233                                             int memLevel,
 234                                             int strategy,
 235                                             const char* password,
 236                                             uLong crcForCrypting));
 237
 238 extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
 239                                             const char* filename,
 240                                             const zip_fileinfo* zipfi,
 241                                             const void* extrafield_local,
 242                                             uInt size_extrafield_local,
 243                                             const void* extrafield_global,
 244                                             uInt size_extrafield_global,
 245                                             const char* comment,
 246                                             int method,
 247                                             int level,
 248                                             int raw,
 249                                             int windowBits,
 250                                             int memLevel,
 251                                             int strategy,
 252                                             const char* password,
 253                                             uLong crcForCrypting,
 254                                             int zip64
 255                                             ));
 256
 257 /*
 258   Same than zipOpenNewFileInZip2, except
 259     windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
 260     password : crypting password (NULL for no crypting)
 261     crcForCrypting : crc of file to compress (needed for crypting)
 262  */
 263
 264 extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
 265                                             const char* filename,
 266                                             const zip_fileinfo* zipfi,
 267                                             const void* extrafield_local,
 268                                             uInt size_extrafield_local,
 269                                             const void* extrafield_global,
 270                                             uInt size_extrafield_global,
 271                                             const char* comment,
 272                                             int method,
 273                                             int level,
 274                                             int raw,
 275                                             int windowBits,
 276                                             int memLevel,
 277                                             int strategy,
 278                                             const char* password,
 279                                             uLong crcForCrypting,
 280                                             uLong versionMadeBy,
 281                                             uLong flagBase
 282                                             ));
 283
 284
 285 extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
 286                                             const char* filename,
 287                                             const zip_fileinfo* zipfi,
 288                                             const void* extrafield_local,
 289                                             uInt size_extrafield_local,
 290                                             const void* extrafield_global,
 291                                             uInt size_extrafield_global,
 292                                             const char* comment,
 293                                             int method,
 294                                             int level,
 295                                             int raw,
 296                                             int windowBits,
 297                                             int memLevel,
 298                                             int strategy,
 299                                             const char* password,
 300                                             uLong crcForCrypting,
 301                                             uLong versionMadeBy,
 302                                             uLong flagBase,
 303                                             int zip64
 304                                             ));
 305 /*
 306   Same than zipOpenNewFileInZip4, except
 307     versionMadeBy : value for Version made by field
 308     flag : value for flag field (compression level info will be added)
 309  */
 310
 311
 312 extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
 313                        const void* buf,
 314                        unsigned len));
 315 /*
 316   Write data in the zipfile
 317 */
 318
 319 extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
 320 /*
 321   Close the current file in the zipfile
 322 */
 323
 324 extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
 325                                             uLong uncompressed_size,
 326                                             uLong crc32));
 327
 328 extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
 329                                             ZPOS64_T uncompressed_size,
 330                                             uLong crc32));
 331
 332 /*
 333   Close the current file in the zipfile, for file opened with
 334     parameter raw=1 in zipOpenNewFileInZip2
 335   uncompressed_size and crc32 are value for the uncompressed size
 336 */
 337
 338 extern int ZEXPORT zipClose OF((zipFile file,
 339                 const char* global_comment));
 340 /*
 341   Close the zipfile
 342 */
 343
 344
 345 extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
 346 /*
 347   zipRemoveExtraInfoBlock -  Added by Mathias Svensson
 348
 349   Remove extra information block from a extra information data for the local file header or central directory header
 350
 351   It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
 352
 353   0x0001 is the signature header for the ZIP64 extra information blocks
 354
 355   usage.
 356                         Remove ZIP64 Extra information from a central director extra field data
 357               zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
 358
 359                         Remove ZIP64 Extra information from a Local File Header extra field data
 360         zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
 361 */
 362
 363 #ifdef __cplusplus
 364 }
 365 #endif
 366
 367 #endif /* _zip64_H */