| ZZIPlib 0.13.24
 
 Library
 -ZIP Access
 -Transparently
 -SDLrwops Example
 -ext/io Customization
 -xor/io Obfuscation
 -Library API
 -Parsing ZIPs
 -64on32 extras
 -Next To Come
 -Config Helpers
 -Making a zip/exe
 -Hints And Links
 -Referentials
 -Functions List #
 -The Manual Pages #
     (# autogenerated)
 
 
 Download Area *
 Sourceforge Project
 zziplib.sf.net 
                                  Home
 LGPL/MPL license
 
 
   
generated 2003-12-12
(C) Guido Draheim
 guidod@gmx.de
 | zziplib autodoc documentation zziplib -0.10.82.pre2
| void 
 |  | zzip_rewinddir |  | 1000 (ZZIP_DIR * dir) |  
| ZZIP_DIRENT* 
 |  | zzip_readdir |  | 1000 (ZZIP_DIR * dir) |  
| zzip_off_t 
 |  | zzip_telldir |  | zzip_telldir (ZZIP_DIR* dir) |  
| void
 |  | zzip_seekdir |  | zzip_seekdir (ZZIP_DIR* dir,
zzip_off_t offset) |  
| ZZIP_DIR* 
 |  | zzip_opendir |  | zzip_opendir (zzip_char_t* filename) |  
| ZZIP_DIR* 
 |  | zzip_opendir_ext_io |  | zzip_opendir_ext_io (zzip_char_t* filename,
int o_modes,
zzip_strings_t* ext,
zzip_plugin_io_t io) |  
| int
 |  | zzip_closedir |  | zzip_closedir (ZZIP_DIR* dir) |  
| zzip_char_t* 
 |  | zzip_strerror |  | zzip_strerror (int errcode) |  
| zzip_char_t* 
 |  | zzip_strerror_of |  | zzip_strerror_of (ZZIP_DIR* dir) |  
| int
 |  | zzip_errno |  | zzip_errno (int errcode) |  
| int 
 |  | zzip_file_close |  | zzip_file_close (ZZIP_FILE * fp) |  
| ZZIP_FILE * 
 |  | zzip_file_open |  | zzip_file_open (ZZIP_DIR * dir,
zzip_char_t* name,
int o_mode) |  
| static int 
 |  | zzip_inflate_init |  | zzip_inflate_init (ZZIP_FILE * fp,
struct zzip_dir_hdr* hdr) |  
| int 
 |  | zzip_fclose |  | zzip_fclose (ZZIP_FILE * fp) |  
| int 
 |  | zzip_close |  | zzip_close (ZZIP_FILE* fp) |  
| zzip_ssize_t 
 |  | zzip_file_read |  | zzip_file_read (ZZIP_FILE * fp,
char * buf,
zzip_size_t len) |  
| zzip_ssize_t
 |  | zzip_read |  | zzip_read (ZZIP_FILE * fp,
char * buf,
zzip_size_t len) |  
| zzip_size_t
 |  | zzip_fread |  | zzip_fread (void *ptr,
zzip_size_t size,
zzip_size_t nmemb,
ZZIP_FILE *file) |  
| ZZIP_FILE*
 |  | zzip_fopen |  | zzip_fopen (zzip_char_t* filename,
zzip_char_t* mode) |  
| ZZIP_FILE*
 |  | zzip_freopen |  | zzip_freopen (zzip_char_t* filename,
zzip_char_t* mode,
ZZIP_FILE* stream) |  
| ZZIP_FILE*
 |  | zzip_open |  | zzip_open (zzip_char_t* filename,
int o_flags) |  
| ZZIP_FILE*
 |  | zzip_open_ext_io |  | zzip_open_ext_io (zzip_char_t* filename,
int o_flags,
int o_modes,
zzip_strings_t* ext,
zzip_plugin_io_t io) |  
| ZZIP_FILE*
 |  | zzip_open_shared_io |  | zzip_open_shared_io (ZZIP_FILE* stream,
zzip_char_t* filename,
int o_flags,
int o_modes,
zzip_strings_t* ext,
zzip_plugin_io_t io) |  
| int
 |  | zzip_rewind |  | zzip_rewind (ZZIP_FILE *fp) |  
| zzip_off_t
 |  | zzip_seek |  | zzip_seek (ZZIP_FILE * fp,
zzip_off_t offset,
int whence) |  
| zzip_off_t
 |  | zzip_tell |  | zzip_tell (ZZIP_FILE * fp) |  
| int 
 |  | zzip_error |  | zzip_error (ZZIP_DIR * dir) |  
| void 
 |  | zzip_seterror |  | zzip_seterror (ZZIP_DIR * dir,
int errcode) |  
| ZZIP_DIR * 
 |  | zzip_dirhandle |  | zzip_dirhandle (ZZIP_FILE * fp) |  
| int 
 |  | zzip_dirfd |  | zzip_dirfd (ZZIP_DIR* dir) |  
| zzip_char_t*
 |  | zzip_compr_str |  | zzip_compr_str (int compr) |  
| int
 |  | zzip_dir_real |  | zzip_dir_real (ZZIP_DIR* dir) |  
| int
 |  | zzip_file_real |  | zzip_file_real (ZZIP_FILE* fp) |  
| void*
 |  | zzip_realdir |  | zzip_realdir (ZZIP_DIR* dir) |  
| int
 |  | zzip_realfd |  | zzip_realfd (ZZIP_FILE* fp) |  
| zzip_plugin_io_t
 |  | zzip_get_default_io |  | zzip_get_default_io () |  
| int  |  | zzip_init_io |  | zzip_init_io (struct zzip_plugin_io* io,
int flags) |  
| int 
 |  | zzip_dir_stat |  | zzip_dir_stat (ZZIP_DIR * dir,
zzip_char_t* name,
ZZIP_STAT * zs,
int flags) |  
| uint32_t  |  | __zzip_get32 |  | __zzip_get32 (unsigned char * s) |  
| uint16_t  |  | __zzip_get16 |  | __zzip_get16 (unsigned char * s) |  
| int 
 |  | __zzip_find_disk_trailer |  | __zzip_find_disk_trailer (int fd,
zzip_off_t filesize,
struct zzip_disk_trailer * trailer,
zzip_plugin_io_t io) |  
| int 
 |  | __zzip_parse_root_directory |  | __zzip_parse_root_directory (int fd,
struct zzip_disk_trailer * trailer,
struct zzip_dir_hdr ** hdr_return,
zzip_plugin_io_t io) |  
| ZZIP_DIR*
 |  | zzip_dir_alloc_ext_io |  | zzip_dir_alloc_ext_io (zzip_strings_t* ext,
const zzip_plugin_io_t io) |  
| ZZIP_DIR*
 |  | zzip_dir_alloc |  | zzip_dir_alloc (zzip_strings_t* fileext) |  
| int 
 |  | zzip_dir_free |  | zzip_dir_free (ZZIP_DIR * dir) |  
| int 
 |  | zzip_dir_close |  | zzip_dir_close (ZZIP_DIR * dir) |  
| ZZIP_DIR * 
 |  | zzip_dir_fdopen |  | zzip_dir_fdopen (int fd,
zzip_error_t * errcode_p) |  
| ZZIP_DIR * 
 |  | zzip_dir_fdopen_ext_io |  | zzip_dir_fdopen_ext_io (int fd,
zzip_error_t * errcode_p,
zzip_strings_t* ext,
const zzip_plugin_io_t io) |  
| int
 |  | __zzip_try_open |  | __zzip_try_open (zzip_char_t* filename,
int filemode,
zzip_strings_t* ext,
zzip_plugin_io_t io) |  
| ZZIP_DIR* 
 |  | zzip_dir_open |  | zzip_dir_open (zzip_char_t* filename,
zzip_error_t* e) |  
| ZZIP_DIR* 
 |  | zzip_dir_open_ext_io |  | zzip_dir_open_ext_io (zzip_char_t* filename,
zzip_error_t* e,
zzip_strings_t* ext,
zzip_plugin_io_t io) |  
| int
 |  | zzip_dir_read |  | zzip_dir_read (ZZIP_DIR * dir,
ZZIP_DIRENT * d ) | 
 Documentation
void 
 zzip_rewinddir1000
 (ZZIP_DIR * dir)
 zzip_off_t 
 zzip_telldirzzip_telldir
 (ZZIP_DIR* dir)
 void
 zzip_seekdirzzip_seekdir
 (ZZIP_DIR* dir,
zzip_off_t offset)
  (../zzip/dir.c)
    This function is the equivalent of a rewinddir(2)for a realdir orthe zipfile in place of a directory. The ZZIP_DIR handle returned from
 
 zzip_opendirhas a flag saying realdir or zipfile. As for a zipfile,the filenames will include the filesubpath, so take care.
 (../zzip/dir.c)ZZIP_DIRENT* 
 zzip_readdir1000
 (ZZIP_DIR * dir)
  (../zzip/dir.c)
    This function is the equivalent of a readdir(2)for a realdiror a zipfile referenced by the ZZIP_DIR returned from
 zzip_opendir.  
   The ZZIP_DIR handle (as returned by zzip_opendir)contains a few moreentries than being copied into the ZZIP_DIRENT. The only valid fields in
 a ZZIP_DIRENT are d_name (the file name), d_compr (compression), d_csize
 (compressed size), st_size (uncompressed size).
 (../zzip/dir.c)ZZIP_DIR* 
 zzip_opendirzzip_opendir
 (zzip_char_t* filename)
 ZZIP_DIR* 
 zzip_opendir_ext_iozzip_opendir_ext_io
 (zzip_char_t* filename,
int o_modes,
zzip_strings_t* ext,
zzip_plugin_io_t io)
  (../zzip/dir.c)
    This function is the equivalent of opendir(3)for a realdir or zipfile.
  
   This function has some magic - if the given argument-path 
 is a directory, it will wrap a real
 opendir(3)into the ZZIP_DIRstructure. Otherwise it will divert to
 zzip_dir_openwhichcan also attach a ".zip" extension if needed to find the archive.
 
  
   the error-code is mapped to errno(3). (../zzip/dir.c)int
 zzip_closedirzzip_closedir
 (ZZIP_DIR* dir)
  (../zzip/dir.c)
    This function is the equivalent of closedir(3)for a realdir or zipfile.
  
   This function is magic - if the given arg-ZZIP_DIR 
 is a real directory, it will call the real
 closedir(3)and thenfree the wrapping ZZIP_DIR structure. Otherwise it will divert
 to
 zzip_dir_closewhich will free the ZZIP_DIR structure. (../zzip/dir.c)zzip_char_t* 
 zzip_strerrorzzip_strerror
 (int errcode)
 zzip_char_t* 
 zzip_strerror_ofzzip_strerror_of
 (ZZIP_DIR* dir)
  (../zzip/err.c)
    returns the static string for the given error code. The
 
 error code can be either a normal system error (a
 positive error code will flag this), it can be
 libzerror code (a small negative error code will flag this)
 or it can be an error code from
 libzzip, which is annegative value lower than
 ZZIP_ERROR (../zzip/err.c)int
 zzip_errnozzip_errno
 (int errcode)
  (../zzip/err.c)
    map the error code to a system error code. This is used
 
 for the drop-in replacement functions to return a value
 that can be interpreted correctly by code sections that
 are unaware of the fact they their
 open(2)call had beendiverted to a file inside a zip-archive.
 (../zzip/err.c)int 
 zzip_file_closezzip_file_close
 (ZZIP_FILE * fp)
  (../zzip/file.c)
    the direct function of zzip_close(fp). it will cleanup theinflate-portion of
 zliband free the structure given.  
   it is called quite from the error-cleanup parts 
 of the various
 _openfunctions.  
   the .refcount is decreased and if zero the fp->dir is closed just as well. 
 
 (../zzip/file.c)ZZIP_FILE * 
 zzip_file_openzzip_file_open
 (ZZIP_DIR * dir,
zzip_char_t* name,
int o_mode)
  (../zzip/file.c)
    open an ZZIP_FILEfrom an already openZZIP_DIRhandle. Sincewe have a chance to reuse a cached
 buf32kandZZIP_FILEmemchunkthis is the best choice to unpack multiple files.
  
   Note: the zlib supports 2..15 bit windowsize, hence we provide a 32k 
 memchunk here... just to be safe.
 (../zzip/file.c)static int 
 zzip_inflate_initzzip_inflate_init
 (ZZIP_FILE * fp,
struct zzip_dir_hdr* hdr)
  (../zzip/file.c)
     call inflateInitand setup fp's iterator variables,used by lowlevel
 _openfunctions. (../zzip/file.c)int 
 zzip_fclosezzip_fclose
 (ZZIP_FILE * fp)
 int 
 zzip_closezzip_close
 (ZZIP_FILE* fp)
  (../zzip/file.c)
    This function closes the given ZZIP_FILE handle.  
   
   If the ZZIP_FILE wraps a normal stat'fd then it is just that int'fd  
 that is being closed and the otherwise empty ZZIP_FILE gets freed.
 (../zzip/file.c)zzip_ssize_t 
 zzip_file_readzzip_file_read
 (ZZIP_FILE * fp,
char * buf,
zzip_size_t len)
  (../zzip/file.c)
    This functions read data from zip-contained file. 
   
   It works like read(2)and will fill the given buffer with bytes fromthe opened file. It will return the number of bytes read, so if the
 EOFis encountered you will be prompted with the number of bytes actually read.
  
   This is the routines that needs the buf32kbuffer, and it would haveneed for much more polishing but it does already work quite well.
  
   Note: the 32K buffer is rather big. The original inflate-algorithm 
 required just that but the latest zlib would work just fine with
 a smaller buffer.
 (../zzip/file.c)zzip_ssize_t
 zzip_readzzip_read
 (ZZIP_FILE * fp,
char * buf,
zzip_size_t len)
 zzip_size_t
 zzip_freadzzip_fread
 (void *ptr,
zzip_size_t size,
zzip_size_t nmemb,
ZZIP_FILE *file)
  (../zzip/file.c)
    This function will read(2) data from a real/zipped file. 
   
   the replacement for read(2)will fill the given buffer with bytes fromthe opened file. It will return the number of bytes read, so if the EOF
 is encountered you will be prompted with the number of bytes actually read.
  
   If the file-handle is wrapping a stat'able file then it will actually just 
 perform a normal
 read(2)-call, otherwisezzip_file_readis calledto decompress the data stream and any error is mapped to
 errno(3). (../zzip/file.c)ZZIP_FILE*
 zzip_fopenzzip_fopen
 (zzip_char_t* filename,
zzip_char_t* mode)
 ZZIP_FILE*
 zzip_freopenzzip_freopen
 (zzip_char_t* filename,
zzip_char_t* mode,
ZZIP_FILE* stream)
  (../zzip/file.c)
    This function will fopen(3)a real/zipped file.  
   It has some magic functionality builtin - it will first try to open 
 the given filename as a normal file. If it does not
 exist, the given path to the filename (if any) is split into
 its directory-part and the file-part. A ".zip" extension is
 then added to the directory-part to create the name of a
 zip-archive. That zip-archive (if it exists) is being searched
 for the file-part, and if found a zzip-handle is returned.
  
   Note that if the file is found in the normal fs-directory the 
 returned structure is mostly empty and the
 zzip_readcall willuse the libc
 readto obtain data. Otherwise azzip_file_openis performed and any error mapped to
 errno(3).  
   unlike the posix-wrapper zzip_openthe mode-argument isa string which allows for more freedom to support the extra
 zzip modes called ZZIP_CASEINSENSITIVE and ZZIP_IGNOREPATH.
 Currently, this
 zzip_fopencall will convert the followingcharacters in the mode-string into their corrsponding mode-bits:
 
 all other modes will be ignored for zip-contained entries "r" : O_RDONLY : read-only
 "b" : O_BINARY : binary (win32 specific)
 "f" : O_NOCTTY : no char device (unix)
 "i" : ZZIP_CASELESS : inside zip file
 "*" : ZZIP_NOPATHS : inside zip file only
 but they are transferred for compatibility and portability,
 including these extra sugar bits:
 
 ... the access bits are in traditional unix bit format "x" : O_EXCL :fail if file did exist
 "s" : O_SYNC :synchronized access
 "n" : O_NONBLOCK :nonblocking access
 "z#" : compression level :for zlib
 "g#" : group access :unix access bits
 "u#" : owner access :unix access bits
 "o#" : world access :unix access bits
 with 7 = read/write/execute, 6 = read/write, 4 = read-only.
  
   The default access mode is 0664, and the compression level 
 is ignored since the lib can not yet write zip files, otherwise
 it would be the initialisation value for the zlib deflateInit
 where 0 = no-compression, 1 = best-speed, 9 = best-compression.
 (../zzip/file.c)ZZIP_FILE*
 zzip_openzzip_open
 (zzip_char_t* filename,
int o_flags)
 ZZIP_FILE*
 zzip_open_ext_iozzip_open_ext_io
 (zzip_char_t* filename,
int o_flags,
int o_modes,
zzip_strings_t* ext,
zzip_plugin_io_t io)
 ZZIP_FILE*
 zzip_open_shared_iozzip_open_shared_io
 (ZZIP_FILE* stream,
zzip_char_t* filename,
int o_flags,
int o_modes,
zzip_strings_t* ext,
zzip_plugin_io_t io)
  (../zzip/file.c)
    This function will open(2)a real/zipped file  
   It has some magic functionality builtin - it will first try to open 
 the given filename as a normal file. If it does not
 exist, the given path to the filename (if any) is split into
 its directory-part and the file-part. A ".zip" extension is
 then added to the directory-part to create the name of a
 zip-archive. That zip-archive (if it exists) is being searched
 for the file-part, and if found a zzip-handle is returned.
  
   Note that if the file is found in the normal fs-directory the 
 returned structure is mostly empty and the
 zzip_readcall willuse the libc
 readto obtain data. Otherwise azzip_file_openis performed and any error mapped to
 errno(3).  
   There was a possibility to transfer zziplib-specific openmodes 
 through o_flags but you should please not use them anymore and
 look into
 zzip_open_ext_ioto submit them down. This functionis shallow in that it just extracts the zzipflags and calls
  
 zzip_open_ext_io(filename, o_flags, zzipflags|0664, 0, 0)
 you must stop using this extra functionality (not well known
 anyway) since zzip_open might be later usable to open files
 for writing in which case the _EXTRAFLAGS will get in conflict.
  
   compare with  open(2)andzzip_fopen (../zzip/file.c)int
 zzip_rewindzzip_rewind
 (ZZIP_FILE *fp)
  (../zzip/file.c)
    This function will rewind a real/zipped file.  
   
   It seeks to the beginning of this file's data in the zip,  
 or the beginning of the file for a stat'fd.
 (../zzip/file.c)zzip_off_t
 zzip_seekzzip_seek
 (ZZIP_FILE * fp,
zzip_off_t offset,
int whence)
  (../zzip/file.c)
    This function will perform a lseek(2)operation on a real/zipped file  
   It will try to seek to the offset specified by offset, relative to whence,  
 which is one of SEEK_SET, SEEK_CUR or SEEK_END.
  
   If the file-handle is wrapping a stat'able file then it will actually just 
 perform a normal
 lseek(2)-call. Otherwise the relative offsetis calculated, negative offsets are transformed into positive ones
 by rewinding the file, and then data is read until the offset is
 reached.  This can make the function terribly slow, but this is
 how gzio implements it, so I'm not sure there is a better way
 without using the internals of the algorithm.
 (../zzip/file.c)zzip_off_t
 zzip_tellzzip_tell
 (ZZIP_FILE * fp)
  (../zzip/file.c)
    This function will tell(2)the current position in a real/zipped file  
   It will return the current offset within the real/zipped file,  
 measured in uncompressed bytes for the zipped-file case.
  
   If the file-handle is wrapping a stat'able file then it will actually just 
 perform a normal
 tell(2)-call, otherwise the offset iscalculated from the amount of data left and the total uncompressed
 size;
 (../zzip/file.c)int 
 zzip_errorzzip_error
 (ZZIP_DIR * dir)
 void 
 zzip_seterrorzzip_seterror
 (ZZIP_DIR * dir,
int errcode)
  (../zzip/info.c)
     just returns dir->errcode of the ZZIP_DIR handle  
 see:
 zzip_dir_open,zzip_diropen,zzip_readdir,zzip_dir_read (../zzip/info.c)ZZIP_DIR * 
 zzip_dirhandlezzip_dirhandle
 (ZZIP_FILE * fp)
 int 
 zzip_dirfdzzip_dirfd
 (ZZIP_DIR* dir)
  (../zzip/info.c)
    This function will just return fp->dir  
   
   If a ZZIP_FILE is contained within a zip-file that one will be a valid 
 pointer, otherwise a NULL is returned and the ZZIP_FILE wraps a real file.
 (../zzip/info.c)zzip_char_t*
 zzip_compr_strzzip_compr_str
 (int compr)
  (../zzip/info.c)
    return static const string of the known compression methods,  
 otherwise just "zipped" is returned
 (../zzip/info.c)int
 zzip_file_realzzip_file_real
 (ZZIP_FILE* fp)
 int
 zzip_dir_realzzip_dir_real
 (ZZIP_DIR* dir)
 void*
 zzip_realdirzzip_realdir
 (ZZIP_DIR* dir)
 int
 zzip_realfdzzip_realfd
 (ZZIP_FILE* fp)
  (../zzip/info.c)
    This function checks if the ZZIP_FILE-handle is wrapping  
 a real file or a zip-contained file.
 Returns 1 for a stat'able file, and 0 for a file inside a zip-archive.
 (../zzip/info.c)int 
 zzip_init_iozzip_init_io
 (struct zzip_plugin_io* io,
int flags)
 zzip_plugin_io_t
 zzip_get_default_iozzip_get_default_io
 ()
  (../zzip/plugin.c)
    This function initializes the users handler struct to default values  
 being the posix io functions in default configured environments.
 (../zzip/plugin.c)int 
 zzip_dir_statzzip_dir_stat
 (ZZIP_DIR * dir,
zzip_char_t* name,
ZZIP_STAT * zs,
int flags)
  (../zzip/stat.c)
    obtain information about a filename in an opened zip-archive without  
 opening that file first. Mostly used to obtain the uncompressed
 size of a file inside a zip-archive. see
 zzip_dir_open. (../zzip/stat.c)uint32_t 
 __zzip_get32__zzip_get32
 (unsigned char * s)
  (../zzip/zip.c)
    Make 32 bit value in host byteorder from little-endian mapped octet-data 
 (works also on machines which SIGBUS on misaligned data access (eg. 68000))
 (../zzip/zip.c)int 
 __zzip_find_disk_trailer__zzip_find_disk_trailer
 (int fd,
zzip_off_t filesize,
struct zzip_disk_trailer * trailer,
zzip_plugin_io_t io)
  (../zzip/zip.c)
    This function is used by zzip_file_open. It tries to findthe zip's central directory info that is usually a few
 bytes off the end of the file.
 (../zzip/zip.c)int 
 __zzip_parse_root_directory__zzip_parse_root_directory
 (int fd,
struct zzip_disk_trailer * trailer,
struct zzip_dir_hdr ** hdr_return,
zzip_plugin_io_t io)
  (../zzip/zip.c)
    This function is used by zzip_file_open, it is usually called after
 __zzip_find_disk_trailer. It will parse the zip's central directoryinformation and create a zziplib private directory table in
 memory.
 (../zzip/zip.c)ZZIP_DIR*
 zzip_dir_alloc_ext_iozzip_dir_alloc_ext_io
 (zzip_strings_t* ext,
const zzip_plugin_io_t io)
 ZZIP_DIR*
 zzip_dir_alloczzip_dir_alloc
 (zzip_strings_t* fileext)
  (../zzip/zip.c)
    allocate a new ZZIP_DIR handle and do basic  
 initializations before usage by
 zzip_dir_fdopen
 zzip_dir_openzzip_file_openor through
 zzip_open(ext==null flags uses { ".zip" , ".ZIP" } )
 (io ==null flags use of posix io defaults)
 (../zzip/zip.c)int 
 zzip_dir_freezzip_dir_free
 (ZZIP_DIR * dir)
  (../zzip/zip.c)
    will free the zzip_dir handle unless there are still  
 zzip_files attached (that may use its cache buffer).
 This is the inverse of
 zzip_dir_alloc, and bothare helper functions used implicitly in other zzipcalls
 e.g.
 zzip_dir_close= zzip_close  
   returns zero on success
 returns the refcount when files are attached.
 (../zzip/zip.c)int 
 zzip_dir_closezzip_dir_close
 (ZZIP_DIR * dir)
  (../zzip/zip.c)
    It will also free(2)theZZIP_DIR-handle given.the counterpart for
 zzip_dir_opensee also
 zzip_dir_free (../zzip/zip.c)ZZIP_DIR * 
 zzip_dir_fdopenzzip_dir_fdopen
 (int fd,
zzip_error_t * errcode_p)
 ZZIP_DIR * 
 zzip_dir_fdopen_ext_iozzip_dir_fdopen_ext_io
 (int fd,
zzip_error_t * errcode_p,
zzip_strings_t* ext,
const zzip_plugin_io_t io)
  (../zzip/zip.c)
    used by the zzip_dir_openand zzip_opendir(2) call. Opens thezip-archive as specified with the fd which points to an
 already openend file. This function then search and parse
 the zip's central directory.
 
   
   NOTE: refcount is zero, so an _open/_close pair will also delete  
 this _dirhandle
 (../zzip/zip.c)int
 __zzip_try_open__zzip_try_open
 (zzip_char_t* filename,
int filemode,
zzip_strings_t* ext,
zzip_plugin_io_t io)
  (../zzip/zip.c)
    will attach a .zip extension and tries to open it 
 the with
 open(2). This is a helper function for
 zzip_dir_open,zzip_opendirandzzip_open. (../zzip/zip.c)ZZIP_DIR* 
 zzip_dir_openzzip_dir_open
 (zzip_char_t* filename,
zzip_error_t* e)
 ZZIP_DIR* 
 zzip_dir_open_ext_iozzip_dir_open_ext_io
 (zzip_char_t* filename,
zzip_error_t* e,
zzip_strings_t* ext,
zzip_plugin_io_t io)
  (../zzip/zip.c)
    Opens the zip-archive (if available). 
 the two ext_io arguments will default to use posix io and
 a set of default fileext that can atleast add .zip ext itself.
 (../zzip/zip.c)int
 zzip_dir_readzzip_dir_read
 (ZZIP_DIR * dir,
ZZIP_DIRENT * d )
  (../zzip/zip.c)
    fills the dirent-argument with the values and  
 increments the read-pointer of the dir-argument.
 
  
   returns 0 if there no entry (anymore). 
 
 (../zzip/zip.c) |