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