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.1     ! root        1: /*
        !             2:   Hatari
        !             3: 
        !             4:   Zipped disc support, using zlib
        !             5: 
        !             6:   This file is originally from the minizip code by Gilles Vollant
        !             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.