36508e0a17
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_2_BRANCH@7117 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
602 lines
15 KiB
C
602 lines
15 KiB
C
/*---------------------------------------------------------------------------
|
|
|
|
api.c
|
|
|
|
This module supplies an UnZip engine for use directly from C/C++
|
|
programs. The functions are:
|
|
|
|
UzpVer *UzpVersion(void);
|
|
void UzpVersion2(UzpVer2 *version)
|
|
int UzpMain(int argc, char *argv[]);
|
|
int UzpAltMain(int argc, char *argv[], UzpInit *init);
|
|
int UzpValidate(char *archive, int AllCodes);
|
|
void UzpFreeMemBuffer(UzpBuffer *retstr);
|
|
int UzpUnzipToMemory(char *zip, char *file, UzpOpts *optflgs,
|
|
UzpCB *UsrFuncts, UzpBuffer *retstr);
|
|
|
|
non-WINDLL only (a special WINDLL variant is defined in windll/windll.c):
|
|
int UzpGrep(char *archive, char *file, char *pattern, int cmd, int SkipBin,
|
|
UzpCB *UsrFuncts);
|
|
|
|
OS/2 only (for now):
|
|
int UzpFileTree(char *name, cbList(callBack), char *cpInclude[],
|
|
char *cpExclude[]);
|
|
|
|
You must define `DLL' in order to include the API extensions.
|
|
|
|
---------------------------------------------------------------------------*/
|
|
|
|
|
|
#ifdef OS2
|
|
# define INCL_DOSMEMMGR
|
|
# include <os2.h>
|
|
#endif
|
|
#include <setjmp.h>
|
|
|
|
#define UNZIP_INTERNAL
|
|
#include "unzip.h"
|
|
#include "version.h"
|
|
#ifdef WINDLL
|
|
# include "windll/windll.h"
|
|
#endif
|
|
|
|
#ifdef DLL /* This source file supplies DLL-only interface code. */
|
|
|
|
jmp_buf dll_error_return;
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Documented API entry points
|
|
---------------------------------------------------------------------------*/
|
|
|
|
|
|
UzpVer * UZ_EXP UzpVersion() /* should be pointer to const struct */
|
|
{
|
|
static UzpVer version; /* doesn't change between calls */
|
|
|
|
|
|
version.structlen = UZPVER_LEN;
|
|
|
|
#ifdef BETA
|
|
version.flag = 1;
|
|
#else
|
|
version.flag = 0;
|
|
#endif
|
|
version.betalevel = BETALEVEL;
|
|
version.date = VERSION_DATE;
|
|
|
|
#ifdef ZLIB_VERSION
|
|
version.zlib_version = ZLIB_VERSION;
|
|
version.flag |= 2;
|
|
#else
|
|
version.zlib_version = NULL;
|
|
#endif
|
|
|
|
/* someday each of these may have a separate patchlevel: */
|
|
version.unzip.major = UZ_MAJORVER;
|
|
version.unzip.minor = UZ_MINORVER;
|
|
version.unzip.patchlevel = PATCHLEVEL;
|
|
|
|
version.zipinfo.major = ZI_MAJORVER;
|
|
version.zipinfo.minor = ZI_MINORVER;
|
|
version.zipinfo.patchlevel = PATCHLEVEL;
|
|
|
|
/* these are retained for backward compatibility only: */
|
|
version.os2dll.major = UZ_MAJORVER;
|
|
version.os2dll.minor = UZ_MINORVER;
|
|
version.os2dll.patchlevel = PATCHLEVEL;
|
|
|
|
version.windll.major = UZ_MAJORVER;
|
|
version.windll.minor = UZ_MINORVER;
|
|
version.windll.patchlevel = PATCHLEVEL;
|
|
|
|
return &version;
|
|
}
|
|
|
|
void UZ_EXP UzpVersion2(UzpVer2 *version)
|
|
{
|
|
|
|
version->structlen = UZPVER_LEN;
|
|
|
|
#ifdef BETA
|
|
version->flag = 1;
|
|
#else
|
|
version->flag = 0;
|
|
#endif
|
|
strcpy(version->betalevel, BETALEVEL);
|
|
strcpy(version->date, VERSION_DATE);
|
|
|
|
#ifdef ZLIB_VERSION
|
|
strcpy(version->zlib_version, ZLIB_VERSION);
|
|
version->flag |= 2;
|
|
#else
|
|
version->zlib_version[0] = '\0';
|
|
#endif
|
|
|
|
/* someday each of these may have a separate patchlevel: */
|
|
version->unzip.major = UZ_MAJORVER;
|
|
version->unzip.minor = UZ_MINORVER;
|
|
version->unzip.patchlevel = PATCHLEVEL;
|
|
|
|
version->zipinfo.major = ZI_MAJORVER;
|
|
version->zipinfo.minor = ZI_MINORVER;
|
|
version->zipinfo.patchlevel = PATCHLEVEL;
|
|
|
|
/* these are retained for backward compatibility only: */
|
|
version->os2dll.major = UZ_MAJORVER;
|
|
version->os2dll.minor = UZ_MINORVER;
|
|
version->os2dll.patchlevel = PATCHLEVEL;
|
|
|
|
version->windll.major = UZ_MAJORVER;
|
|
version->windll.minor = UZ_MINORVER;
|
|
version->windll.patchlevel = PATCHLEVEL;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef WINDLL
|
|
|
|
int UZ_EXP UzpAltMain(int argc, char *argv[], UzpInit *init)
|
|
{
|
|
int r, (*dummyfn)();
|
|
|
|
|
|
CONSTRUCTGLOBALS();
|
|
|
|
if (init->structlen >= (sizeof(ulg) + sizeof(dummyfn)) && init->msgfn)
|
|
G.message = init->msgfn;
|
|
|
|
if (init->structlen >= (sizeof(ulg) + 2*sizeof(dummyfn)) && init->inputfn)
|
|
G.input = init->inputfn;
|
|
|
|
if (init->structlen >= (sizeof(ulg) + 3*sizeof(dummyfn)) && init->pausefn)
|
|
G.mpause = init->pausefn;
|
|
|
|
if (init->structlen >= (sizeof(ulg) + 4*sizeof(dummyfn)) && init->userfn)
|
|
(*init->userfn)(); /* allow void* arg? */
|
|
|
|
r = unzip(__G__ argc, argv);
|
|
DESTROYGLOBALS()
|
|
RETURN(r);
|
|
}
|
|
|
|
#endif /* !WINDLL */
|
|
|
|
|
|
|
|
|
|
#ifndef __16BIT__
|
|
|
|
void UZ_EXP UzpFreeMemBuffer(UzpBuffer *retstr)
|
|
{
|
|
if (retstr->strptr != NULL) {
|
|
free(retstr->strptr);
|
|
retstr->strptr = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifndef WINDLL
|
|
|
|
static int UzpDLL_Init OF((zvoid *pG, UzpCB *UsrFuncts));
|
|
|
|
static int UzpDLL_Init(pG, UsrFuncts)
|
|
zvoid *pG;
|
|
UzpCB *UsrFuncts;
|
|
{
|
|
int (*dummyfn)();
|
|
|
|
if (UsrFuncts->structlen >= (sizeof(ulg) + sizeof(dummyfn)) &&
|
|
UsrFuncts->msgfn)
|
|
((Uz_Globs *)pG)->message = UsrFuncts->msgfn;
|
|
else
|
|
return FALSE;
|
|
|
|
if (UsrFuncts->structlen >= (sizeof(ulg) + 2*sizeof(dummyfn)) &&
|
|
UsrFuncts->inputfn)
|
|
((Uz_Globs *)pG)->input = UsrFuncts->inputfn;
|
|
|
|
if (UsrFuncts->structlen >= (sizeof(ulg) + 3*sizeof(dummyfn)) &&
|
|
UsrFuncts->pausefn)
|
|
((Uz_Globs *)pG)->mpause = UsrFuncts->pausefn;
|
|
|
|
if (UsrFuncts->structlen >= (sizeof(ulg) + 4*sizeof(dummyfn)) &&
|
|
UsrFuncts->passwdfn)
|
|
((Uz_Globs *)pG)->decr_passwd = UsrFuncts->passwdfn;
|
|
|
|
if (UsrFuncts->structlen >= (sizeof(ulg) + 5*sizeof(dummyfn)) &&
|
|
UsrFuncts->statrepfn)
|
|
((Uz_Globs *)pG)->statreportcb = UsrFuncts->statrepfn;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int UZ_EXP UzpUnzipToMemory(char *zip, char *file, UzpOpts *optflgs,
|
|
UzpCB *UsrFuncts, UzpBuffer *retstr)
|
|
{
|
|
int r;
|
|
#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
|
|
char *intern_zip, *intern_file;
|
|
#endif
|
|
|
|
CONSTRUCTGLOBALS();
|
|
#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
|
|
intern_zip = (char *)malloc(strlen(zip)+1);
|
|
if (intern_zip == NULL) {
|
|
DESTROYGLOBALS()
|
|
return PK_MEM;
|
|
}
|
|
intern_file = (char *)malloc(strlen(file)+1);
|
|
if (intern_file == NULL) {
|
|
DESTROYGLOBALS()
|
|
free(intern_zip);
|
|
return PK_MEM;
|
|
}
|
|
ISO_TO_INTERN(zip, intern_zip);
|
|
ISO_TO_INTERN(file, intern_file);
|
|
# define zip intern_zip
|
|
# define file intern_file
|
|
#endif
|
|
/* Copy those options that are meaningful for UzpUnzipToMemory, instead of
|
|
* a simple "memcpy(G.UzO, optflgs, sizeof(UzpOpts));"
|
|
*/
|
|
uO.pwdarg = optflgs->pwdarg;
|
|
uO.aflag = optflgs->aflag;
|
|
uO.C_flag = optflgs->C_flag;
|
|
uO.qflag = optflgs->qflag; /* currently, overridden in unzipToMemory */
|
|
|
|
if (!UzpDLL_Init((zvoid *)&G, UsrFuncts)) {
|
|
DESTROYGLOBALS();
|
|
return PK_BADERR;
|
|
}
|
|
G.redirect_data = 1;
|
|
|
|
r = (unzipToMemory(__G__ zip, file, retstr) <= PK_WARN);
|
|
|
|
DESTROYGLOBALS()
|
|
#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
|
|
# undef file
|
|
# undef zip
|
|
free(intern_file);
|
|
free(intern_zip);
|
|
#endif
|
|
if (!r && retstr->strlength) {
|
|
free(retstr->strptr);
|
|
retstr->strptr = NULL;
|
|
}
|
|
return r;
|
|
}
|
|
#endif /* !WINDLL */
|
|
#endif /* !__16BIT__ */
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef OS2DLL
|
|
|
|
int UZ_EXP UzpFileTree(char *name, cbList(callBack), char *cpInclude[],
|
|
char *cpExclude[])
|
|
{
|
|
int r;
|
|
|
|
CONSTRUCTGLOBALS();
|
|
uO.qflag = 2;
|
|
uO.vflag = 1;
|
|
uO.C_flag = 1;
|
|
G.wildzipfn = name;
|
|
G.process_all_files = TRUE;
|
|
if (cpInclude) {
|
|
char **ptr = cpInclude;
|
|
|
|
while (*ptr != NULL) ptr++;
|
|
G.filespecs = ptr - cpInclude;
|
|
G.pfnames = cpInclude, G.process_all_files = FALSE;
|
|
}
|
|
if (cpExclude) {
|
|
char **ptr = cpExclude;
|
|
|
|
while (*ptr != NULL) ptr++;
|
|
G.xfilespecs = ptr - cpExclude;
|
|
G.pxnames = cpExclude, G.process_all_files = FALSE;
|
|
}
|
|
|
|
G.processExternally = callBack;
|
|
r = process_zipfiles(__G)==0;
|
|
DESTROYGLOBALS()
|
|
return r;
|
|
}
|
|
|
|
#endif /* OS2DLL */
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Helper functions
|
|
---------------------------------------------------------------------------*/
|
|
|
|
|
|
void setFileNotFound(__G)
|
|
__GDEF
|
|
{
|
|
G.filenotfound++;
|
|
}
|
|
|
|
|
|
|
|
int unzipToMemory(__GPRO__ char *zip, char *file, UzpBuffer *retstr)
|
|
{
|
|
int r;
|
|
char *incname[2];
|
|
|
|
G.process_all_files = FALSE;
|
|
G.extract_flag = TRUE;
|
|
uO.qflag = 2;
|
|
G.wildzipfn = zip;
|
|
|
|
G.pfnames = incname;
|
|
incname[0] = file;
|
|
incname[1] = NULL;
|
|
G.filespecs = 1;
|
|
|
|
r = process_zipfiles(__G);
|
|
if (retstr) {
|
|
retstr->strptr = (char *)G.redirect_buffer;
|
|
retstr->strlength = G.redirect_size;
|
|
}
|
|
return r; /* returns `PK_???' error values */
|
|
}
|
|
|
|
|
|
|
|
int redirect_outfile(__G)
|
|
__GDEF
|
|
{
|
|
if (G.redirect_size != 0 || G.redirect_buffer != NULL)
|
|
return FALSE;
|
|
|
|
#ifndef NO_SLIDE_REDIR
|
|
G.redirect_slide = !G.pInfo->textmode;
|
|
#endif
|
|
G.redirect_size = (G.pInfo->textmode ?
|
|
G.lrec.ucsize * lenEOL : G.lrec.ucsize);
|
|
#ifdef OS2
|
|
DosAllocMem((void **)&G.redirect_buffer, G.redirect_size+1,
|
|
PAG_READ|PAG_WRITE|PAG_COMMIT);
|
|
G.redirect_pointer = G.redirect_buffer;
|
|
#else
|
|
#ifdef __16BIT__
|
|
if ((ulg)((extent)G.redirect_size) != G.redirect_size)
|
|
return FALSE;
|
|
#endif
|
|
G.redirect_pointer = G.redirect_buffer = malloc(G.redirect_size+1);
|
|
#endif
|
|
if (!G.redirect_buffer)
|
|
return FALSE;
|
|
G.redirect_pointer[G.redirect_size] = '\0';
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
int writeToMemory(__GPRO__ uch *rawbuf, ulg size)
|
|
{
|
|
if (rawbuf != G.redirect_pointer)
|
|
memcpy(G.redirect_pointer,rawbuf,size);
|
|
G.redirect_pointer += size;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
int close_redirect(__G)
|
|
__GDEF
|
|
{
|
|
if (G.pInfo->textmode) {
|
|
*G.redirect_pointer = '\0';
|
|
G.redirect_size = G.redirect_pointer - G.redirect_buffer;
|
|
if ((G.redirect_buffer =
|
|
realloc(G.redirect_buffer, G.redirect_size + 1)) == NULL) {
|
|
G.redirect_size = 0;
|
|
return EOF;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifndef __16BIT__
|
|
#ifndef WINDLL
|
|
|
|
/* Purpose: Determine if file in archive contains the string szSearch
|
|
|
|
Parameters: archive = archive name
|
|
file = file contained in the archive. This cannot be
|
|
a wild card to be meaningful
|
|
pattern = string to search for
|
|
cmd = 0 - case-insensitive search
|
|
1 - case-sensitve search
|
|
2 - case-insensitive, whole words only
|
|
3 - case-sensitive, whole words only
|
|
SkipBin = if true, skip any files that have control
|
|
characters other than CR, LF, or tab in the first
|
|
100 characters.
|
|
|
|
Returns: TRUE if a match is found
|
|
FALSE if no match is found
|
|
-1 on error
|
|
|
|
Comments: This does not pretend to be as useful as the standard
|
|
Unix grep, which returns the strings associated with a
|
|
particular pattern, nor does it search past the first
|
|
matching occurrence of the pattern.
|
|
*/
|
|
|
|
int UZ_EXP UzpGrep(char *archive, char *file, char *pattern, int cmd,
|
|
int SkipBin, UzpCB *UsrFuncts)
|
|
{
|
|
int retcode = FALSE, compare;
|
|
ulg i, j, patternLen, buflen;
|
|
char * sz, *p;
|
|
UzpOpts flgopts;
|
|
UzpBuffer retstr;
|
|
|
|
memzero(&flgopts, sizeof(UzpOpts)); /* no special options */
|
|
|
|
if (!UzpUnzipToMemory(archive, file, &flgopts, UsrFuncts, &retstr)) {
|
|
return -1; /* not enough memory, file not found, or other error */
|
|
}
|
|
|
|
if (SkipBin) {
|
|
if (retstr.strlength < 100)
|
|
buflen = retstr.strlength;
|
|
else
|
|
buflen = 100;
|
|
for (i = 0; i < buflen; i++) {
|
|
if (iscntrl(retstr.strptr[i])) {
|
|
if ((retstr.strptr[i] != 0x0A) &&
|
|
(retstr.strptr[i] != 0x0D) &&
|
|
(retstr.strptr[i] != 0x09))
|
|
{
|
|
/* OK, we now think we have a binary file of some sort */
|
|
free(retstr.strptr);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
patternLen = strlen(pattern);
|
|
|
|
if (retstr.strlength < patternLen) {
|
|
free(retstr.strptr);
|
|
return FALSE;
|
|
}
|
|
|
|
sz = malloc(patternLen + 3); /* add two in case doing whole words only */
|
|
if (cmd > 1) {
|
|
strcpy(sz, " ");
|
|
strcat(sz, pattern);
|
|
strcat(sz, " ");
|
|
} else
|
|
strcpy(sz, pattern);
|
|
|
|
if ((cmd == 0) || (cmd == 2)) {
|
|
for (i = 0; i < strlen(sz); i++)
|
|
sz[i] = toupper(sz[i]);
|
|
for (i = 0; i < retstr.strlength; i++)
|
|
retstr.strptr[i] = toupper(retstr.strptr[i]);
|
|
}
|
|
|
|
for (i = 0; i < (retstr.strlength - patternLen); i++) {
|
|
p = &retstr.strptr[i];
|
|
compare = TRUE;
|
|
for (j = 0; j < patternLen; j++) {
|
|
/* We cannot do strncmp here, as we may be dealing with a
|
|
* "binary" file, such as a word processing file, or perhaps
|
|
* even a true executable of some sort. */
|
|
if (p[j] != sz[j]) {
|
|
compare = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
if (compare == TRUE) {
|
|
retcode = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
free(sz);
|
|
free(retstr.strptr);
|
|
|
|
return retcode;
|
|
}
|
|
#endif /* !WINDLL */
|
|
#endif /* !__16BIT__ */
|
|
|
|
|
|
|
|
|
|
int UZ_EXP UzpValidate(char *archive, int AllCodes)
|
|
{
|
|
int retcode;
|
|
CONSTRUCTGLOBALS();
|
|
|
|
uO.jflag = 1;
|
|
uO.tflag = 1;
|
|
uO.overwrite_none = 0;
|
|
G.extract_flag = (!uO.zipinfo_mode &&
|
|
!uO.cflag && !uO.tflag && !uO.vflag && !uO.zflag
|
|
#ifdef TIMESTAMP
|
|
&& !uO.T_flag
|
|
#endif
|
|
);
|
|
|
|
uO.qflag = 2; /* turn off all messages */
|
|
G.fValidate = TRUE;
|
|
G.pfnames = (char **)&fnames[0]; /* assign default filename vector */
|
|
#ifdef WINDLL
|
|
Wiz_NoPrinting(TRUE);
|
|
#endif
|
|
|
|
if (archive == NULL) { /* something is screwed up: no filename */
|
|
DESTROYGLOBALS();
|
|
return PK_NOZIP;
|
|
}
|
|
|
|
G.wildzipfn = (char *)malloc(FILNAMSIZ + 1);
|
|
strcpy(G.wildzipfn, archive);
|
|
#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
|
|
_ISO_INTERN(G.wildzipfn);
|
|
#endif
|
|
|
|
G.process_all_files = TRUE; /* for speed */
|
|
|
|
retcode = setjmp(dll_error_return);
|
|
|
|
if (retcode) {
|
|
#ifdef WINDLL
|
|
Wiz_NoPrinting(FALSE);
|
|
#endif
|
|
free(G.wildzipfn);
|
|
DESTROYGLOBALS();
|
|
return PK_BADERR;
|
|
}
|
|
|
|
retcode = process_zipfiles(__G);
|
|
|
|
free(G.wildzipfn);
|
|
#ifdef WINDLL
|
|
Wiz_NoPrinting(FALSE);
|
|
#endif
|
|
DESTROYGLOBALS();
|
|
|
|
/* PK_WARN == 1 and PK_FIND == 11. When we are just looking at an
|
|
archive, we should still be able to see the files inside it,
|
|
even if we can't decode them for some reason.
|
|
|
|
We also still want to be able to get at files even if there is
|
|
something odd about the zip archive, hence allow PK_WARN,
|
|
PK_FIND, IZ_UNSUP as well as PK_ERR
|
|
*/
|
|
|
|
if (AllCodes)
|
|
return retcode;
|
|
|
|
if ((retcode == PK_OK) || (retcode == PK_WARN) || (retcode == PK_ERR) ||
|
|
(retcode == IZ_UNSUP) || (retcode == PK_FIND))
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
#endif /* DLL */
|