home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 9 Archive / 09-Archive.zip / unzip540.zip / windll / windll.c < prev    next >
C/C++ Source or Header  |  1998-11-02  |  20KB  |  745 lines
  1. /*
  2.  Copyright (C) 1996 Mike White
  3.  Permission is granted to any individual or institution to use, copy, or
  4.  redistribute this software so long as all of the original files are included,
  5.  that it is not sold for profit, and that this copyright notice is retained.
  6.  
  7. */
  8. /* Windows Info-ZIP Unzip DLL module
  9.  *
  10.  * Author: Mike White
  11.  *
  12.  * Original: 1996
  13.  *
  14.  * This module has the entry points for "unzipping" a zip file.
  15.  */
  16.  
  17. /*---------------------------------------------------------------------------
  18.  
  19.   This file is the WINDLL replacement for the generic ``main program source
  20.   file'' unzip.c.
  21.  
  22.   See the general comments in the header part of unzip.c.
  23.  
  24.   Copyrights:  see accompanying file "COPYING" in UnZip source distribution.
  25.                (This software is free but NOT IN THE PUBLIC DOMAIN.  There
  26.                are some restrictions on commercial use.)
  27.  
  28.   ---------------------------------------------------------------------------*/
  29.  
  30. #include <windows.h>
  31. #ifdef __RSXNT__
  32. #  include "win32/rsxntwin.h"
  33. #endif
  34. #ifdef __BORLANDC__
  35. #include <dir.h>
  36. #endif
  37. #define UNZIP_INTERNAL
  38. #include "unzip.h"
  39. #include "crypt.h"
  40. #include "version.h"
  41. #include "windll.h"
  42. #include "structs.h"
  43. #include "consts.h"
  44.  
  45. /* Added type casts to prevent potential "type mismatch" error messages. */
  46. #ifdef REENTRANT
  47. #  undef __G
  48. #  undef __G__
  49. #  define __G                 (Uz_Globs *)pG
  50. #  define __G__               (Uz_Globs *)pG,
  51. #endif
  52.  
  53. HANDLE hwildZipFN;
  54. HANDLE hInst;               /* current instance */
  55. HANDLE hDCL;
  56. int fNoPrinting = 0;
  57. extern jmp_buf dll_error_return;
  58.  
  59. /* For displaying status messages and error messages */
  60. static int UZ_EXP DllMessagePrint(zvoid *pG, uch *buf, ulg size, int flag);
  61.  
  62. #if 0 /* currently unused */
  63. /* For displaying files extracted to the display window */
  64. int DllDisplayPrint(zvoid *pG, uch *buf, ulg size, int flag);
  65. #endif /* never */
  66.  
  67. /* Callback function for status report and/or user interception */
  68. static int UZ_EXP Wiz_StatReportCB(zvoid *pG, int fnflag, ZCONST char *zfn,
  69.                                    ZCONST char *efn, ZCONST zvoid *details);
  70.  
  71. /* Dummy sound function for those applications that don't use sound */
  72. static void WINAPI DummySound(void);
  73.  
  74. #ifndef UNZIPLIB
  75. /*  DLL Entry Point */
  76.  
  77. #ifdef __BORLANDC__
  78. #pragma argsused
  79. /* Borland seems to want DllEntryPoint instead of DllMain like MSVC */
  80. #define DllMain DllEntryPoint
  81. #endif
  82. #ifdef WIN32
  83. BOOL WINAPI DllMain( HINSTANCE hInstance,
  84.                      DWORD dwReason,
  85.                      LPVOID plvReserved)
  86. #else
  87. int FAR PASCAL LibMain( HINSTANCE hInstance,
  88.                         WORD wDataSegment,
  89.                         WORD wHeapSize,
  90.                         LPSTR lpszCmdLine )
  91. #endif
  92. {
  93. #ifndef WIN32
  94. /* The startup code for the DLL initializes the local heap(if there is one)
  95.  * with a call to LocalInit which locks the data segment.
  96.  */
  97.  
  98. if ( wHeapSize != 0 )
  99.    {
  100.    UnlockData( 0 );
  101.    }
  102. hInst = hInstance;
  103. return 1;   /* Indicate that the DLL was initialized successfully. */
  104. #else
  105. BOOL rc = TRUE;
  106. switch( dwReason )
  107.    {
  108.    case DLL_PROCESS_ATTACH:
  109.       // DLL is loaded. Do your initialization here.
  110.       // If cannot init, set rc to FALSE.
  111.       hInst = hInstance;
  112.       break;
  113.  
  114.    case DLL_PROCESS_DETACH:
  115.       // DLL is unloaded. Do your cleanup here.
  116.       break;
  117.    default:
  118.       break;
  119.    }
  120. return rc;
  121. #endif
  122. }
  123.  
  124. #ifdef __BORLANDC__
  125. #pragma argsused
  126. #endif
  127. int FAR PASCAL WEP ( int bSystemExit )
  128. {
  129. return 1;
  130. }
  131. #endif /* !UNZIPLIB */
  132.  
  133. /* DLL calls */
  134.  
  135. /*
  136.     ExtractOnlyNewer  = true if you are to extract only newer
  137.     SpaceToUnderscore = true if convert space to underscore
  138.     PromptToOverwrite = true if prompt to overwrite is wanted
  139.     fQuiet    = quiet flag. 1 = few messages, 2 = no messages, 0 = all messages
  140.     ncflag    = write to stdout if true
  141.     ntflag    = test zip file
  142.     nvflag    = verbose listing
  143.     nUflag    = "update" (extract only newer/new files)
  144.     nzflag    = display zip file comment
  145.     ndflag    = all args are files/dir to be extracted
  146.     noflag    = overwrite all files
  147.     naflag    = do end-of-line translation
  148.     nZIflag   = get Zip Info if TRUE
  149.     C_flag    = be case insensitive if TRUE
  150.     fPrivilege = restore ACL's if 1, use privileges if 2
  151.     lpszZipFN = zip file name
  152.     lpszExtractDir = directory to extract to; NULL means: current directory
  153. */
  154.  
  155. BOOL WINAPI Wiz_SetOpts(pG, C)
  156. zvoid *pG;
  157. LPDCL C;
  158. {
  159.     uO.qflag = C->fQuiet;  /* Quiet flag */
  160.     G.pfnames = (char **)&fnames[0];    /* assign default file name vector */
  161.     G.pxnames = (char **)&fnames[1];
  162.  
  163.     uO.jflag = !C->ndflag;
  164.     uO.cflag = C->ncflag;
  165.     uO.overwrite_all = C->noflag;
  166.     uO.tflag = C->ntflag ;
  167.     uO.vflag = C->nvflag;
  168.     uO.zflag = C->nzflag;
  169.     uO.uflag = C->nUflag;
  170.     uO.aflag = C->naflag;
  171.     uO.C_flag = C->C_flag;
  172.     uO.uflag = C->ExtractOnlyNewer;
  173.     G.prompt_always = C->PromptToOverwrite;
  174. #ifdef WIN32
  175.     uO.X_flag = C->fPrivilege;
  176. #endif
  177.     uO.overwrite_none = !uO.overwrite_all;
  178.     uO.sflag = C->SpaceToUnderscore; /* Translate spaces to underscores? */
  179.     if (C->nZIflag)
  180.       {
  181.       uO.zipinfo_mode = TRUE;
  182.       uO.hflag = TRUE;
  183.       uO.lflag = 10;
  184.       uO.qflag = 2;
  185.       }
  186.     else
  187.       {
  188.       uO.zipinfo_mode = FALSE;
  189.       }
  190.  
  191.     G.extract_flag = (!uO.zipinfo_mode &&
  192.                       !uO.cflag && !uO.tflag && !uO.vflag && !uO.zflag
  193. #ifdef TIMESTAMP
  194.                       && !uO.T_flag
  195. #endif
  196.                      );
  197.  
  198.     if (C->lpszExtractDir != NULL && G.extract_flag)
  199.        {
  200. #ifndef CRTL_CP_IS_ISO
  201.        char *pExDirRoot = (char *)malloc(strlen(C->lpszExtractDir)+1);
  202.  
  203.        if (pExDirRoot == NULL)
  204.            return FALSE;
  205.        ISO_TO_INTERN(C->lpszExtractDir, pExDirRoot);
  206. #else
  207. #  define pExDirRoot C->lpszExtractDir
  208. #endif
  209.        uO.exdir = pExDirRoot;
  210.        }
  211.     else
  212.        {
  213.        uO.exdir = (char *)NULL;
  214.        }
  215.  
  216. /* G.wildzipfn needs to be initialized so that do_wild does not wind
  217.    up clearing out the zip file name when it returns in process.c
  218. */
  219.     hwildZipFN = GlobalAlloc(GPTR, FILNAMSIZ);
  220.     if (hwildZipFN == (HGLOBAL) NULL)
  221.        return FALSE;
  222.  
  223.     G.wildzipfn = GlobalLock(hwildZipFN);
  224.     lstrcpy(G.wildzipfn, C->lpszZipFN);
  225.     _ISO_INTERN(G.wildzipfn);
  226.  
  227.     return TRUE;    /* set up was OK */
  228. }
  229.  
  230. void FreeDllMem(__GPRO)
  231. {
  232.     if (G.wildzipfn) {
  233.         GlobalUnlock(hwildZipFN);
  234.         G.wildzipfn = NULL;
  235.     }
  236.     if (hwildZipFN)
  237.         hwildZipFN = GlobalFree(hwildZipFN);
  238.  
  239.     uO.zipinfo_mode = FALSE;
  240. }
  241.  
  242. int WINAPI Wiz_SingleEntryUnzip(int ifnc, char **ifnv, int xfnc, char **xfnv,
  243.    LPDCL C, LPUSERFUNCTIONS lpUserFunc)
  244. {
  245. int retcode;
  246. CONSTRUCTGLOBALS();
  247.  
  248. if (!Wiz_Init((zvoid *)&G, lpUserFunc))
  249.    {
  250.    DESTROYGLOBALS();
  251.    return PK_BADERR;
  252.    }
  253.  
  254. if (C->lpszZipFN == NULL) /* Something has screwed up, we don't have a filename */
  255.    {
  256.    DESTROYGLOBALS();
  257.    return PK_NOZIP;
  258.    }
  259.  
  260. Wiz_SetOpts((zvoid *)&G, C);
  261.  
  262. #ifdef SFX
  263. G.zipfn = C->lpszZipFN;
  264. G.argv0 = C->lpszZipFN;
  265. #endif
  266.  
  267. /* Here is the actual call to "unzip" the files (or whatever else you
  268.  * are doing.)
  269.  */
  270. retcode = Wiz_Unzip((zvoid *)&G, ifnc, ifnv, xfnc, xfnv);
  271.  
  272. DESTROYGLOBALS();
  273. return retcode;
  274. }
  275.  
  276.  
  277. BOOL WINAPI Wiz_Init(pG, lpUserFunc)
  278. zvoid *pG;
  279. LPUSERFUNCTIONS lpUserFunc;
  280. {
  281. G.message = DllMessagePrint;
  282. G.statreportcb = Wiz_StatReportCB;
  283. if (lpUserFunc->sound == NULL)
  284.    lpUserFunc->sound = DummySound;
  285. G.lpUserFunctions = lpUserFunc;
  286.  
  287. if (!G.lpUserFunctions->print ||
  288.     !G.lpUserFunctions->sound ||
  289.     !G.lpUserFunctions->replace)
  290.     return FALSE;
  291.  
  292. return TRUE;
  293. }
  294.  
  295. int WINAPI Wiz_Unzip(pG, ifnc, ifnv, xfnc, xfnv)
  296. zvoid *pG;
  297. int ifnc;
  298. char **ifnv;
  299. int xfnc;
  300. char **xfnv;
  301. {
  302. int retcode, f_cnt;
  303. #ifndef CRTL_CP_IS_ISO
  304. char **intern_ifv = NULL, **intern_xfv = NULL;
  305. #endif
  306.  
  307. if (ifnv == (char **)NULL && ifnc != 0)
  308.     ifnc = 0;
  309. else
  310.     for (f_cnt = 0; f_cnt < ifnc; f_cnt++)
  311.         if (ifnv[f_cnt] == (char *)NULL) {
  312.             ifnc = f_cnt;
  313.             break;
  314.         }
  315. if (xfnv == (char **)NULL && xfnc != 0)
  316.     xfnc = 0;
  317. else
  318.     for (f_cnt = 0; f_cnt < xfnc; f_cnt++)
  319.         if (xfnv[f_cnt] == (char *)NULL) {
  320.             xfnc = f_cnt;
  321.             break;
  322.         }
  323.  
  324. G.process_all_files = (ifnc == 0 && xfnc == 0);         /* for speed */
  325. G.filespecs = ifnc;
  326. G.xfilespecs = xfnc;
  327.  
  328. if (ifnc > 0) {
  329. #ifdef CRTL_CP_IS_ISO
  330.     G.pfnames = ifnv;
  331. #else /* !CRTL_CP_IS_ISO */
  332.     unsigned bufsize = 0;
  333.  
  334.     intern_ifv = (char **)malloc((ifnc+1)*sizeof(char **));
  335.     if (intern_ifv == (char **)NULL)
  336.         {
  337.         FreeDllMem(__G);
  338.         return PK_BADERR;
  339.         }
  340.  
  341.     for (f_cnt = ifnc; --f_cnt >= 0;)
  342.         bufsize += strlen(ifnv[f_cnt]) + 1;
  343.     intern_ifv[0] = (char *)malloc(bufsize);
  344.     if (intern_ifv[0] == (char *)NULL)
  345.         {
  346.         free(intern_ifv);
  347.         FreeDllMem(__G);
  348.         return PK_BADERR;
  349.         }
  350.  
  351.     for (f_cnt = 0; ; f_cnt++)
  352.         {
  353.         ISO_TO_INTERN(ifnv[f_cnt], intern_ifv[f_cnt]);
  354.         if ((f_cnt+1) >= ifnc)
  355.             break;
  356.         intern_ifv[f_cnt+1] = intern_ifv[f_cnt] +
  357.                               (strlen(intern_ifv[f_cnt]) + 1);
  358.         }
  359.     intern_ifv[ifnc] = (char *)NULL;
  360.     G.pfnames = intern_ifv;
  361. #endif /* ?CRTL_CP_IS_ISO */
  362.     }
  363.  
  364. if (xfnc > 0) {
  365. #ifdef CRTL_CP_IS_ISO
  366.     G.pxnames = xfnv;
  367. #else /* !CRTL_CP_IS_ISO */
  368.     unsigned bufsize = 0;
  369.  
  370.     intern_xfv = (char **)malloc((xfnc+1)*sizeof(char **));
  371.     if (intern_xfv == (char **)NULL)
  372.         {
  373.         if (ifnc > 0)
  374.             {
  375.             free(intern_ifv[0]);
  376.             free(intern_ifv);
  377.             }
  378.         FreeDllMem(__G);
  379.         return PK_BADERR;
  380.         }
  381.  
  382.     for (f_cnt = xfnc; --f_cnt >= 0;)
  383.         bufsize += strlen(xfnv[f_cnt]) + 1;
  384.     intern_xfv[0] = (char *)malloc(bufsize);
  385.     if (intern_xfv[0] == (char *)NULL)
  386.         {
  387.         free(intern_xfv);
  388.         if (ifnc > 0)
  389.             {
  390.             free(intern_ifv[0]);
  391.             free(intern_ifv);
  392.             }
  393.         FreeDllMem(__G);
  394.         return PK_BADERR;
  395.         }
  396.  
  397.     for (f_cnt = 0; ; f_cnt++)
  398.         {
  399.         ISO_TO_INTERN(xfnv[f_cnt], intern_xfv[f_cnt]);
  400.         if ((f_cnt+1) >= xfnc)
  401.             break;
  402.         intern_xfv[f_cnt+1] = intern_xfv[f_cnt] +
  403.                               (strlen(intern_xfv[f_cnt]) + 1);
  404.         }
  405.     intern_xfv[xfnc] = (char *)NULL;
  406.     G.pxnames = intern_xfv;
  407. #endif /* ?CRTL_CP_IS_ISO */
  408.     }
  409.  
  410. /*---------------------------------------------------------------------------
  411.     Okey dokey, we have everything we need to get started.  Let's roll.
  412.   ---------------------------------------------------------------------------*/
  413.  
  414. retcode = setjmp(dll_error_return);
  415. if (retcode)
  416.    {
  417. #ifndef CRTL_CP_IS_ISO
  418.    if (xfnc > 0)
  419.       {
  420.       free(intern_xfv[0]);
  421.       free(intern_xfv);
  422.       }
  423.    if (ifnc > 0)
  424.       {
  425.       free(intern_ifv[0]);
  426.       free(intern_ifv);
  427.       }
  428. #endif
  429.    FreeDllMem(__G);
  430.    return PK_BADERR;
  431.    }
  432.  
  433. retcode = process_zipfiles(__G);
  434. #ifndef CRTL_CP_IS_ISO
  435. if (xfnc > 0)
  436.    {
  437.    free(intern_xfv[0]);
  438.    free(intern_xfv);
  439.    }
  440. if (ifnc > 0)
  441.    {
  442.    free(intern_ifv[0]);
  443.    free(intern_ifv);
  444.    }
  445. #endif
  446. FreeDllMem(__G);
  447. return retcode;
  448. }
  449.  
  450.  
  451. int win_fprintf(zvoid *pG, FILE *file, unsigned int size, char far *buffer)
  452. {
  453. if ((file != stderr) && (file != stdout))
  454.    {
  455.    return write(fileno(file),(char far *)(buffer),size);
  456.    }
  457. if (!fNoPrinting)
  458.    return G.lpUserFunctions->print((LPSTR)buffer, size);
  459. return (int)size;
  460. }
  461.  
  462. /**********************************
  463.  * Function DllMessagePrint()     *
  464.  *                                *
  465.  * Send messages to status window *
  466.  **********************************/
  467. #ifdef __BORLANDC__
  468. #pragma argsused
  469. #endif
  470. static int UZ_EXP DllMessagePrint(pG, buf, size, flag)
  471.     zvoid *pG;      /* globals struct:  always passed */
  472.     uch *buf;       /* preformatted string to be printed */
  473.     ulg size;       /* length of string (may include nulls) */
  474.     int flag;       /* flag bits */
  475. {
  476. if (!fNoPrinting)
  477.    return G.lpUserFunctions->print((LPSTR)buf, size);
  478. else
  479.    return (int)size;
  480. }
  481.  
  482. #if 0 /* currently unused */
  483. /********************************
  484.  * Function DllDisplayPrint()   *
  485.  *                              *
  486.  * Send files to display window *
  487.  ********************************/
  488. #ifdef __BORLANDC__
  489. #pragma argsused
  490. #endif
  491. int DllDisplayPrint(pG, buf, size, flag)
  492.     zvoid *pG;      /* globals struct:  always passed */
  493.     uch *buf;       /* preformatted string to be printed */
  494.     ulg size;       /* length of string (may include nulls) */
  495.     int flag;       /* flag bits */
  496. {
  497. return (!fNoPrinting ? G.lpUserFunctions->print((LPSTR)buf, size) : (int)size);
  498. }
  499. #endif /* never */
  500.  
  501.  
  502. /**********************************
  503.  * Function UzpPassword()         *
  504.  *                                *
  505.  * Prompt for decryption password *
  506.  **********************************/
  507. #ifdef __BORLANDC__
  508. #pragma argsused
  509. #endif
  510. int UZ_EXP UzpPassword(pG, rcnt, pwbuf, size, zfn, efn)
  511.     zvoid *pG;          /* globals struct: always passed */
  512.     int *rcnt;          /* retry counter */
  513.     char *pwbuf;        /* buffer for password */
  514.     int size;           /* size of password buffer */
  515.     ZCONST char *zfn;   /* name of zip archiv */
  516.     ZCONST char *efn;   /* name of archiv entry being processed */
  517. {
  518. #if CRYPT
  519.     LPSTR m;
  520.  
  521.     if (*rcnt == 0) {
  522.         *rcnt = 2;
  523.         m = "Enter password for: ";
  524.     } else {
  525.         (*rcnt)--;
  526.         m = "Password incorrect--reenter: ";
  527.     }
  528.  
  529.     return (*G.lpUserFunctions->password)((LPSTR)pwbuf, size, m, (LPSTR)efn);
  530. #else /* !CRYPT */
  531.     return IZ_PW_ERROR; /* internal error, function should never get called */
  532. #endif /* ?CRYPT */
  533. } /* end function UzpPassword() */
  534.  
  535. /* Turn off all messages to the calling application */
  536. void WINAPI Wiz_NoPrinting(int f)
  537. {
  538. fNoPrinting = f;
  539. }
  540.  
  541. /* Dummy sound function for those applications that don't use sound */
  542. static void WINAPI DummySound(void)
  543. {
  544. }
  545.  
  546. /* Interface between WINDLL specific service callback functions and the
  547.    generic DLL's "status report & user interception" callback */
  548. #ifdef __BORLANDC__
  549. #pragma argsused
  550. #endif
  551. static int WINAPI Wiz_StatReportCB(zvoid *pG, int fnflag, ZCONST char *zfn,
  552.                     ZCONST char *efn, ZCONST zvoid *details)
  553. {
  554.     int rval = UZ_ST_CONTINUE;
  555.  
  556.     switch (fnflag) {
  557.       case UZ_ST_START_EXTRACT:
  558.         if (G.lpUserFunctions->sound != NULL)
  559.             (*G.lpUserFunctions->sound)();
  560.         break;
  561.       case UZ_ST_FINISH_MEMBER:
  562.         if ((G.lpUserFunctions->ServCallBk != NULL) &&
  563.             (*G.lpUserFunctions->ServCallBk)(efn, *((unsigned long *)details)))
  564.             rval = UZ_ST_BREAK;
  565.         break;
  566.       case UZ_ST_IN_PROGRESS:
  567.         break;
  568.       default:
  569.         break;
  570.     }
  571.     return rval;
  572. }
  573.  
  574.  
  575. #ifndef SFX
  576. #ifndef __16BIT__
  577.  
  578. int WINAPI Wiz_UnzipToMemory(LPSTR zip, LPSTR file,
  579.     LPUSERFUNCTIONS lpUserFunctions, UzpBuffer *retstr)
  580. {
  581.     int r;
  582. #ifndef CRTL_CP_IS_ISO
  583.     char *intern_zip, *intern_file;
  584. #endif
  585.  
  586.     CONSTRUCTGLOBALS();
  587. #ifndef CRTL_CP_IS_ISO
  588.     intern_zip = (char *)malloc(strlen(zip)+1);
  589.     if (intern_zip == NULL) {
  590.        DESTROYGLOBALS()
  591.        return PK_MEM;
  592.     }
  593.     intern_file = (char *)malloc(strlen(file)+1);
  594.     if (intern_file == NULL) {
  595.        DESTROYGLOBALS()
  596.        free(intern_zip);
  597.        return PK_MEM;
  598.     }
  599.     ISO_TO_INTERN(zip, intern_zip);
  600.     ISO_TO_INTERN(file, intern_file);
  601. #   define zip intern_zip
  602. #   define file intern_file
  603. #endif
  604.     if (!Wiz_Init((zvoid *)&G, lpUserFunctions)) {
  605.        DESTROYGLOBALS();
  606.        return PK_BADERR;
  607.     }
  608.     G.redirect_data = 1;
  609.  
  610.     r = (unzipToMemory(__G__ zip, file, retstr) == PK_COOL);
  611.  
  612.     DESTROYGLOBALS()
  613. #ifndef CRTL_CP_IS_ISO
  614. #  undef file
  615. #  undef zip
  616.     free(intern_file);
  617.     free(intern_zip);
  618. #endif
  619.     if (!r && retstr->strlength) {
  620.        free(retstr->strptr);
  621.        retstr->strptr = NULL;
  622.     }
  623.     return r;
  624. }
  625.  
  626.  
  627.  
  628.  
  629. /* Purpose: Determine if file in archive contains the string szSearch
  630.  
  631.    Parameters: archive  = archive name
  632.                file     = file contained in the archive. This cannot be
  633.                           a wild card to be meaningful
  634.                pattern  = string to search for
  635.                cmd      = 0 - case-insensitive search
  636.                           1 - case-sensitve search
  637.                           2 - case-insensitive, whole words only
  638.                           3 - case-sensitive, whole words only
  639.                SkipBin  = if true, skip any files that have control
  640.                           characters other than CR, LF, or tab in the first
  641.                           100 characters.
  642.  
  643.    Returns:    TRUE if a match is found
  644.                FALSE if no match is found
  645.                -1 on error
  646.  
  647.    Comments: This does not pretend to be as useful as the standard
  648.              Unix grep, which returns the strings associated with a
  649.              particular pattern, nor does it search past the first
  650.              matching occurrence of the pattern.
  651.  */
  652.  
  653. int WINAPI Wiz_Grep(LPSTR archive, LPSTR file, LPSTR pattern, int cmd,
  654.                    int SkipBin, LPUSERFUNCTIONS lpUserFunctions)
  655. {
  656.     int retcode = FALSE, compare;
  657.     ulg i, j, patternLen, buflen;
  658.     char * sz, *p;
  659.     UzpBuffer retstr;
  660.  
  661.     /* Turn off any windows printing functions, as they may not have been
  662.      * identified yet. There is no requirement that we initialize the
  663.      * dll with printing stuff for this. */
  664.     Wiz_NoPrinting(TRUE);
  665.  
  666.     if (!Wiz_UnzipToMemory(archive, file, lpUserFunctions, &retstr)) {
  667.        Wiz_NoPrinting(FALSE);
  668.        return -1;   /* not enough memory, file not found, or other error */
  669.     }
  670.  
  671.     if (SkipBin) {
  672.         if (retstr.strlength < 100)
  673.             buflen = retstr.strlength;
  674.         else
  675.             buflen = 100;
  676.         for (i = 0; i < buflen; i++) {
  677.             if (iscntrl(retstr.strptr[i])) {
  678.                 if ((retstr.strptr[i] != 0x0A) &&
  679.                     (retstr.strptr[i] != 0x0D) &&
  680.                     (retstr.strptr[i] != 0x09))
  681.                 {
  682.                     /* OK, we now think we have a binary file of some sort */
  683.                     free(retstr.strptr);
  684.                     Wiz_NoPrinting(FALSE);
  685.                     return FALSE;
  686.                 }
  687.             }
  688.         }
  689.     }
  690.  
  691.     patternLen = strlen(pattern);
  692.  
  693.     if (retstr.strlength < patternLen) {
  694.         free(retstr.strptr);
  695.         Wiz_NoPrinting(FALSE);
  696.         return FALSE;
  697.     }
  698.  
  699.     sz = malloc(patternLen + 3); /* add two in case doing whole words only */
  700.     if (cmd > 1) {
  701.         strcpy(sz, " ");
  702.         strcat(sz, pattern);
  703.         strcat(sz, " ");
  704.     } else
  705.         strcpy(sz, pattern);
  706.  
  707.     if ((cmd == 0) || (cmd == 2)) {
  708.         for (i = 0; i < strlen(sz); i++)
  709.             sz[i] = toupper(sz[i]);
  710.         for (i = 0; i < retstr.strlength; i++)
  711.             retstr.strptr[i] = toupper(retstr.strptr[i]);
  712.     }
  713.  
  714.     for (i = 0; i < (retstr.strlength - patternLen); i++) {
  715.         p = &retstr.strptr[i];
  716.         compare = TRUE;
  717.         for (j = 0; j < patternLen; j++) {
  718.             /* We cannot do strncmp here, as we may be dealing with a
  719.              * "binary" file, such as a word processing file, or perhaps
  720.              * even a true executable of some sort. */
  721.             if (p[j] != sz[j]) {
  722.                 compare = FALSE;
  723.                 break;
  724.             }
  725.         }
  726.         if (compare == TRUE) {
  727.             retcode = TRUE;
  728.             break;
  729.         }
  730.     }
  731.  
  732.     free(sz);
  733.     free(retstr.strptr);
  734.     Wiz_NoPrinting(FALSE); /* Turn printing back on */
  735.     return retcode;
  736. }
  737. #endif /* !__16BIT__ */
  738.  
  739. int WINAPI Wiz_Validate(LPSTR archive, int AllCodes)
  740. {
  741.     return UzpValidate((char *)archive, AllCodes);
  742. }
  743.  
  744. #endif /* !SFX */
  745.