Return to unzip.h CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src / includes

Annotation of hatari/src/includes/unzip.h, revision 1.1.1.2

1.1       root        1: /*
1.1.1.2 ! root        2:   Hatari - unzip.h
1.1       root        3: 
1.1.1.2 ! root        4:   Support for *.zip files, using zlib.
1.1       root        5: 
1.1.1.2 ! root        6:   This file is originally from the minizip code by Gilles Vollant.
1.1       root        7: 
                      8: */
                      9: /* unzip.h -- IO for uncompress .zip files using zlib 
                     10:    Version 0.15 beta, Mar 19th, 1998,
                     11: 
                     12:    Copyright (C) 1998 Gilles Vollant
                     13: 
                     14:    This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
                     15:      WinZip, InfoZip tools and compatible.
                     16:    Encryption and multi volume ZipFile (span) are not supported.
                     17:    Old compressions used by old PKZip 1.x are not supported
                     18: 
                     19:    THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
                     20:    CAN CHANGE IN FUTURE VERSION !!
                     21:    I WAIT FEEDBACK at mail [email protected]
                     22:    Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
                     23: 
                     24:    Condition of use and distribution are the same than zlib :
                     25: 
                     26:   This software is provided 'as-is', without any express or implied
                     27:   warranty.  In no event will the authors be held liable for any damages
                     28:   arising from the use of this software.
                     29: 
                     30:   Permission is granted to anyone to use this software for any purpose,
                     31:   including commercial applications, and to alter it and redistribute it
                     32:   freely, subject to the following restrictions:
                     33: 
                     34:   1. The origin of this software must not be misrepresented; you must not
                     35:      claim that you wrote the original software. If you use this software
                     36:      in a product, an acknowledgment in the product documentation would be
                     37:      appreciated but is not required.
                     38:   2. Altered source versions must be plainly marked as such, and must not be
                     39:      misrepresented as being the original software.
                     40:   3. This notice may not be removed or altered from any source distribution.
                     41: 
                     42: 
                     43: */
                     44: /* for more info about .ZIP format, see 
                     45:       ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
                     46:    PkWare has also a specification at :
                     47:       ftp://ftp.pkware.com/probdesc.zip */
                     48: 
                     49: #ifndef _unz_H
                     50: #define _unz_H
                     51: 
                     52: #ifdef __cplusplus
                     53: extern "C" {
                     54: #endif
                     55: 
                     56: #ifndef _ZLIB_H
                     57: #include "zlib.h"
                     58: #endif
                     59: 
                     60: #if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
                     61: /* like the STRICT of WIN32, we define a pointer that cannot be converted
                     62:     from (void*) without cast */
                     63: typedef struct TagunzFile__ { int unused; } unzFile__; 
                     64: typedef unzFile__ *unzFile;
                     65: #else
                     66: typedef voidp unzFile;
                     67: #endif
                     68: 
                     69: 
                     70: #define UNZ_OK                                  (0)
                     71: #define UNZ_END_OF_LIST_OF_FILE (-100)
                     72: #define UNZ_ERRNO               (Z_ERRNO)
                     73: #define UNZ_EOF                 (0)
                     74: #define UNZ_PARAMERROR                  (-102)
                     75: #define UNZ_BADZIPFILE                  (-103)
                     76: #define UNZ_INTERNALERROR               (-104)
                     77: #define UNZ_CRCERROR                    (-105)
                     78: 
                     79: /* tm_unz contain date/time info */
                     80: typedef struct tm_unz_s 
                     81: {
                     82:        uInt tm_sec;            /* seconds after the minute - [0,59] */
                     83:        uInt tm_min;            /* minutes after the hour - [0,59] */
                     84:        uInt tm_hour;           /* hours since midnight - [0,23] */
                     85:        uInt tm_mday;           /* day of the month - [1,31] */
                     86:        uInt tm_mon;            /* months since January - [0,11] */
                     87:        uInt tm_year;           /* years - [1980..2044] */
                     88: } tm_unz;
                     89: 
                     90: /* unz_global_info structure contain global data about the ZIPfile
                     91:    These data comes from the end of central dir */
                     92: typedef struct unz_global_info_s
                     93: {
                     94:        uLong number_entry;         /* total number of entries in
                     95:                                       the central dir on this disk */
                     96:        uLong size_comment;         /* size of the global comment of the zipfile */
                     97: } unz_global_info;
                     98: 
                     99: 
                    100: /* unz_file_info contain information about a file in the zipfile */
                    101: typedef struct unz_file_info_s
                    102: {
                    103:     uLong version;              /* version made by                 2 bytes */
                    104:     uLong version_needed;       /* version needed to extract       2 bytes */
                    105:     uLong flag;                 /* general purpose bit flag        2 bytes */
                    106:     uLong compression_method;   /* compression method              2 bytes */
                    107:     uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
                    108:     uLong crc;                  /* crc-32                          4 bytes */
                    109:     uLong compressed_size;      /* compressed size                 4 bytes */ 
                    110:     uLong uncompressed_size;    /* uncompressed size               4 bytes */ 
                    111:     uLong size_filename;        /* filename length                 2 bytes */
                    112:     uLong size_file_extra;      /* extra field length              2 bytes */
                    113:     uLong size_file_comment;    /* file comment length             2 bytes */
                    114: 
                    115:     uLong disk_num_start;       /* disk number start               2 bytes */
                    116:     uLong internal_fa;          /* internal file attributes        2 bytes */
                    117:     uLong external_fa;          /* external file attributes        4 bytes */
                    118: 
                    119:     tm_unz tmu_date;
                    120: } unz_file_info;
                    121: 
                    122: extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
                    123:                                                                                                 const char* fileName2,
                    124:                                                                                                 int iCaseSensitivity));
                    125: /*
                    126:    Compare two filename (fileName1,fileName2).
                    127:    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
                    128:    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
                    129:                                                                or strcasecmp)
                    130:    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
                    131:        (like 1 on Unix, 2 on Windows)
                    132: */
                    133: 
                    134: 
                    135: extern unzFile ZEXPORT unzOpen OF((const char *path));
                    136: /*
                    137:   Open a Zip file. path contain the full pathname (by example,
                    138:      on a Windows NT computer "c:\\zlib\\zlib111.zip" or on an Unix computer
                    139:         "zlib/zlib111.zip".
                    140:         If the zipfile cannot be opened (file don't exist or in not valid), the
                    141:           return value is NULL.
                    142:      Else, the return value is a unzFile Handle, usable with other function
                    143:           of this unzip package.
                    144: */
                    145: 
                    146: extern int ZEXPORT unzClose OF((unzFile file));
                    147: /*
                    148:   Close a ZipFile opened with unzipOpen.
                    149:   If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
                    150:     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
                    151:   return UNZ_OK if there is no problem. */
                    152: 
                    153: extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
                    154:                                        unz_global_info *pglobal_info));
                    155: /*
                    156:   Write info about the ZipFile in the *pglobal_info structure.
                    157:   No preparation of the structure is needed
                    158:   return UNZ_OK if there is no problem. */
                    159: 
                    160: 
                    161: extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
                    162:                                                                                   char *szComment,
                    163:                                           uLong uSizeBuf));
                    164: /*
                    165:   Get the global comment string of the ZipFile, in the szComment buffer.
                    166:   uSizeBuf is the size of the szComment buffer.
                    167:   return the number of byte copied or an error code <0
                    168: */
                    169: 
                    170: 
                    171: /***************************************************************************/
                    172: /* Unzip package allow you browse the directory of the zipfile */
                    173: 
                    174: extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
                    175: /*
                    176:   Set the current file of the zipfile to the first file.
                    177:   return UNZ_OK if there is no problem
                    178: */
                    179: 
                    180: extern int ZEXPORT unzGoToNextFile OF((unzFile file));
                    181: /*
                    182:   Set the current file of the zipfile to the next file.
                    183:   return UNZ_OK if there is no problem
                    184:   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
                    185: */
                    186: 
                    187: extern int ZEXPORT unzLocateFile OF((unzFile file, 
                    188:                                     const char *szFileName,
                    189:                                     int iCaseSensitivity));
                    190: /*
                    191:   Try locate the file szFileName in the zipfile.
                    192:   For the iCaseSensitivity signification, see unzStringFileNameCompare
                    193: 
                    194:   return value :
                    195:   UNZ_OK if the file is found. It becomes the current file.
                    196:   UNZ_END_OF_LIST_OF_FILE if the file is not found
                    197: */
                    198: 
                    199: 
                    200: extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
                    201:                                             unz_file_info *pfile_info,
                    202:                                             char *szFileName,
                    203:                                             uLong fileNameBufferSize,
                    204:                                             void *extraField,
                    205:                                             uLong extraFieldBufferSize,
                    206:                                             char *szComment,
                    207:                                             uLong commentBufferSize));
                    208: /*
                    209:   Get Info about the current file
                    210:   if pfile_info!=NULL, the *pfile_info structure will contain somes info about
                    211:            the current file
                    212:   if szFileName!=NULL, the filemane string will be copied in szFileName
                    213:                        (fileNameBufferSize is the size of the buffer)
                    214:   if extraField!=NULL, the extra field information will be copied in extraField
                    215:                        (extraFieldBufferSize is the size of the buffer).
                    216:                        This is the Central-header version of the extra field
                    217:   if szComment!=NULL, the comment string of the file will be copied in szComment
                    218:                        (commentBufferSize is the size of the buffer)
                    219: */
                    220: 
                    221: /***************************************************************************/
                    222: /* for reading the content of the current zipfile, you can open it, read data
                    223:    from it, and close it (you can close it before reading all the file)
                    224:    */
                    225: 
                    226: extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
                    227: /*
                    228:   Open for reading data the current file in the zipfile.
                    229:   If there is no error, the return value is UNZ_OK.
                    230: */
                    231: 
                    232: extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
                    233: /*
                    234:   Close the file in zip opened with unzOpenCurrentFile
                    235:   Return UNZ_CRCERROR if all the file was read but the CRC is not good
                    236: */
                    237: 
                    238:                                                                                                
                    239: extern int ZEXPORT unzReadCurrentFile OF((unzFile file, 
                    240:                                          voidp buf,
                    241:                                          unsigned len));
                    242: /*
                    243:   Read bytes from the current file (opened by unzOpenCurrentFile)
                    244:   buf contain buffer where data must be copied
                    245:   len the size of buf.
                    246: 
                    247:   return the number of byte copied if somes bytes are copied
                    248:   return 0 if the end of file was reached
                    249:   return <0 with error code if there is an error
                    250:     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
                    251: */
                    252: 
                    253: extern z_off_t ZEXPORT unztell OF((unzFile file));
                    254: /*
                    255:   Give the current position in uncompressed data
                    256: */
                    257: 
                    258: extern int ZEXPORT unzeof OF((unzFile file));
                    259: /*
                    260:   return 1 if the end of file was reached, 0 elsewhere 
                    261: */
                    262: 
                    263: extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
                    264:                                                                                         voidp buf,
                    265:                                                                                         unsigned len));
                    266: /*
                    267:   Read extra field from the current file (opened by unzOpenCurrentFile)
                    268:   This is the local-header version of the extra field (sometimes, there is
                    269:     more info in the local-header version than in the central-header)
                    270: 
                    271:   if buf==NULL, it return the size of the local extra field
                    272: 
                    273:   if buf!=NULL, len is the size of the buffer, the extra header is copied in
                    274:        buf.
                    275:   the return value is the number of bytes copied in buf, or (if <0) 
                    276:        the error code
                    277: */
                    278: 
                    279: #ifdef __cplusplus
                    280: }
                    281: #endif
                    282: 
                    283: #endif /* _unz_H */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.