[wxWidgets.git] / utils / Install / sfxzip / api.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 */
Commit	Line	Data
f6bcfd97 BP	1	/*---------------------------------------------------------------------------
	2
	3	api.c
	4
	5	This module supplies an UnZip engine for use directly from C/C++
	6	programs. The functions are:
	7
	8	UzpVer *UzpVersion(void);
	9	void UzpVersion2(UzpVer2 *version)
	10	int UzpMain(int argc, char *argv[]);
	11	int UzpAltMain(int argc, char argv[], UzpInit init);
	12	int UzpValidate(char *archive, int AllCodes);
	13	void UzpFreeMemBuffer(UzpBuffer *retstr);
	14	int UzpUnzipToMemory(char zip, char file, UzpOpts *optflgs,
	15	UzpCB UsrFuncts, UzpBuffer retstr);
	16
	17	non-WINDLL only (a special WINDLL variant is defined in windll/windll.c):
	18	int UzpGrep(char archive, char file, char *pattern, int cmd, int SkipBin,
	19	UzpCB *UsrFuncts);
	20
	21	OS/2 only (for now):
	22	int UzpFileTree(char name, cbList(callBack), char cpInclude[],
	23	char *cpExclude[]);
	24
	25	You must define `DLL' in order to include the API extensions.
	26
	27	---------------------------------------------------------------------------*/
	28
	29
	30	#ifdef OS2
	31	# define INCL_DOSMEMMGR
	32	# include <os2.h>
	33	#endif
	34	#include <setjmp.h>
	35
	36	#define UNZIP_INTERNAL
	37	#include "unzip.h"
	38	#include "version.h"
	39	#ifdef WINDLL
	40	# include "windll/windll.h"
	41	#endif
	42
	43	#ifdef DLL /* This source file supplies DLL-only interface code. */
	44
	45	jmp_buf dll_error_return;
	46
	47	/*---------------------------------------------------------------------------
	48	Documented API entry points
	49	---------------------------------------------------------------------------*/
	50
	51
	52	UzpVer * UZ_EXP UzpVersion() /* should be pointer to const struct */
	53	{
	54	static UzpVer version; /* doesn't change between calls */
	55
	56
	57	version.structlen = UZPVER_LEN;
	58
	59	#ifdef BETA
	60	version.flag = 1;
	61	#else
	62	version.flag = 0;
	63	#endif
	64	version.betalevel = BETALEVEL;
65	version.date = VERSION_DATE;
66
67	#ifdef ZLIB_VERSION
68	version.zlib_version = ZLIB_VERSION;
69	version.flag \|= 2;
70	#else
71	version.zlib_version = NULL;
72	#endif
73
74	/* someday each of these may have a separate patchlevel: */
75	version.unzip.major = UZ_MAJORVER;
76	version.unzip.minor = UZ_MINORVER;
77	version.unzip.patchlevel = PATCHLEVEL;
78
79	version.zipinfo.major = ZI_MAJORVER;
80	version.zipinfo.minor = ZI_MINORVER;
81	version.zipinfo.patchlevel = PATCHLEVEL;
82
83	/* these are retained for backward compatibility only: */
84	version.os2dll.major = UZ_MAJORVER;
85	version.os2dll.minor = UZ_MINORVER;
86	version.os2dll.patchlevel = PATCHLEVEL;
87
88	version.windll.major = UZ_MAJORVER;
89	version.windll.minor = UZ_MINORVER;
90	version.windll.patchlevel = PATCHLEVEL;
91
92	return &version;
93	}
94
95	void UZ_EXP UzpVersion2(UzpVer2 *version)
96	{
97
98	version->structlen = UZPVER_LEN;
99
100	#ifdef BETA
101	version->flag = 1;
102	#else
103	version->flag = 0;
104	#endif
105	strcpy(version->betalevel, BETALEVEL);
106	strcpy(version->date, VERSION_DATE);
107
108	#ifdef ZLIB_VERSION
109	strcpy(version->zlib_version, ZLIB_VERSION);
110	version->flag \|= 2;
111	#else
112	version->zlib_version[0] = '\0';
113	#endif
114
115	/* someday each of these may have a separate patchlevel: */
116	version->unzip.major = UZ_MAJORVER;
117	version->unzip.minor = UZ_MINORVER;
118	version->unzip.patchlevel = PATCHLEVEL;
119
120	version->zipinfo.major = ZI_MAJORVER;
121	version->zipinfo.minor = ZI_MINORVER;
122	version->zipinfo.patchlevel = PATCHLEVEL;
123
124	/* these are retained for backward compatibility only: */
125	version->os2dll.major = UZ_MAJORVER;
126	version->os2dll.minor = UZ_MINORVER;
127	version->os2dll.patchlevel = PATCHLEVEL;
128
129	version->windll.major = UZ_MAJORVER;
130	version->windll.minor = UZ_MINORVER;
131	version->windll.patchlevel = PATCHLEVEL;
132	}
133
134
135
136
137
138	#ifndef WINDLL
139
140	int UZ_EXP UzpAltMain(int argc, char argv[], UzpInit init)
141	{
142	int r, (*dummyfn)();
143
144
145	CONSTRUCTGLOBALS();
146
147	if (init->structlen >= (sizeof(ulg) + sizeof(dummyfn)) && init->msgfn)
148	G.message = init->msgfn;
149
150	if (init->structlen >= (sizeof(ulg) + 2*sizeof(dummyfn)) && init->inputfn)
151	G.input = init->inputfn;
152
153	if (init->structlen >= (sizeof(ulg) + 3*sizeof(dummyfn)) && init->pausefn)
154	G.mpause = init->pausefn;
155
156	if (init->structlen >= (sizeof(ulg) + 4*sizeof(dummyfn)) && init->userfn)
157	(init->userfn)(); / allow void* arg? */
158
159	r = unzip(__G__ argc, argv);
160	DESTROYGLOBALS()
161	RETURN(r);
162	}
163
164	#endif /* !WINDLL */
165
166
167
168
169	#ifndef __16BIT__
170
171	void UZ_EXP UzpFreeMemBuffer(UzpBuffer *retstr)
172	{
173	if (retstr->strptr != NULL) {
174	free(retstr->strptr);
175	retstr->strptr = NULL;
176	}
177	}
178
179
180
181
182	#ifndef WINDLL
183
184	static int UzpDLL_Init OF((zvoid pG, UzpCB UsrFuncts));
185
186	static int UzpDLL_Init(pG, UsrFuncts)
187	zvoid *pG;
188	UzpCB *UsrFuncts;
189	{
190	int (*dummyfn)();
191
192	if (UsrFuncts->structlen >= (sizeof(ulg) + sizeof(dummyfn)) &&
193	UsrFuncts->msgfn)
194	((Uz_Globs *)pG)->message = UsrFuncts->msgfn;
195	else
196	return FALSE;
197
198	if (UsrFuncts->structlen >= (sizeof(ulg) + 2*sizeof(dummyfn)) &&
199	UsrFuncts->inputfn)
200	((Uz_Globs *)pG)->input = UsrFuncts->inputfn;
201
202	if (UsrFuncts->structlen >= (sizeof(ulg) + 3*sizeof(dummyfn)) &&
203	UsrFuncts->pausefn)
204	((Uz_Globs *)pG)->mpause = UsrFuncts->pausefn;
205
206	if (UsrFuncts->structlen >= (sizeof(ulg) + 4*sizeof(dummyfn)) &&
207	UsrFuncts->passwdfn)
208	((Uz_Globs *)pG)->decr_passwd = UsrFuncts->passwdfn;
209
210	if (UsrFuncts->structlen >= (sizeof(ulg) + 5*sizeof(dummyfn)) &&
211	UsrFuncts->statrepfn)
212	((Uz_Globs *)pG)->statreportcb = UsrFuncts->statrepfn;
213
214	return TRUE;
215	}
216
217
218	int UZ_EXP UzpUnzipToMemory(char zip, char file, UzpOpts *optflgs,
219	UzpCB UsrFuncts, UzpBuffer retstr)
220	{
221	int r;
222	#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
223	char intern_zip, intern_file;
224	#endif
225
226	CONSTRUCTGLOBALS();
227	#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
228	intern_zip = (char *)malloc(strlen(zip)+1);
229	if (intern_zip == NULL) {
230	DESTROYGLOBALS()
231	return PK_MEM;
232	}
233	intern_file = (char *)malloc(strlen(file)+1);
234	if (intern_file == NULL) {
235	DESTROYGLOBALS()
236	free(intern_zip);
237	return PK_MEM;
238	}
239	ISO_TO_INTERN(zip, intern_zip);
240	ISO_TO_INTERN(file, intern_file);
241	# define zip intern_zip
242	# define file intern_file
243	#endif
244	/* Copy those options that are meaningful for UzpUnzipToMemory, instead of
245	* a simple "memcpy(G.UzO, optflgs, sizeof(UzpOpts));"
246	*/
247	uO.pwdarg = optflgs->pwdarg;
248	uO.aflag = optflgs->aflag;
249	uO.C_flag = optflgs->C_flag;
250	uO.qflag = optflgs->qflag; /* currently, overridden in unzipToMemory */
251
252	if (!UzpDLL_Init((zvoid *)&G, UsrFuncts)) {
253	DESTROYGLOBALS();
254	return PK_BADERR;
255	}
256	G.redirect_data = 1;
257
258	r = (unzipToMemory(__G__ zip, file, retstr) <= PK_WARN);
259
260	DESTROYGLOBALS()
261	#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
262	# undef file
263	# undef zip
264	free(intern_file);
265	free(intern_zip);
266	#endif
267	if (!r && retstr->strlength) {
268	free(retstr->strptr);
269	retstr->strptr = NULL;
270	}
271	return r;
272	}
273	#endif /* !WINDLL */
274	#endif /* !__16BIT__ */
275
276
277
278
279
280	#ifdef OS2DLL
281
282	int UZ_EXP UzpFileTree(char name, cbList(callBack), char cpInclude[],
283	char *cpExclude[])
284	{
285	int r;
286
287	CONSTRUCTGLOBALS();
288	uO.qflag = 2;
289	uO.vflag = 1;
290	uO.C_flag = 1;
291	G.wildzipfn = name;
292	G.process_all_files = TRUE;
293	if (cpInclude) {
294	char **ptr = cpInclude;
295
296	while (*ptr != NULL) ptr++;
297	G.filespecs = ptr - cpInclude;
298	G.pfnames = cpInclude, G.process_all_files = FALSE;
299	}
300	if (cpExclude) {
301	char **ptr = cpExclude;
302
303	while (*ptr != NULL) ptr++;
304	G.xfilespecs = ptr - cpExclude;
305	G.pxnames = cpExclude, G.process_all_files = FALSE;
306	}
307
308	G.processExternally = callBack;
309	r = process_zipfiles(__G)==0;
310	DESTROYGLOBALS()
311	return r;
312	}
313
314	#endif /* OS2DLL */
315
316
317
318
319	/*---------------------------------------------------------------------------
320	Helper functions
321	---------------------------------------------------------------------------*/
322
323
324	void setFileNotFound(__G)
325	__GDEF
326	{
327	G.filenotfound++;
328	}
329
330
331
332	int unzipToMemory(__GPRO__ char zip, char file, UzpBuffer *retstr)
333	{
334	int r;
335	char *incname[2];
336
337	G.process_all_files = FALSE;
338	G.extract_flag = TRUE;
339	uO.qflag = 2;
340	G.wildzipfn = zip;
341
342	G.pfnames = incname;
343	incname[0] = file;
344	incname[1] = NULL;
345	G.filespecs = 1;
346
347	r = process_zipfiles(__G);
348	if (retstr) {
349	retstr->strptr = (char *)G.redirect_buffer;
350	retstr->strlength = G.redirect_size;
351	}
352	return r; /* returns `PK_???' error values */
353	}
354
355
356
357	int redirect_outfile(__G)
358	__GDEF
359	{
360	if (G.redirect_size != 0 \|\| G.redirect_buffer != NULL)
361	return FALSE;
362
363	#ifndef NO_SLIDE_REDIR
364	G.redirect_slide = !G.pInfo->textmode;
365	#endif
366	G.redirect_size = (G.pInfo->textmode ?
367	G.lrec.ucsize * lenEOL : G.lrec.ucsize);
368	#ifdef OS2
369	DosAllocMem((void **)&G.redirect_buffer, G.redirect_size+1,
370	PAG_READ\|PAG_WRITE\|PAG_COMMIT);
371	G.redirect_pointer = G.redirect_buffer;
372	#else
373	#ifdef __16BIT__
374	if ((ulg)((extent)G.redirect_size) != G.redirect_size)
375	return FALSE;
376	#endif
377	G.redirect_pointer = G.redirect_buffer = malloc(G.redirect_size+1);
378	#endif
379	if (!G.redirect_buffer)
380	return FALSE;
381	G.redirect_pointer[G.redirect_size] = '\0';
382	return TRUE;
383	}
384
385
386
387	int writeToMemory(__GPRO__ uch *rawbuf, ulg size)
388	{
389	if (rawbuf != G.redirect_pointer)
390	memcpy(G.redirect_pointer,rawbuf,size);
391	G.redirect_pointer += size;
392	return 0;
393	}
394
395
396
397
398	int close_redirect(__G)
399	__GDEF
400	{
401	if (G.pInfo->textmode) {
402	*G.redirect_pointer = '\0';
403	G.redirect_size = G.redirect_pointer - G.redirect_buffer;
404	if ((G.redirect_buffer =
405	realloc(G.redirect_buffer, G.redirect_size + 1)) == NULL) {
406	G.redirect_size = 0;
407	return EOF;
408	}
409	}
410	return 0;
411	}
412
413
414
415
416	#ifndef __16BIT__
417	#ifndef WINDLL
418
419	/* Purpose: Determine if file in archive contains the string szSearch
420
421	Parameters: archive = archive name
422	file = file contained in the archive. This cannot be
423	a wild card to be meaningful
424	pattern = string to search for
425	cmd = 0 - case-insensitive search
426	1 - case-sensitve search
427	2 - case-insensitive, whole words only
428	3 - case-sensitive, whole words only
429	SkipBin = if true, skip any files that have control
430	characters other than CR, LF, or tab in the first
431	100 characters.
432
433	Returns: TRUE if a match is found
434	FALSE if no match is found
435	-1 on error
436
437	Comments: This does not pretend to be as useful as the standard
438	Unix grep, which returns the strings associated with a
439	particular pattern, nor does it search past the first
440	matching occurrence of the pattern.
441	*/
442
443	int UZ_EXP UzpGrep(char archive, char file, char *pattern, int cmd,
444	int SkipBin, UzpCB *UsrFuncts)
445	{
446	int retcode = FALSE, compare;
447	ulg i, j, patternLen, buflen;
448	char * sz, *p;
449	UzpOpts flgopts;
450	UzpBuffer retstr;
451
452	memzero(&flgopts, sizeof(UzpOpts)); /* no special options */
453
454	if (!UzpUnzipToMemory(archive, file, &flgopts, UsrFuncts, &retstr)) {
455	return -1; /* not enough memory, file not found, or other error */
456	}
457
458	if (SkipBin) {
459	if (retstr.strlength < 100)
460	buflen = retstr.strlength;
461	else
462	buflen = 100;
463	for (i = 0; i < buflen; i++) {
464	if (iscntrl(retstr.strptr[i])) {
465	if ((retstr.strptr[i] != 0x0A) &&
466	(retstr.strptr[i] != 0x0D) &&
467	(retstr.strptr[i] != 0x09))
468	{
469	/* OK, we now think we have a binary file of some sort */
470	free(retstr.strptr);
471	return FALSE;
472	}
473	}
474	}
475	}
476
477	patternLen = strlen(pattern);
478
479	if (retstr.strlength < patternLen) {
480	free(retstr.strptr);
481	return FALSE;
482	}
483
484	sz = malloc(patternLen + 3); /* add two in case doing whole words only */
485	if (cmd > 1) {
486	strcpy(sz, " ");
487	strcat(sz, pattern);
488	strcat(sz, " ");
489	} else
490	strcpy(sz, pattern);
491
492	if ((cmd == 0) \|\| (cmd == 2)) {
493	for (i = 0; i < strlen(sz); i++)
494	sz[i] = toupper(sz[i]);
495	for (i = 0; i < retstr.strlength; i++)
496	retstr.strptr[i] = toupper(retstr.strptr[i]);
497	}
498
499	for (i = 0; i < (retstr.strlength - patternLen); i++) {
500	p = &retstr.strptr[i];
501	compare = TRUE;
502	for (j = 0; j < patternLen; j++) {
503	/* We cannot do strncmp here, as we may be dealing with a
504	* "binary" file, such as a word processing file, or perhaps
505	* even a true executable of some sort. */
506	if (p[j] != sz[j]) {
507	compare = FALSE;
508	break;
509	}
510	}
511	if (compare == TRUE) {
512	retcode = TRUE;
513	break;
514	}
515	}
516
517	free(sz);
518	free(retstr.strptr);
519
520	return retcode;
521	}
522	#endif /* !WINDLL */
523	#endif /* !__16BIT__ */
524
525
526
527
528	int UZ_EXP UzpValidate(char *archive, int AllCodes)
529	{
530	int retcode;
531	CONSTRUCTGLOBALS();
532
533	uO.jflag = 1;
534	uO.tflag = 1;
535	uO.overwrite_none = 0;
536	G.extract_flag = (!uO.zipinfo_mode &&
537	!uO.cflag && !uO.tflag && !uO.vflag && !uO.zflag
538	#ifdef TIMESTAMP
539	&& !uO.T_flag
540	#endif
541	);
542
543	uO.qflag = 2; /* turn off all messages */
544	G.fValidate = TRUE;
545	G.pfnames = (char *)&fnames[0]; / assign default filename vector */
546	#ifdef WINDLL
547	Wiz_NoPrinting(TRUE);
548	#endif
549
550	if (archive == NULL) { /* something is screwed up: no filename */
551	DESTROYGLOBALS();
552	return PK_NOZIP;
553	}
554
555	G.wildzipfn = (char *)malloc(FILNAMSIZ + 1);
556	strcpy(G.wildzipfn, archive);
557	#if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
558	_ISO_INTERN(G.wildzipfn);
559	#endif
560
561	G.process_all_files = TRUE; /* for speed */
562
563	retcode = setjmp(dll_error_return);
564
565	if (retcode) {
566	#ifdef WINDLL
567	Wiz_NoPrinting(FALSE);
568	#endif
569	free(G.wildzipfn);
570	DESTROYGLOBALS();
571	return PK_BADERR;
572	}
573
574	retcode = process_zipfiles(__G);
575
576	free(G.wildzipfn);
577	#ifdef WINDLL
578	Wiz_NoPrinting(FALSE);
579	#endif
580	DESTROYGLOBALS();
581
582	/* PK_WARN == 1 and PK_FIND == 11. When we are just looking at an
583	archive, we should still be able to see the files inside it,
584	even if we can't decode them for some reason.
585
586	We also still want to be able to get at files even if there is
587	something odd about the zip archive, hence allow PK_WARN,
588	PK_FIND, IZ_UNSUP as well as PK_ERR
589	*/
590
591	if (AllCodes)
592	return retcode;
593
594	if ((retcode == PK_OK) \|\| (retcode == PK_WARN) \|\| (retcode == PK_ERR) \|\|
595	(retcode == IZ_UNSUP) \|\| (retcode == PK_FIND))
596	return TRUE;
597	else
598	return FALSE;
599	}
600
601	#endif /* DLL */