deps/libchdr/deps/zlib-1.3.1/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(const char *pathname, int append);
 117 extern zipFile ZEXPORT zipOpen64(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 course, you can use RAW reading and writing to copy the file you did not want delete
 135 */
 136
 137 extern zipFile ZEXPORT zipOpen2(const char *pathname,
 138                                 int append,
 139                                 zipcharpc* globalcomment,
 140                                 zlib_filefunc_def* pzlib_filefunc_def);
 141
 142 extern zipFile ZEXPORT zipOpen2_64(const void *pathname,
 143                                    int append,
 144                                    zipcharpc* globalcomment,
 145                                    zlib_filefunc64_def* pzlib_filefunc_def);
 146
 147 extern zipFile ZEXPORT zipOpen3(const void *pathname,
 148                                 int append,
 149                                 zipcharpc* globalcomment,
 150                                 zlib_filefunc64_32_def* pzlib_filefunc64_32_def);
 151
 152 extern int ZEXPORT zipOpenNewFileInZip(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(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 for the local header
 181   if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
 182     contains the extrafield data for the global 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(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(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(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(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   Same than zipOpenNewFileInZip2, except
 258     windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
 259     password : crypting password (NULL for no crypting)
 260     crcForCrypting : crc of file to compress (needed for crypting)
 261  */
 262
 263 extern int ZEXPORT zipOpenNewFileInZip4(zipFile file,
 264                                         const char* filename,
 265                                         const zip_fileinfo* zipfi,
 266                                         const void* extrafield_local,
 267                                         uInt size_extrafield_local,
 268                                         const void* extrafield_global,
 269                                         uInt size_extrafield_global,
 270                                         const char* comment,
 271                                         int method,
 272                                         int level,
 273                                         int raw,
 274                                         int windowBits,
 275                                         int memLevel,
 276                                         int strategy,
 277                                         const char* password,
 278                                         uLong crcForCrypting,
 279                                         uLong versionMadeBy,
 280                                         uLong flagBase);
 281
 282
 283 extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file,
 284                                            const char* filename,
 285                                            const zip_fileinfo* zipfi,
 286                                            const void* extrafield_local,
 287                                            uInt size_extrafield_local,
 288                                            const void* extrafield_global,
 289                                            uInt size_extrafield_global,
 290                                            const char* comment,
 291                                            int method,
 292                                            int level,
 293                                            int raw,
 294                                            int windowBits,
 295                                            int memLevel,
 296                                            int strategy,
 297                                            const char* password,
 298                                            uLong crcForCrypting,
 299                                            uLong versionMadeBy,
 300                                            uLong flagBase,
 301                                            int zip64);
 302 /*
 303   Same than zipOpenNewFileInZip4, except
 304     versionMadeBy : value for Version made by field
 305     flag : value for flag field (compression level info will be added)
 306  */
 307
 308
 309 extern int ZEXPORT zipWriteInFileInZip(zipFile file,
 310                                        const void* buf,
 311                                        unsigned len);
 312 /*
 313   Write data in the zipfile
 314 */
 315
 316 extern int ZEXPORT zipCloseFileInZip(zipFile file);
 317 /*
 318   Close the current file in the zipfile
 319 */
 320
 321 extern int ZEXPORT zipCloseFileInZipRaw(zipFile file,
 322                                         uLong uncompressed_size,
 323                                         uLong crc32);
 324
 325 extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file,
 326                                           ZPOS64_T uncompressed_size,
 327                                           uLong crc32);
 328
 329 /*
 330   Close the current file in the zipfile, for file opened with
 331     parameter raw=1 in zipOpenNewFileInZip2
 332   uncompressed_size and crc32 are value for the uncompressed size
 333 */
 334
 335 extern int ZEXPORT zipClose(zipFile file,
 336                             const char* global_comment);
 337 /*
 338   Close the zipfile
 339 */
 340
 341
 342 extern int ZEXPORT zipRemoveExtraInfoBlock(char* pData, int* dataLen, short sHeader);
 343 /*
 344   zipRemoveExtraInfoBlock -  Added by Mathias Svensson
 345
 346   Remove extra information block from a extra information data for the local file header or central directory header
 347
 348   It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
 349
 350   0x0001 is the signature header for the ZIP64 extra information blocks
 351
 352   usage.
 353                         Remove ZIP64 Extra information from a central director extra field data
 354               zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
 355
 356                         Remove ZIP64 Extra information from a Local File Header extra field data
 357         zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
 358 */
 359
 360 #ifdef __cplusplus
 361 }
 362 #endif
 363
 364 #endif /* _zip64_H */