rainlance
/
unzip
mirror of https://frontier.innolan.net/rainlance/unzip.git
1
0
Fork 0
Code Releases Activity
unzip/globals.h

444 lines
17 KiB
C
Raw Permalink Blame History

/*
Copyright (c) 1990-2009 Info-ZIP. All rights reserved.
See the accompanying file LICENSE, version 2009-Jan-02 or later
(the contents of which are also included in unzip.h) for terms of use.
If, for some reason, all these files are missing, the Info-ZIP license
also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
*/
/*---------------------------------------------------------------------------
globals.h
There is usually no need to include this file since unzip.h includes it.
This header file is used by all of the UnZip source files. It contains
a struct definition that is used to "house" all of the global variables.
This is done to allow for multithreaded environments (OS/2, NT, Win95,
Unix) to call UnZip through an API without a semaphore. REENTRANT should
be defined for all platforms that require this.
GLOBAL CONSTRUCTOR AND DESTRUCTOR (API WRITERS READ THIS!!!)
------------------------------------------------------------
No, it's not C++, but it's as close as we can get with K&R.
The main() of each process that uses these globals must include the
CONSTRUCTGLOBALS; statement. This will malloc enough memory for the
structure and initialize any variables that require it. This must
also be done by any API function that jumps into the middle of the
code.
The DESTROYGLOBALS(); statement should be inserted before EVERY "EXIT(n)".
Naturally, it also needs to be put before any API returns as well.
In fact, it's much more important in API functions since the process
will NOT end, and therefore the memory WON'T automatically be freed
by the operating system.
USING VARIABLES FROM THE STRUCTURE
----------------------------------
All global variables must now be prefixed with `G.' which is either a
global struct (in which case it should be the only global variable) or
a macro for the value of a local pointer variable that is passed from
function to function. Yes, this is a pain. But it's the only way to
allow full reentrancy.
ADDING VARIABLES TO THE STRUCTURE
---------------------------------
If you make the inclusion of any variables conditional, be sure to only
check macros that are GUARANTEED to be included in every module.
For instance, newzip and pwdarg are needed only if CRYPT is TRUE,
but this is defined after unzip.h has been read. If you are not careful,
some modules will expect your variable to be part of this struct while
others won't. This will cause BIG problems. (Inexplicable crashes at
strange times, car fires, etc.) When in doubt, always include it!
Note also that UnZipSFX needs a few variables that UnZip doesn't. However,
it also includes some object files from UnZip. If we were to conditionally
include the extra variables that UnZipSFX needs, the object files from
UnZip would not mesh with the UnZipSFX object files. Result: we just
include the UnZipSFX variables every time. (It's only an extra 4 bytes
so who cares!)
ADDING FUNCTIONS
----------------
To support this new global struct, all functions must now conditionally
pass the globals pointer (pG) to each other. This is supported by 5 macros:
__GPRO, __GPRO__, __G, __G__ and __GDEF. A function that needs no other
parameters would look like this:
int extract_or_test_files(__G)
__GDEF
{
... stuff ...
}
A function with other parameters would look like:
int memextract(__G__ tgt, tgtsize, src, srcsize)
__GDEF
uch *tgt, *src;
ulg tgtsize, srcsize;
{
... stuff ...
}
In the Function Prototypes section of unzpriv.h, you should use __GPRO and
__GPRO__ instead:
int uz_opts OF((__GPRO__ int *pargc, char ***pargv));
int process_zipfiles OF((__GPRO));
Note that there is NO comma after __G__ or __GPRO__ and no semi-colon after
__GDEF. I wish there was another way but I don't think there is.
TESTING THE CODE
-----------------
Whether your platform requires reentrancy or not, you should always try
building with REENTRANT defined if any functions have been added. It is
pretty easy to forget a __G__ or a __GDEF and this mistake will only show
up if REENTRANT is defined. All platforms should run with REENTRANT
defined. Platforms that can't take advantage of it will just be paying
a performance penalty needlessly.
SIGNAL MADNESS
--------------
This whole pointer passing scheme falls apart when it comes to SIGNALs.
I handle this situation 2 ways right now. If you define USETHREADID,
UnZip will include a 64-entry table. Each entry can hold a global
pointer and thread ID for one thread. This should allow up to 64
threads to access UnZip simultaneously. Calling DESTROYGLOBALS()
will free the global struct and zero the table entry. If somebody
forgets to call DESTROYGLOBALS(), this table will eventually fill up
and UnZip will exit with an error message. A good way to test your
code to make sure you didn't forget a DESTROYGLOBALS() is to change
THREADID_ENTRIES to 3 or 4 in globals.c, making the table real small.
Then make a small test program that calls your API a dozen times.
Those platforms that don't have threads still need to be able to compile
with REENTRANT defined to test and see if new code is correctly written
to work either way. For these platforms, I simply keep a global pointer
called GG that points to the Globals structure. Good enough for testing.
I believe that NT has thread level storage. This could probably be used
to store a global pointer for the sake of the signal handler more cleanly
than my table approach.
---------------------------------------------------------------------------*/
#ifndef __globals_h
#define __globals_h
#ifdef USE_ZLIB
# include "zlib.h"
# ifdef zlib_version /* This name is used internally in unzip */
# undef zlib_version /* and must not be defined as a macro. */
# endif
#endif
#ifdef USE_BZIP2
# include "bzlib.h"
#endif
/*************/
/* Globals */
/*************/
typedef struct Globals {
#ifdef DLL
zvoid *callerglobs; /* pointer to structure of pass-through global vars */
#endif
/* command options of general use */
UzpOpts UzO; /* command options of general use */
#ifndef FUNZIP
/* command options specific to the high level command line interface */
#ifdef MORE
int M_flag; /* -M: built-in "more" function */
#endif
/* internal flags and general globals */
#ifdef MORE
int height; /* check for SIGWINCH, etc., eventually... */
int lines; /* count of lines displayed on current screen */
# if (defined(SCREENWIDTH) && defined(SCREENLWRAP))
int width;
int chars; /* count of screen characters in current line */
# endif
#endif /* MORE */
#if (defined(IZ_CHECK_TZ) && defined(USE_EF_UT_TIME))
int tz_is_valid; /* indicates that timezone info can be used */
#endif
int noargs; /* did true command line have *any* arguments? */
unsigned filespecs; /* number of real file specifications to be matched */
unsigned xfilespecs; /* number of excluded filespecs to be matched */
int process_all_files;
int overwrite_mode; /* 0 - query, 1 - always, 2 - never */
int create_dirs; /* used by main(), mapname(), checkdir() */
int extract_flag;
int newzip; /* reset in extract.c; used in crypt.c */
zoff_t real_ecrec_offset;
zoff_t expect_ecrec_offset;
zoff_t csize; /* used by decompr. (NEXTBYTE): must be signed */
zoff_t used_csize; /* used by extract_or_test_member(), explode() */
#ifdef DLL
int fValidate; /* true if only validating an archive */
int filenotfound;
int redirect_data; /* redirect data to memory buffer */
int redirect_text; /* redirect text output to buffer */
# ifndef NO_SLIDE_REDIR
int redirect_slide; /* redirect decompression area to mem buffer */
# if (defined(USE_DEFLATE64) && defined(INT_16BIT))
ulg _wsize; /* size of sliding window exceeds "unsigned" range */
# else
unsigned _wsize; /* sliding window size can be hold in unsigned */
# endif
# endif
ulg redirect_size; /* size of redirected output buffer */
uch *redirect_buffer; /* pointer to head of allocated buffer */
uch *redirect_pointer; /* pointer past end of written data */
# ifndef NO_SLIDE_REDIR
uch *redirect_sldptr; /* head of decompression slide buffer */
# endif
# ifdef OS2DLL
cbList(processExternally); /* call-back list */
# endif
#endif /* DLL */
char **pfnames;
char **pxnames;
char sig[4];
char answerbuf[10];
min_info info[DIR_BLKSIZ];
min_info *pInfo;
#endif /* !FUNZIP */
union work area; /* see unzpriv.h for definition of work */
#if (!defined(USE_ZLIB) || defined(USE_OWN_CRCTAB))
ZCONST ulg near *crc_32_tab;
#else
ZCONST ulg Far *crc_32_tab;
#endif
ulg crc32val; /* CRC shift reg. (was static in funzip) */
#ifdef FUNZIP
FILE *in; /* file descriptor of compressed stream */
#endif
uch *inbuf; /* input buffer (any size is OK) */
uch *inptr; /* pointer into input buffer */
int incnt;
#ifndef FUNZIP
ulg bitbuf;
int bits_left; /* unreduce and unshrink only */
int zipeof;
char *argv0; /* used for NT and EXE_EXTENSION */
char *wildzipfn;
char *zipfn; /* GRR: WINDLL: must nuke any malloc'd zipfn... */
#ifdef USE_STRM_INPUT
FILE *zipfd; /* zipfile file descriptor */
#else
int zipfd; /* zipfile file handle */
#endif
zoff_t ziplen;
zoff_t cur_zipfile_bufstart; /* extract_or_test, readbuf, ReadByte */
zoff_t extra_bytes; /* used in unzip.c, misc.c */
uch *extra_field; /* Unix, VMS, Mac, OS/2, Acorn, ... */
uch *hold;
local_file_hdr lrec; /* used in unzip.c, extract.c */
cdir_file_hdr crec; /* used in unzip.c, extract.c, misc.c */
ecdir_rec ecrec; /* used in unzip.c, extract.c */
z_stat statbuf; /* used by main, mapname, check_for_newer */
int mem_mode;
uch *outbufptr; /* extract.c static */
ulg outsize; /* extract.c static */
int reported_backslash; /* extract.c static */
int disk_full;
int newfile;
int didCRlast; /* fileio static */
ulg numlines; /* fileio static: number of lines printed */
int sol; /* fileio static: at start of line */
int no_ecrec; /* process static */
#ifdef SYMLINKS
int symlnk;
slinkentry *slink_head; /* pointer to head of symlinks list */
slinkentry *slink_last; /* pointer to last entry in symlinks list */
#endif
#ifdef NOVELL_BUG_FAILSAFE
int dne; /* true if stat() says file doesn't exist */
#endif
FILE *outfile;
uch *outbuf;
uch *realbuf;
#ifndef VMS /* if SMALL_MEM, outbuf2 is initialized in */
uch *outbuf2; /* process_zipfiles() (never changes); */
#endif /* else malloc'd ONLY if unshrink and -a */
#endif /* !FUNZIP */
uch *outptr;
ulg outcnt; /* number of chars stored in outbuf */
#ifndef FUNZIP
char filename[FILNAMSIZ]; /* also used by NT for temporary SFX path */
#ifdef UNICODE_SUPPORT
char *filename_full; /* the full path so Unicode checks work */
extent fnfull_bufsize; /* size of allocated filename buffer */
int unicode_escape_all;
int unicode_mismatch;
#ifdef UTF8_MAYBE_NATIVE
int native_is_utf8; /* bool, TRUE => native charset == UTF-8 */
#endif
int unipath_version; /* version of Unicode field */
ulg unipath_checksum; /* Unicode field checksum */
char *unipath_filename; /* UTF-8 path */
#endif /* UNICODE_SUPPORT */
#ifdef CMS_MVS
char *tempfn; /* temp file used; erase on close */
#endif
char *key; /* crypt static: decryption password or NULL */
int nopwd; /* crypt static */
#endif /* !FUNZIP */
z_uint4 keys[3]; /* crypt static: keys defining pseudo-random sequence */
#if (!defined(DOS_FLX_H68_NLM_OS2_W32) && !defined(AMIGA) && !defined(RISCOS))
#if (!defined(MACOS) && !defined(ATARI) && !defined(VMS))
int echofd; /* ttyio static: file descriptor whose echo is off */
#endif /* !(MACOS || ATARI || VMS) */
#endif /* !(DOS_FLX_H68_NLM_OS2_W32 || AMIGA || RISCOS) */
unsigned hufts; /* track memory usage */
#ifdef USE_ZLIB
int inflInit; /* inflate static: zlib inflate() initialized */
z_stream dstrm; /* inflate global: decompression stream */
#else
struct huft *fixed_tl; /* inflate static */
struct huft *fixed_td; /* inflate static */
unsigned fixed_bl, fixed_bd; /* inflate static */
#ifdef USE_DEFLATE64
struct huft *fixed_tl64; /* inflate static */
struct huft *fixed_td64; /* inflate static */
unsigned fixed_bl64, fixed_bd64; /* inflate static */
struct huft *fixed_tl32; /* inflate static */
struct huft *fixed_td32; /* inflate static */
unsigned fixed_bl32, fixed_bd32; /* inflate static */
ZCONST ush *cplens; /* inflate static */
ZCONST uch *cplext; /* inflate static */
ZCONST uch *cpdext; /* inflate static */
#endif
unsigned wp; /* inflate static: current position in slide */
ulg bb; /* inflate static: bit buffer */
unsigned bk; /* inflate static: bits count in bit buffer */
#endif /* ?USE_ZLIB */
#ifndef FUNZIP
/* cylindric buffer space for formatting zoff_t values (fileio static) */
char fzofft_buf[FZOFFT_NUM][FZOFFT_LEN];
int fzofft_index;
#ifdef SMALL_MEM
char rgchBigBuffer[512];
char rgchSmallBuffer[96];
char rgchSmallBuffer2[160]; /* boosted to 160 for local3[] in unzip.c */
#endif
MsgFn *message;
InputFn *input;
PauseFn *mpause;
PasswdFn *decr_passwd;
StatCBFn *statreportcb;
#ifdef WINDLL
LPUSERFUNCTIONS lpUserFunctions;
#endif
int incnt_leftover; /* so improved NEXTBYTE does not waste input */
uch *inptr_leftover;
#ifdef VMS_TEXT_CONV
unsigned VMS_line_length; /* so native VMS variable-length text files */
int VMS_line_state; /* are readable on other platforms */
int VMS_line_pad;
#endif
#if (defined(SFX) && defined(CHEAP_SFX_AUTORUN))
char autorun_command[FILNAMSIZ];
#endif
#endif /* !FUNZIP */
#ifdef SYSTEM_SPECIFIC_GLOBALS
SYSTEM_SPECIFIC_GLOBALS
#endif
} Uz_Globs; /* end of struct Globals */
/***************************************************************************/
#define CRC_32_TAB G.crc_32_tab
Uz_Globs *globalsCtor OF((void));
/* pseudo constant sigs; they are initialized at runtime so unzip executable
* won't look like a zipfile
*/
extern char local_hdr_sig[4];
extern char central_hdr_sig[4];
extern char end_central_sig[4];
extern char end_central32_sig[4];
extern char end_central64_sig[4];
extern char end_centloc64_sig[4];
/* extern char extd_local_sig[4]; NOT USED YET */
#ifdef REENTRANT
# define G (*(Uz_Globs *)pG)
# define __G pG
# define __G__ pG,
# define __GPRO Uz_Globs *pG
# define __GPRO__ Uz_Globs *pG,
# define __GDEF Uz_Globs *pG;
# ifdef USETHREADID
extern int lastScan;
void deregisterGlobalPointer OF((__GPRO));
Uz_Globs *getGlobalPointer OF((void));
# define GETGLOBALS() Uz_Globs *pG = getGlobalPointer()
# define DESTROYGLOBALS() do {free_G_buffers(pG); \
deregisterGlobalPointer(pG);} while (0)
# else
extern Uz_Globs *GG;
# define GETGLOBALS() Uz_Globs *pG = GG
# define DESTROYGLOBALS() do {free_G_buffers(pG); free(pG);} while (0)
# endif /* ?USETHREADID */
# define CONSTRUCTGLOBALS() Uz_Globs *pG = globalsCtor()
#else /* !REENTRANT */
extern Uz_Globs G;
# define __G
# define __G__
# define __GPRO void
# define __GPRO__
# define __GDEF
# define GETGLOBALS()
# define CONSTRUCTGLOBALS() globalsCtor()
# define DESTROYGLOBALS()
#endif /* ?REENTRANT */
#define uO G.UzO
#endif /* __globals_h */
View Git Blame Copy Permalink