mirror of https://github.com/Cisco-Talos/clamav
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
338 lines
10 KiB
338 lines
10 KiB
/*
|
|
* Author:
|
|
* Guido Draheim <guidod@gmx.de>
|
|
* Tomi Ollila <Tomi.Ollila@iki.fi>
|
|
*
|
|
* Copyright (c) 1999,2000,2001,2002,2003 Guido Draheim
|
|
* All rights reserved,
|
|
* usage allowed under the restrictions of the
|
|
* Lesser GNU General Public License
|
|
* note the additional license information
|
|
* that can be found in COPYING.ZZIP
|
|
*
|
|
* if you see "unknown symbol" errors, check first that `-I ..` is part of
|
|
* your compiler options - a special hint to VC/IDE users who tend to make up
|
|
* their own workspace files. All includes look like #include <zzip|*.h>, so
|
|
* you need to add an include path to the dir containing (!!) the ./zzip/ dir
|
|
*/
|
|
|
|
#if HAVE_CONFIG_H
|
|
#include "clamav-config.h"
|
|
#endif
|
|
|
|
#ifndef _ZZIP_ZZIP_H /* zziplib.h */
|
|
#define _ZZIP_ZZIP_H
|
|
|
|
#include <zzip-conf.h>
|
|
|
|
#include <fcntl.h>
|
|
#include <stddef.h> /* size_t and friends */
|
|
/* msvc6 has neither ssize_t (we assume "int") nor off_t (assume "long") */
|
|
|
|
#ifdef C_OS2
|
|
#include <types.h>
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* the zzip_error_t is also used to pass back ZLIB errors... */
|
|
#define ZZIP_ERROR -4096
|
|
|
|
typedef enum
|
|
{
|
|
ZZIP_NO_ERROR = 0, /* no error, may be used if user sets it. */
|
|
ZZIP_OUTOFMEM = ZZIP_ERROR-20, /* out of memory */
|
|
ZZIP_DIR_OPEN = ZZIP_ERROR-21, /* failed to open zipfile, see errno for details */
|
|
ZZIP_DIR_STAT = ZZIP_ERROR-22, /* failed to fstat zipfile, see errno for details */
|
|
ZZIP_DIR_SEEK = ZZIP_ERROR-23, /* failed to lseek zipfile, see errno for details */
|
|
ZZIP_DIR_READ = ZZIP_ERROR-24, /* failed to read zipfile, see errno for details */
|
|
ZZIP_DIR_TOO_SHORT = ZZIP_ERROR-25,
|
|
ZZIP_DIR_EDH_MISSING = ZZIP_ERROR-26,
|
|
ZZIP_DIRSIZE = ZZIP_ERROR-27,
|
|
ZZIP_ENOENT = ZZIP_ERROR-28,
|
|
ZZIP_UNSUPP_COMPR = ZZIP_ERROR-29,
|
|
ZZIP_CORRUPTED = ZZIP_ERROR-31,
|
|
ZZIP_UNDEF = ZZIP_ERROR-32,
|
|
} zzip_error_t;
|
|
|
|
/*
|
|
* zzip_open flags.
|
|
*/
|
|
#define ZZIP_CASEINSENSITIVE O_APPEND /* do not use anymore. use CASLESS */
|
|
#define ZZIP_IGNOREPATH O_TRUNC /* do not use anymore. use NOPATHS */
|
|
#define ZZIP_EXTRAFLAGS (ZZIP_CASEINSENSITIVE|ZZIP_IGNOREPATH)
|
|
|
|
/* zzip_open_ext_io o_modes flags : new style. use these from now on! */
|
|
#define ZZIP_CASELESS (1<<12) /* ignore filename case inside zips */
|
|
#define ZZIP_NOPATHS (1<<13) /* ignore subdir paths, just filename*/
|
|
#define ZZIP_PREFERZIP (1<<14) /* try first zipped file, then real*/
|
|
#define ZZIP_ONLYZIP (1<<16) /* try _only_ zipped file, skip real*/
|
|
#define ZZIP_FACTORY (1<<17) /* old file handle is not closed */
|
|
#define ZZIP_ALLOWREAL (1<<18) /* real files use default_io (magic) */
|
|
|
|
/*
|
|
* zzip largefile renames
|
|
*/
|
|
#ifdef ZZIP_LARGEFILE_RENAME
|
|
#define zzip_telldir zzip_telldir64
|
|
#define zzip_seekdir zzip_seekdir64
|
|
#endif
|
|
|
|
/*
|
|
* zzip typedefs
|
|
*/
|
|
/* zzip_strings_t ext[] = { ".zip", ".jar", ".pk3", 0 } */
|
|
typedef char _zzip_const * _zzip_const zzip_strings_t;
|
|
typedef char _zzip_const zzip_char_t;
|
|
typedef _zzip_off_t zzip_off_t;
|
|
typedef _zzip_size_t zzip_size_t;
|
|
typedef _zzip_ssize_t zzip_ssize_t;
|
|
typedef struct zzip_dir ZZIP_DIR;
|
|
typedef struct zzip_file ZZIP_FILE;
|
|
typedef struct zzip_dirent ZZIP_DIRENT;
|
|
typedef struct zzip_dirent ZZIP_STAT;
|
|
|
|
struct zzip_dirent
|
|
{
|
|
int d_compr; /* compression method */
|
|
int d_csize; /* compressed size */
|
|
int st_size; /* file size / decompressed size */
|
|
unsigned short d_flags; /* general purpose flags */
|
|
char * d_name; /* file name / strdupped name */
|
|
int d_crc32; /* the adler32-checksum */
|
|
int d_off; /* the offset in the file */
|
|
};
|
|
|
|
/*
|
|
* Getting error strings
|
|
* zzip/err.c
|
|
*/
|
|
_zzip_export /* error in _opendir : */
|
|
zzip_char_t* zzip_strerror(int errcode);
|
|
_zzip_export /* error in other functions : */
|
|
zzip_char_t* zzip_strerror_of(ZZIP_DIR * dir);
|
|
_zzip_export /* error mapped to errno.h defines : */
|
|
int zzip_errno(int errcode);
|
|
|
|
|
|
/*
|
|
* Functions to grab information from ZZIP_DIR/ZZIP_FILE structure
|
|
* (if ever needed)
|
|
* zzip/info.c
|
|
*/
|
|
_zzip_export
|
|
int zzip_error(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
void zzip_seterror(ZZIP_DIR * dir, int errcode);
|
|
_zzip_export
|
|
zzip_char_t* zzip_compr_str(int compr);
|
|
|
|
_zzip_export
|
|
ZZIP_DIR * zzip_dirhandle(ZZIP_FILE * fp);
|
|
_zzip_export
|
|
int zzip_dirfd(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
int zzip_dir_real(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
int zzip_file_real(ZZIP_FILE * fp);
|
|
_zzip_export
|
|
void* zzip_realdir(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
int zzip_realfd(ZZIP_FILE * fp);
|
|
|
|
/*
|
|
* zip handle management
|
|
* zzip/zip.c
|
|
*/
|
|
_zzip_export
|
|
ZZIP_DIR * zzip_dir_alloc(zzip_strings_t* fileext);
|
|
_zzip_export
|
|
int zzip_dir_free(ZZIP_DIR *);
|
|
|
|
/*
|
|
* Opening/closing a zip archive
|
|
* zzip-zip.c
|
|
*/
|
|
_zzip_export
|
|
ZZIP_DIR * zzip_dir_fdopen(int fd, zzip_error_t * errcode_p);
|
|
_zzip_export
|
|
ZZIP_DIR * zzip_dir_open(zzip_char_t* filename, zzip_error_t * errcode_p);
|
|
_zzip_export
|
|
int zzip_dir_close(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
int zzip_dir_read(ZZIP_DIR * dir, ZZIP_DIRENT * dirent);
|
|
|
|
|
|
/*
|
|
* Scanning files in zip archive
|
|
* zzip/dir.c
|
|
* zzip/zip.c
|
|
*/
|
|
_zzip_export
|
|
ZZIP_DIR * zzip_opendir(zzip_char_t* filename);
|
|
_zzip_export
|
|
int zzip_closedir(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
ZZIP_DIRENT * zzip_readdir(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
void zzip_rewinddir(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
zzip_off_t zzip_telldir(ZZIP_DIR * dir);
|
|
_zzip_export
|
|
void zzip_seekdir(ZZIP_DIR * dir, zzip_off_t offset);
|
|
|
|
/*
|
|
* 'opening', 'closing' and reading invidual files in zip archive.
|
|
* zzip/file.c
|
|
*/
|
|
_zzip_export
|
|
ZZIP_FILE * zzip_file_open(ZZIP_DIR * dir, zzip_char_t* name, int modes, int d_off);
|
|
_zzip_export
|
|
int zzip_file_close(ZZIP_FILE * fp);
|
|
_zzip_export
|
|
zzip_ssize_t zzip_file_read(ZZIP_FILE * fp, char* buf, zzip_size_t len);
|
|
|
|
_zzip_export
|
|
ZZIP_FILE * zzip_open(zzip_char_t* name, int flags);
|
|
_zzip_export
|
|
int zzip_close(ZZIP_FILE * fp);
|
|
_zzip_export
|
|
zzip_ssize_t zzip_read(ZZIP_FILE * fp, char * buf, zzip_size_t len);
|
|
|
|
/*
|
|
* the stdc variant to open/read/close files. - Take note of the freopen()
|
|
* call as it may reuse an existing preparsed copy of a zip central directory
|
|
*/
|
|
_zzip_export
|
|
ZZIP_FILE* zzip_freopen(zzip_char_t* name, zzip_char_t* mode, ZZIP_FILE*);
|
|
_zzip_export
|
|
ZZIP_FILE* zzip_fopen(zzip_char_t* name, zzip_char_t* mode);
|
|
_zzip_export
|
|
zzip_size_t zzip_fread(void *ptr, zzip_size_t size, zzip_size_t nmemb,
|
|
ZZIP_FILE * file);
|
|
_zzip_export
|
|
int zzip_fclose(ZZIP_FILE * fp);
|
|
|
|
/*
|
|
* seek and tell functions
|
|
*/
|
|
_zzip_export
|
|
int zzip_rewind(ZZIP_FILE *fp);
|
|
_zzip_export
|
|
zzip_off_t zzip_seek(ZZIP_FILE * fp, zzip_off_t offset, int whence);
|
|
_zzip_export
|
|
zzip_off_t zzip_tell(ZZIP_FILE * fp);
|
|
|
|
/*
|
|
* reading info of a single file
|
|
* zzip/stat.c
|
|
*/
|
|
_zzip_export
|
|
int zzip_dir_stat(ZZIP_DIR * dir, zzip_char_t* name,
|
|
ZZIP_STAT * zs, int flags);
|
|
|
|
#ifdef ZZIP_LARGEFILE_RENAME
|
|
#define zzip_open_shared_io zzip_open_shared_io64
|
|
#define zzip_open_ext_io zzip_open_ext_io64
|
|
#define zzip_opendir_ext_io zzip_opendir_ext_io64
|
|
#define zzip_dir_open_ext_io zzip_dir_open_ext_io64
|
|
#define zzip_plugin_io_t zzip_plugin_io64_t
|
|
#endif
|
|
|
|
/*
|
|
* all ext_io functions can be called with a default of ext/io == zero/zero
|
|
* which will default to a ".zip" extension and posix io of the system.
|
|
*/
|
|
typedef struct zzip_plugin_io _zzip_const * zzip_plugin_io_t;
|
|
|
|
_zzip_export
|
|
ZZIP_FILE * zzip_open_shared_io(ZZIP_FILE* stream,
|
|
zzip_char_t* name, int o_flags, int o_modes,
|
|
zzip_strings_t* ext, zzip_plugin_io_t io);
|
|
|
|
_zzip_export
|
|
ZZIP_FILE * zzip_open_ext_io(zzip_char_t* name, int o_flags, int o_modes,
|
|
zzip_strings_t* ext, zzip_plugin_io_t io);
|
|
|
|
_zzip_export
|
|
ZZIP_DIR * zzip_opendir_ext_io(zzip_char_t* name, int o_modes,
|
|
zzip_strings_t* ext, zzip_plugin_io_t io);
|
|
|
|
_zzip_export
|
|
ZZIP_FILE * zzip_file_open_ext_io(ZZIP_DIR * dir,
|
|
zzip_char_t* name, int flags,
|
|
zzip_strings_t* ext, zzip_plugin_io_t io);
|
|
|
|
_zzip_export
|
|
ZZIP_DIR * zzip_dir_open_ext_io(zzip_char_t* filename,
|
|
zzip_error_t* errcode_p,
|
|
zzip_strings_t* ext, zzip_plugin_io_t io);
|
|
|
|
#if defined _ZZIP_WRITE_SOURCE
|
|
/* ........................................................................
|
|
* write support is not yet implemented
|
|
* zzip/write.c
|
|
*/
|
|
#define ZZIP_NO_CREAT 1
|
|
|
|
ZZIP_DIR* zzip_dir_creat_ext_io(zzip_char_t* name, int o_mode,
|
|
zzip_strings_t* ext, zzip_plugin_io_t io);
|
|
ZZIP_DIR* zzip_dir_creat(zzip_char_t* name, int o_mode);
|
|
int zzip_file_mkdir(ZZIP_DIR* dir, zzip_char_t* name, int o_mode);
|
|
ZZIP_FILE* zzip_file_creat(ZZIP_DIR* dir, zzip_char_t* name, int o_mode);
|
|
zzip_ssize_t zzip_file_write(ZZIP_FILE* file,
|
|
const void* ptr, zzip_size_t len);
|
|
|
|
ZZIP_DIR* zzip_createdir(zzip_char_t* name, int o_mode);
|
|
zzip_ssize_t zzip_write(ZZIP_FILE* file, const void* ptr, zzip_size_t len);
|
|
zzip_size_t zzip_fwrite(const void* ptr, zzip_size_t len,
|
|
zzip_size_t multiply, ZZIP_FILE* file);
|
|
#ifndef zzip_savefile
|
|
#define zzip_savefile 0
|
|
#define zzip_savefile_is_null
|
|
#endif
|
|
|
|
#ifdef _ZZIP_NO_INLINE
|
|
#define zzip_mkdir(_name_,_mode_) \
|
|
zzip_file_mkdir((zzip_savefile),(_name_),(_mode_))
|
|
#define zzip_creat(_name_,_mode_) \
|
|
zzip_file_creat((zzip_savefile),(_name_),(_mode_))
|
|
#define zzip_sync() \
|
|
{ zzip_closedir((zzip_savefile)); (zzip_savefile) = 0; }
|
|
#define zzip_start(_name_,_mode_,_ext_) \
|
|
{ if ((zzip_savefile)) zzip_closedir((zzip_savefile));
|
|
zzip_savefile = zzip_dir_creat(_name_, _mode_,_ext_); }
|
|
|
|
#else
|
|
|
|
_zzip_inline static int zzip_mkdir(zzip_char_t* name, int o_mode)
|
|
{ return zzip_file_mkdir(zzip_savefile, name, o_mode); }
|
|
_zzip_inline static ZZIP_FILE* zzip_creat(zzip_char_t* name, int o_mode)
|
|
{ return zzip_file_creat(zzip_savefile, name, o_mode); }
|
|
|
|
#ifndef zzip_savefile_is_null
|
|
_zzip_inline static void zzip_sync(void)
|
|
{ zzip_closedir(zzip_savefile); zzip_savefile = 0; }
|
|
_zzip_inline static void zzip_mkfifo(zzip_char_t* name, int o_mode)
|
|
{ if ((zzip_savefile)) zzip_closedir (zzip_savefile);
|
|
zzip_savefile = zzip_createdir(_name_,_mode_); }
|
|
#else
|
|
_zzip_inline static void zzip_sync(void) {}
|
|
_zzip_inline static void zzip_mkfifo(zzip_char_t* name, int o_mode) {}
|
|
#endif
|
|
#endif /* _ZZIP_NO_INLINE */
|
|
#endif /* _ZZIP_WRITE_SOURCE */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _ZZIPLIB_H */
|
|
|
|
/*
|
|
* Local variables:
|
|
* c-file-style: "stroustrup"
|
|
* End:
|
|
*/
|
|
|