mirror of https://github.com/x64dbg/btparser
667 lines
16 KiB
Plaintext
667 lines
16 KiB
Plaintext
|
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: typedef enum < uint > {
|
||
|
33: S_ZIPFILERECORD = 0x4034B50 ,
|
||
|
34: S_ZIPDATADESCR = 0x8074B50 ,
|
||
|
35: S_ZIPDIRENTRY = 0x2014B50 ,
|
||
|
36: S_ZIPDIGITALSIG = 0x5054B50 ,
|
||
|
37: S_ZIP64ENDLOCATORRECORD = 0x6064B50 ,
|
||
|
38: S_ZIP64ENDLOCATOR = 0x7064B50 ,
|
||
|
39: S_ZIPENDLOCATOR = 0x6054B50
|
||
|
40: } SignatureTYPE < format = hex > ;
|
||
|
41:
|
||
|
42: typedef enum < byte > {
|
||
|
43: OS_FAT = 0 ,
|
||
|
44: OS_AMIGA = 1 ,
|
||
|
45: OS_VMS = 2 ,
|
||
|
46: OS_Unix = 3 ,
|
||
|
47: OS_VM_CMS = 4 ,
|
||
|
48: OS_Atari = 5 ,
|
||
|
49: OS_HPFS = 6 ,
|
||
|
50: OS_Mac = 7 ,
|
||
|
51: OS_Z_System = 8 ,
|
||
|
52: OS_CPM = 9 ,
|
||
|
53: OS_TOPS20 = 10 ,
|
||
|
54: OS_NTFS = 11 ,
|
||
|
55: OS_QDOS = 12 ,
|
||
|
56: OS_Acorn = 13 ,
|
||
|
57: OS_VFAT = 14 ,
|
||
|
58: OS_MVS = 15 ,
|
||
|
59: OS_BeOS = 16 ,
|
||
|
60: OS_Tandem = 17 ,
|
||
|
61: OS_OS400 = 18 ,
|
||
|
62: OS_OSX = 19
|
||
|
63: } HOSTOSTYPE ;
|
||
|
64:
|
||
|
65: typedef byte VERSIONTYPE < read = read_VERSIONTYPE > ;
|
||
|
66:
|
||
|
67: string read_VERSIONTYPE ( local VERSIONTYPE & af ) {
|
||
|
68: local string s = "" ;
|
||
|
69: SPrintf ( s , "%1.1f" , ( float ) af / 10 ) ;
|
||
|
70: return s ;
|
||
|
71: }
|
||
|
72:
|
||
|
73: typedef struct {
|
||
|
74: VERSIONTYPE Version ;
|
||
|
75: HOSTOSTYPE HostOS ;
|
||
|
76: } VERECORD < read = read_VERECORD > ;
|
||
|
77:
|
||
|
78: string read_VERECORD ( local VERECORD & af ) {
|
||
|
79: local string s = "" ;
|
||
|
80: SPrintf ( s , "Ver %1.1f, " , ( float ) af . Version / 10 ) ;
|
||
|
81: s += EnumToString ( af . HostOS ) ;
|
||
|
82: return s ;
|
||
|
83: }
|
||
|
84:
|
||
|
85:
|
||
|
86: typedef enum < short > {
|
||
|
87: COMP_STORED = 0 ,
|
||
|
88: COMP_SHRUNK = 1 ,
|
||
|
89: COMP_REDUCED1 = 2 ,
|
||
|
90: COMP_REDUCED2 = 3 ,
|
||
|
91: COMP_REDUCED3 = 4 ,
|
||
|
92: COMP_REDUCED4 = 5 ,
|
||
|
93: COMP_IMPLODED = 6 ,
|
||
|
94: COMP_TOKEN = 7 ,
|
||
|
95: COMP_DEFLATE = 8 ,
|
||
|
96: COMP_DEFLATE64 = 9 ,
|
||
|
97: COMP_PKImploding = 10 ,
|
||
|
98:
|
||
|
99: COMP_BZip2 = 12 ,
|
||
|
100: COMP_LZMA = 14 ,
|
||
|
101: COMP_Terse = 18 ,
|
||
|
102: COMP_Lz77 = 19 ,
|
||
|
103:
|
||
|
104: COMP_Jpeg = 0x60 ,
|
||
|
105: COMP_WavPack = 0x61 ,
|
||
|
106: COMP_PPMd = 0x62 ,
|
||
|
107: COMP_WzAES = 0x63
|
||
|
108: } COMPTYPE ;
|
||
|
109:
|
||
|
110: typedef enum < ushort > {
|
||
|
111: FLAG_Encrypted = 0x1 ,
|
||
|
112: FLAG_CompressionFlagBit1 = 0x2 ,
|
||
|
113: FLAG_CompressionFlagBit2 = 0x4 ,
|
||
|
114: FLAG_DescriptorUsedMask = 0x8 ,
|
||
|
115: FLAG_Reserved1 = 0x10 ,
|
||
|
116: FLAG_Reserved2 = 0x20 ,
|
||
|
117: FLAG_StrongEncrypted = 0x40 ,
|
||
|
118: FLAG_CurrentlyUnused1 = 0x80 ,
|
||
|
119: FLAG_CurrentlyUnused2 = 0x100 ,
|
||
|
120: FLAG_CurrentlyUnused3 = 0x200 ,
|
||
|
121: FLAG_CurrentlyUnused4 = 0x400 ,
|
||
|
122: FLAG_Utf8 = 0x800 ,
|
||
|
123: FLAG_ReservedPKWARE1 = 0x1000 ,
|
||
|
124: FLAG_CDEncrypted = 0x2000 ,
|
||
|
125: FLAG_ReservedPKWARE2 = 0x4000 ,
|
||
|
126: FLAG_ReservedPKWARE3 = 0x8000 ,
|
||
|
127:
|
||
|
128: } FLAGTYPE < read = read_FLAGTYPE > ;
|
||
|
129:
|
||
|
130: string read_FLAGTYPE ( local FLAGTYPE & af ) {
|
||
|
131: local string s = "" ;
|
||
|
132: local int commaNeeded = 0 ;
|
||
|
133: local FLAGTYPE i = 1 ;
|
||
|
134:
|
||
|
135: SPrintf ( s , "%d: " , af ) ;
|
||
|
136: while ( i < FLAG_ReservedPKWARE3 )
|
||
|
137: {
|
||
|
138: if ( af & i )
|
||
|
139: {
|
||
|
140: if ( commaNeeded )
|
||
|
141: { s += ", " ; }
|
||
|
142: s += EnumToString ( i ) ;
|
||
|
143: commaNeeded = 1 ;
|
||
|
144: }
|
||
|
145: i = i << 1 ;
|
||
|
146: }
|
||
|
147: return s ;
|
||
|
148: }
|
||
|
149:
|
||
|
150: typedef enum < ushort > {
|
||
|
151: EH_Zip64 = 0x1 ,
|
||
|
152: EH_AVInfo = 0x7 ,
|
||
|
153: EH_ExtLanguage = 0x8 ,
|
||
|
154: EH_OS2 = 0x9 ,
|
||
|
155: EH_NTFS = 0xA ,
|
||
|
156: EH_OpenVMS = 0xC ,
|
||
|
157: EH_UNIX = 0xD ,
|
||
|
158: EH_fileStream = 0xE ,
|
||
|
159: EH_PatchDescriptor = 0xF ,
|
||
|
160: EH_PKCS7X509 = 0x14 ,
|
||
|
161: EH_X509IDSignature = 0x15 ,
|
||
|
162: EH_X509IDCD = 0x16 ,
|
||
|
163: EH_StrongEncryption = 0x17 ,
|
||
|
164: EH_RecordManagement = 0x18 ,
|
||
|
165: EH_PKCS7List = 0x19 ,
|
||
|
166: EH_Attributes = 0x65 ,
|
||
|
167: EH_ReservedAttributes = 0x66 ,
|
||
|
168: EH_POSZIP4690 = 0x4690 ,
|
||
|
169: EH_Mac = 0x7C8 ,
|
||
|
170: EH_ZipItMac1 = 0x2605 ,
|
||
|
171: EH_ZipItMac2 = 0x2705 ,
|
||
|
172: EH_ZipItMac3 = 0x2805 ,
|
||
|
173: EH_InfoZIPMac = 0x334D ,
|
||
|
174: EH_Acorn = 0x4341 ,
|
||
|
175: EH_WinNTSecurity = 0x4453 ,
|
||
|
176: EH_VM_CMS = 0x4704 ,
|
||
|
177: EH_MVS = 0x470F ,
|
||
|
178: EH_FWKCS = 0x4B46 ,
|
||
|
179: EH_OS2AccessList = 0x4C41 ,
|
||
|
180: EH_InfoZIPOpenVMS = 0x4D49 ,
|
||
|
181: EH_Xceed = 0x4F4C ,
|
||
|
182: EH_AOSVS = 0x5356 ,
|
||
|
183: EH_extTimestamp = 0x5455 ,
|
||
|
184: EH_XceedUnicode = 0x554E ,
|
||
|
185: EH_InfoZIPUNIX = 0x5855 ,
|
||
|
186: EH_InfoZIPUnicodeComment = 0x6375 ,
|
||
|
187: EH_BeOS = 0x6542 ,
|
||
|
188: EH_InfoZIPUnicodePath = 0x7075 ,
|
||
|
189: EH_ASiUNIX = 0x756E ,
|
||
|
190: EH_InfoZIPUNIXNew = 0x7855 ,
|
||
|
191: EH_InfoZIPUNIXNew3rd = 0x7875 ,
|
||
|
192: EH_WinGrowth = 0xA220 ,
|
||
|
193: EH_SMSQDOS = 0xFD4A ,
|
||
|
194: EH_WzAES = 0x9901 ,
|
||
|
195: } HEADERFLAG ;
|
||
|
196:
|
||
|
197: typedef enum < ushort > {
|
||
|
198: AlgID_DES = 0x6601 ,
|
||
|
199: AlgID_RC2OLD = 0x6602 ,
|
||
|
200: AlgID_3DES168 = 0x6603 ,
|
||
|
201: AlgID_3DES112 = 0x6609 ,
|
||
|
202: AlgID_AES128 = 0x660E ,
|
||
|
203: AlgID_AES192 = 0x660F ,
|
||
|
204: AlgID_AES256 = 0x6610 ,
|
||
|
205: AlgID_RC2 = 0x6702 ,
|
||
|
206: AlgID_Blowfish = 0x6720 ,
|
||
|
207: AlgID_Twofish = 0x6721 ,
|
||
|
208: AlgID_RC4 = 0x6801 ,
|
||
|
209: AlgID_Unknown = 0xFFFF ,
|
||
|
210: } ALGFLAG ;
|
||
|
211:
|
||
|
212: typedef enum < byte > {
|
||
|
213: AES128 = 0x1 ,
|
||
|
214: AES192 = 0x2 ,
|
||
|
215: AES256 = 0x3 ,
|
||
|
216: } AESMODE ;
|
||
|
217:
|
||
|
218: typedef enum < ushort > {
|
||
|
219: pfPassword = 0x1 ,
|
||
|
220: pfCertificates = 0x2 ,
|
||
|
221: pfPasswordCertificates = 0x3 ,
|
||
|
222: } PRCFLAG ;
|
||
|
223:
|
||
|
224: typedef struct {
|
||
|
225: HEADERFLAG efHeaderID ;
|
||
|
226: ushort efDataSize ;
|
||
|
227:
|
||
|
228: Printf ( "%d" , efHeaderID ) ;
|
||
|
229: switch ( efHeaderID )
|
||
|
230: {
|
||
|
231: case EH_Zip64 :
|
||
|
232: uint64 efOriginalSize ;
|
||
|
233: uint64 efCompressedSize ;
|
||
|
234:
|
||
|
235:
|
||
|
236: break ;
|
||
|
237: case EH_InfoZIPUnicodePath :
|
||
|
238: byte efVersion ;
|
||
|
239: uint efNameCRC32 ;
|
||
|
240: if ( efDataSize > 0 )
|
||
|
241: char efUnicodeName [ efDataSize - 5 ] ;
|
||
|
242: break ;
|
||
|
243: case EH_NTFS :
|
||
|
244: int Reserved ;
|
||
|
245: local int len = efDataSize - 4 ;
|
||
|
246: while ( len > 0 )
|
||
|
247: {
|
||
|
248: ushort Tag ;
|
||
|
249: ushort Size ;
|
||
|
250: if ( Tag == 0x1 )
|
||
|
251: {
|
||
|
252: FILETIME Mtime ;
|
||
|
253: FILETIME Atime ;
|
||
|
254: FILETIME Ctime ;
|
||
|
255: }
|
||
|
256: else
|
||
|
257: byte Data [ Size ] ;
|
||
|
258: len -= Size + 4 ;
|
||
|
259: }
|
||
|
260: break ;
|
||
|
261: case EH_StrongEncryption :
|
||
|
262: ushort Format ;
|
||
|
263: ALGFLAG AlgID ;
|
||
|
264: ushort Bitlen ;
|
||
|
265: PRCFLAG Flags ;
|
||
|
266: if ( efDataSize > 8 )
|
||
|
267: byte CertData [ efDataSize - 8 ] ;
|
||
|
268: break ;
|
||
|
269: case EH_WzAES :
|
||
|
270: ushort version ;
|
||
|
271: char VendorID [ 2 ] ;
|
||
|
272: AESMODE Strength ;
|
||
|
273: COMPTYPE deCompression ;
|
||
|
274: break ;
|
||
|
275: default :
|
||
|
276: if ( efDataSize > 0 )
|
||
|
277: char efData [ efDataSize ] ;
|
||
|
278: break ;
|
||
|
279: }
|
||
|
280: } EXTRAFIELD < read = read_EXTRAFIELD > ;
|
||
|
281:
|
||
|
282: string read_EXTRAFIELD ( local EXTRAFIELD & af )
|
||
|
283: {
|
||
|
284: return EnumToString ( af . efHeaderID ) ;
|
||
|
285: }
|
||
|
286:
|
||
|
287: typedef struct {
|
||
|
288: HEADERFLAG efHeaderID ;
|
||
|
289: uint efDataSize ;
|
||
|
290:
|
||
|
291: Printf ( "%d" , efHeaderID ) ;
|
||
|
292: switch ( efHeaderID )
|
||
|
293: {
|
||
|
294: case EH_Zip64 :
|
||
|
295: uint64 efOriginalSize ;
|
||
|
296: uint64 efCompressedSize ;
|
||
|
297:
|
||
|
298:
|
||
|
299: break ;
|
||
|
300: case EH_InfoZIPUnicodePath :
|
||
|
301: byte efVersion ;
|
||
|
302: uint efNameCRC32 ;
|
||
|
303: if ( efDataSize > 0 )
|
||
|
304: char efUnicodeName [ efDataSize - 5 ] ;
|
||
|
305: break ;
|
||
|
306: default :
|
||
|
307: if ( efDataSize > 0 )
|
||
|
308: char efData [ efDataSize ] ;
|
||
|
309: break ;
|
||
|
310: }
|
||
|
311: } EXTRA64FIELD ;
|
||
|
312:
|
||
|
313: typedef enum < uint > {
|
||
|
314: FA_READONLY = 0x1 ,
|
||
|
315: FA_HIDDEN = 0x2 ,
|
||
|
316: FA_SYSTEM = 0x4 ,
|
||
|
317: FA_DIRECTORY = 0x10 ,
|
||
|
318: FA_ARCHIVE = 0x20 ,
|
||
|
319: FA_DEVICE = 0x40 ,
|
||
|
320: FA_NORMAL = 0x80 ,
|
||
|
321: FA_TEMPORARY = 0x100 ,
|
||
|
322: FA_SPARSE_FILE = 0x200 ,
|
||
|
323: FA_REPARSE_POINT = 0x400 ,
|
||
|
324: FA_COMPRESSED = 0x800 ,
|
||
|
325: FA_OFFLINE = 0x1000 ,
|
||
|
326: FA_NOT_CONTENT_INDEXED = 0x2000 ,
|
||
|
327: FA_ENCRYPTED = 0x4000 ,
|
||
|
328: FA_VIRTUAL = 0x10000 ,
|
||
|
329:
|
||
|
330: kIFMT = 170000 << 16 ,
|
||
|
331:
|
||
|
332: kIFDIR = 40000 << 16 ,
|
||
|
333: kIFREG = 100000 << 16 ,
|
||
|
334: kIFSOCK = 140000 << 16 ,
|
||
|
335: kIFLNK = 120000 << 16 ,
|
||
|
336: kIFBLK = 60000 << 16 ,
|
||
|
337: kIFCHR = 20000 << 16 ,
|
||
|
338: kIFIFO = 10000 << 16 ,
|
||
|
339:
|
||
|
340: kISUID = 4000 << 16 ,
|
||
|
341: kISGID = 2000 << 16 ,
|
||
|
342: kISVTX = 1000 << 16 ,
|
||
|
343: kIRWXU = 700 << 16 ,
|
||
|
344: kIRUSR = 400 << 16 ,
|
||
|
345: kIWUSR = 200 << 16 ,
|
||
|
346: kIXUSR = 100 << 16 ,
|
||
|
347: kIRWXG = 70 << 16 ,
|
||
|
348: kIRGRP = 40 << 16 ,
|
||
|
349: kIWGRP = 20 << 16 ,
|
||
|
350: kIXGRP = 10 << 16 ,
|
||
|
351: kIRWXO = 7 << 16 ,
|
||
|
352: kIROTH = 4 << 16 ,
|
||
|
353: kIWOTH = 2 << 16 ,
|
||
|
354: kIXOTH = 1 << 16
|
||
|
355: } FILEATTRIBUTE < read = read_FILEATTRIBUTE > ;
|
||
|
356:
|
||
|
357: string read_FILEATTRIBUTE ( local FILEATTRIBUTE & af ) {
|
||
|
358: local string s = "" ;
|
||
|
359: local int commaNeeded = 0 ;
|
||
|
360: local FILEATTRIBUTE i = 1 ;
|
||
|
361:
|
||
|
362: SPrintf ( s , "0x%X: " , af ) ;
|
||
|
363: while ( i < 0xFFFFFF - 2 )
|
||
|
364: {
|
||
|
365: if ( af & i )
|
||
|
366: {
|
||
|
367: if ( commaNeeded )
|
||
|
368: {
|
||
|
369: s += ", " ;
|
||
|
370: }
|
||
|
371: s += EnumToString ( i ) ;
|
||
|
372: commaNeeded = 1 ;
|
||
|
373: }
|
||
|
374: i = i << 1 ;
|
||
|
375: }
|
||
|
376: return s ;
|
||
|
377: }
|
||
|
378:
|
||
|
379:
|
||
|
380: typedef struct {
|
||
|
381: SignatureTYPE ddSignature ;
|
||
|
382: uint ddCRC < format = hex > ;
|
||
|
383: uint ddCompressedSize ;
|
||
|
384: uint ddUncompressedSize ;
|
||
|
385: } ZIPDATADESCR ;
|
||
|
386:
|
||
|
387:
|
||
|
388: typedef struct {
|
||
|
389:
|
||
|
390: SignatureTYPE frSignature ;
|
||
|
391: VERECORD frVersion ;
|
||
|
392: FLAGTYPE frFlags ;
|
||
|
393: COMPTYPE frCompression ;
|
||
|
394: DOSTIME frFileTime ;
|
||
|
395: DOSDATE frFileDate ;
|
||
|
396: uint frCrc < format = hex > ;
|
||
|
397: uint frCompressedSize ;
|
||
|
398: uint frUncompressedSize ;
|
||
|
399: ushort frFileNameLength ;
|
||
|
400: ushort frExtraFieldLength ;
|
||
|
401: if ( frFileNameLength > 0 )
|
||
|
402: char frFileName [ frFileNameLength ] ;
|
||
|
403:
|
||
|
404: local int len = frExtraFieldLength ;
|
||
|
405: while ( len > 0 )
|
||
|
406: {
|
||
|
407: EXTRAFIELD frExtraField ;
|
||
|
408: len -= frExtraField . efDataSize + 4 ;
|
||
|
409: }
|
||
|
410:
|
||
|
411: SetBackColor ( cNone ) ;
|
||
|
412:
|
||
|
413: if ( ( frFlags & FLAG_Encrypted ) && ( frFlags & FLAG_StrongEncrypted ) )
|
||
|
414: {
|
||
|
415: struct
|
||
|
416: {
|
||
|
417: ushort IVSize ;
|
||
|
418: byte IVData [ IVSize ] ;
|
||
|
419: uint Size ;
|
||
|
420: ushort Format ;
|
||
|
421: ALGFLAG AlgID ;
|
||
|
422: ushort BitLen ;
|
||
|
423: ushort Flags ;
|
||
|
424: ushort ErdSize ;
|
||
|
425: byte ErdData [ ErdSize ] ;
|
||
|
426: uint Reserved ;
|
||
|
427: ushort VSize ;
|
||
|
428: byte VData [ VSize - 4 ] ;
|
||
|
429: uint VCRC32 ;
|
||
|
430: } StrongEncryptedHeader ;
|
||
|
431: char frData [ frCompressedSize - StrongEncryptedHeader . IVSize - StrongEncryptedHeader . Size - 6 ] ;
|
||
|
432: }
|
||
|
433: else if ( ( frFlags & FLAG_Encrypted ) && ( frCompression == COMP_WzAES ) )
|
||
|
434: {
|
||
|
435: local int lenSalt = 0 ;
|
||
|
436: if ( frExtraField . efHeaderID == EH_WzAES )
|
||
|
437: {
|
||
|
438: switch ( frExtraField . Strength )
|
||
|
439: {
|
||
|
440: case AES128 :
|
||
|
441: lenSalt = 8 ;
|
||
|
442: break ;
|
||
|
443: case AES192 :
|
||
|
444: lenSalt = 12 ;
|
||
|
445: break ;
|
||
|
446: case AES256 :
|
||
|
447: lenSalt = 16 ;
|
||
|
448: break ;
|
||
|
449: }
|
||
|
450: }
|
||
|
451: uchar SaltValue [ lenSalt ] ;
|
||
|
452: ushort PassVerification ;
|
||
|
453: uchar frData [ frCompressedSize - 12 - lenSalt ] ;
|
||
|
454: uchar AuthenticationCode [ 10 ] ;
|
||
|
455: }
|
||
|
456: else if ( ( frCompressedSize > 0 ) && ( frCompressedSize < 0xFFFFFFFF ) )
|
||
|
457: {
|
||
|
458: uchar frData [ frCompressedSize ] ;
|
||
|
459: }
|
||
|
460: else if ( frCompressedSize == 0 && ( frFlags & FLAG_DescriptorUsedMask ) )
|
||
|
461: {
|
||
|
462:
|
||
|
463:
|
||
|
464:
|
||
|
465: local int64 posCurrent = FTell ( ) ;
|
||
|
466: local int64 posNext = FindFirst ( S_ZIPDATADESCR , true , false , false , 0 . 0 , 1 , posCurrent ) ;
|
||
|
467: if ( posNext >= posCurrent )
|
||
|
468: {
|
||
|
469: uchar frData [ posNext - posCurrent ] ;
|
||
|
470:
|
||
|
471: SetBackColor ( cLtGreen ) ;
|
||
|
472: ZIPDATADESCR dataDescr ;
|
||
|
473: }
|
||
|
474: }
|
||
|
475:
|
||
|
476: } ZIPFILERECORD < read = ReadZIPFILERECORD , write = WriteZIPFILERECORD > ;
|
||
|
477:
|
||
|
478:
|
||
|
479: typedef struct {
|
||
|
480: SignatureTYPE deSignature ;
|
||
|
481: VERECORD deVersionMadeBy ;
|
||
|
482: VERECORD deVersionToExtract ;
|
||
|
483: FLAGTYPE deFlags ;
|
||
|
484: COMPTYPE deCompression ;
|
||
|
485: DOSTIME deFileTime ;
|
||
|
486: DOSDATE deFileDate ;
|
||
|
487: uint deCrc < format = hex > ;
|
||
|
488: uint deCompressedSize ;
|
||
|
489: uint deUncompressedSize ;
|
||
|
490: ushort deFileNameLength ;
|
||
|
491: ushort deExtraFieldLength ;
|
||
|
492: ushort deFileCommentLength ;
|
||
|
493: ushort deDiskNumberStart ;
|
||
|
494: ushort deInternalAttributes ;
|
||
|
495: FILEATTRIBUTE deExternalAttributes ;
|
||
|
496: uint deHeaderOffset ;
|
||
|
497: if ( deFileNameLength > 0 )
|
||
|
498: char deFileName [ deFileNameLength ] ;
|
||
|
499: local int len = deExtraFieldLength ;
|
||
|
500: while ( len > 0 )
|
||
|
501: {
|
||
|
502: EXTRAFIELD deExtraField ;
|
||
|
503: len -= deExtraField . efDataSize + 4 ;
|
||
|
504: }
|
||
|
505: if ( deFileCommentLength > 0 )
|
||
|
506: uchar deFileComment [ deFileCommentLength ] ;
|
||
|
507: } ZIPDIRENTRY < read = ReadZIPDIRENTRY > ;
|
||
|
508:
|
||
|
509:
|
||
|
510: typedef struct {
|
||
|
511: SignatureTYPE dsSignature ;
|
||
|
512: ushort dsDataLength ;
|
||
|
513: if ( dsDataLength > 0 )
|
||
|
514: uchar dsData [ dsDataLength ] ;
|
||
|
515: } ZIPDIGITALSIG ;
|
||
|
516:
|
||
|
517:
|
||
|
518: typedef struct {
|
||
|
519: SignatureTYPE elr64Signature ;
|
||
|
520: int64 elr64DirectoryRecordSize ;
|
||
|
521: if ( elr64DirectoryRecordSize > 1 )
|
||
|
522: VERECORD elr64VersionMadeBy ;
|
||
|
523: if ( elr64DirectoryRecordSize > 2 )
|
||
|
524: VERECORD elr64VersionToExtract ;
|
||
|
525: if ( elr64DirectoryRecordSize > 4 )
|
||
|
526: uint el64DiskNumber ;
|
||
|
527: if ( elr64DirectoryRecordSize > 8 )
|
||
|
528: uint el64StartDiskNumber ;
|
||
|
529: if ( elr64DirectoryRecordSize > 12 )
|
||
|
530: int64 el64EntriesOnDisk ;
|
||
|
531: if ( elr64DirectoryRecordSize > 20 )
|
||
|
532: int64 el64EntriesInDirectory ;
|
||
|
533: if ( elr64DirectoryRecordSize > 28 )
|
||
|
534: int64 el64DirectorySize ;
|
||
|
535: if ( elr64DirectoryRecordSize > 36 )
|
||
|
536: int64 el64DirectoryOffset ;
|
||
|
537: if ( elr64DirectoryRecordSize > 44 )
|
||
|
538: {
|
||
|
539: char DataSect [ elr64DirectoryRecordSize - 44 ] ;
|
||
|
540:
|
||
|
541:
|
||
|
542:
|
||
|
543:
|
||
|
544:
|
||
|
545:
|
||
|
546:
|
||
|
547: }
|
||
|
548: } ZIP64ENDLOCATORRECORD ;
|
||
|
549:
|
||
|
550:
|
||
|
551: typedef struct {
|
||
|
552: SignatureTYPE elSignature ;
|
||
|
553: uint elStartDiskNumber ;
|
||
|
554: int64 elDirectoryOffset ;
|
||
|
555: uint elEntriesInDirectory ;
|
||
|
556: } ZIP64ENDLOCATOR ;
|
||
|
557:
|
||
|
558:
|
||
|
559: typedef struct {
|
||
|
560: SignatureTYPE elSignature ;
|
||
|
561: ushort elDiskNumber ;
|
||
|
562: ushort elStartDiskNumber ;
|
||
|
563: ushort elEntriesOnDisk ;
|
||
|
564: ushort elEntriesInDirectory ;
|
||
|
565: uint elDirectorySize ;
|
||
|
566: uint elDirectoryOffset ;
|
||
|
567: ushort elCommentLength ;
|
||
|
568: if ( elCommentLength > 0 )
|
||
|
569: char elComment [ elCommentLength ] ;
|
||
|
570: } ZIPENDLOCATOR ;
|
||
|
571:
|
||
|
572:
|
||
|
573:
|
||
|
574:
|
||
|
575:
|
||
|
576:
|
||
|
577: string ReadZIPFILERECORD ( ZIPFILERECORD & file )
|
||
|
578: {
|
||
|
579: if ( exists ( file . frFileName ) )
|
||
|
580: return file . frFileName ;
|
||
|
581: else
|
||
|
582: return "" ;
|
||
|
583: }
|
||
|
584:
|
||
|
585: string ReadZIPDIRENTRY ( ZIPDIRENTRY & entry )
|
||
|
586: {
|
||
|
587: if ( exists ( entry . deFileName ) )
|
||
|
588: return entry . deFileName ;
|
||
|
589: else
|
||
|
590: return "" ;
|
||
|
591: }
|
||
|
592:
|
||
|
593:
|
||
|
594:
|
||
|
595:
|
||
|
596:
|
||
|
597: void WriteZIPFILERECORD ( ZIPFILERECORD & file , string s )
|
||
|
598: {
|
||
|
599: local int len = Strlen ( s ) ;
|
||
|
600: if ( exists ( file . frFileName ) )
|
||
|
601: {
|
||
|
602: Strncpy ( file . frFileName , s , file . frFileNameLength ) ;
|
||
|
603: if ( len < file . frFileNameLength )
|
||
|
604: file . frFileName [ len ] = 0 ;
|
||
|
605: }
|
||
|
606: }
|
||
|
607:
|
||
|
608:
|
||
|
609:
|
||
|
610:
|
||
|
611: local uint tag ;
|
||
|
612: LittleEndian ( ) ;
|
||
|
613: while ( ! FEof ( ) )
|
||
|
614: {
|
||
|
615:
|
||
|
616: tag = ReadUInt ( FTell ( ) ) ;
|
||
|
617:
|
||
|
618:
|
||
|
619:
|
||
|
620:
|
||
|
621:
|
||
|
622: if ( tag == S_ZIPFILERECORD )
|
||
|
623: {
|
||
|
624: SetBackColor ( cLtGray ) ;
|
||
|
625: ZIPFILERECORD record ;
|
||
|
626: if ( record . frExtraFieldLength > 0 && record . frExtraField . efHeaderID == EH_Zip64 )
|
||
|
627: {
|
||
|
628:
|
||
|
629: FSkip ( record . frExtraField . efCompressedSize ) ;
|
||
|
630: }
|
||
|
631: }
|
||
|
632: else if ( tag == S_ZIPDATADESCR )
|
||
|
633: {
|
||
|
634: SetBackColor ( cLtGreen ) ;
|
||
|
635: ZIPDATADESCR dataDescr ;
|
||
|
636: }
|
||
|
637: else if ( tag == S_ZIPDIRENTRY )
|
||
|
638: {
|
||
|
639: SetBackColor ( cLtPurple ) ;
|
||
|
640: ZIPDIRENTRY dirEntry ;
|
||
|
641: }
|
||
|
642: else if ( tag == S_ZIPDIGITALSIG )
|
||
|
643: {
|
||
|
644: SetBackColor ( cLtBlue ) ;
|
||
|
645: ZIPDIGITALSIG digitalSig ;
|
||
|
646: }
|
||
|
647: else if ( tag == S_ZIP64ENDLOCATORRECORD )
|
||
|
648: {
|
||
|
649: SetBackColor ( cYellow ) ;
|
||
|
650: ZIP64ENDLOCATORRECORD end64Locator ;
|
||
|
651: }
|
||
|
652: else if ( tag == S_ZIP64ENDLOCATOR )
|
||
|
653: {
|
||
|
654: SetBackColor ( cDkYellow ) ;
|
||
|
655: ZIP64ENDLOCATOR end64Locator ;
|
||
|
656: }
|
||
|
657: else if ( tag == S_ZIPENDLOCATOR )
|
||
|
658: {
|
||
|
659: SetBackColor ( cLtYellow ) ;
|
||
|
660: ZIPENDLOCATOR endLocator ;
|
||
|
661: }
|
||
|
662: else
|
||
|
663: {
|
||
|
664: Warning ( "Unknown ZIP tag encountered. Template stopped." ) ;
|
||
|
665: return - 1 ;
|
||
|
666: }
|
||
|
667: } tok_eof
|