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
|
#import "OFStream.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfRangeException.h"
extern uint32_t of_zip_archive_read_field32(const uint8_t **, uint16_t *);
extern uint64_t of_zip_archive_read_field64(const uint8_t **, uint16_t *);
OFString *
of_zip_archive_entry_version_to_string(uint16_t version)
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_MSDOS:
attrCompat = "MS-DOS or OS/2";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_AMIGA:
attrCompat = "Amiga";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_OPENVMS:
attrCompat = "OpenVMS";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_UNIX:
attrCompat = "UNIX";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_VM_CMS:
attrCompat = "VM/CMS";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_ATARI_ST:
attrCompat = "Atari ST";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_OS2_HPFS:
attrCompat = "OS/2 HPFS";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_MACINTOSH:
attrCompat = "Macintosh";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_Z_SYSTEM:
attrCompat = "Z-System";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_CP_M:
attrCompat = "CP/M";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_WINDOWS_NTFS:
attrCompat = "Windows NTFS";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_MVS:
attrCompat = "MVS (OS/390 - Z/OS)";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_VSE:
attrCompat = "VSE";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_ACORN_RISC_OS:
attrCompat = "Acorn RISC OS";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_VFAT:
attrCompat = "VFAT";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_ALTERNATE_MVS:
attrCompat = "Alternate MVS";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_BEOS:
attrCompat = "BeOS";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_TANDEM:
attrCompat = "Tandem";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_OS_400:
attrCompat = "OS/400";
break;
case OF_ZIP_ARCHIVE_ENTRY_ATTR_COMPAT_OS_X:
attrCompat = "OS X (Darwin)";
break;
}
if (attrCompat != NULL)
return [OFString stringWithFormat:
@"%u.%u, %s",
(version & 0xFF) / 10, (version & 0xFF) % 10, attrCompat];
else
return [OFString stringWithFormat:
@"%u.%u, unknown %02X",
(version % 0xFF) / 10, (version & 0xFF) % 10, version >> 8];
}
OFString *
of_zip_archive_entry_compression_method_to_string(uint16_t compressionMethod)
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_NONE:
return @"none";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_SHRINK:
return @"Shrink";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_REDUCE_FACTOR_1:
return @"Reduce (factor 1)";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_REDUCE_FACTOR_2:
return @"Reduce (factor 2)";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_REDUCE_FACTOR_3:
return @"Reduce (factor 3)";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_REDUCE_FACTOR_4:
return @"Reduce (factor 4)";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_IMPLODE:
return @"Implode";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_DEFLATE:
return @"Deflate";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_DEFLATE64:
return @"Deflate64";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_BZIP2:
return @"BZip2";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_LZMA:
return @"LZMA";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_WAVPACK:
return @"WavPack";
case OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_PPMD:
return @"PPMd";
default:
return @"unknown";
}
}
size_t
of_zip_archive_entry_extra_field_find(OFData *extraField, uint16_t tag,
uint16_t *size)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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
|
#import "OFStream.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfRangeException.h"
extern uint32_t OFZIPArchiveReadField32(const uint8_t **, uint16_t *);
extern uint64_t OFZIPArchiveReadField64(const uint8_t **, uint16_t *);
OFString *
OFZIPArchiveEntryVersionToString(uint16_t version)
{
const char *attrCompat = NULL;
switch (version >> 8) {
case OFZIPArchiveEntryAttributeCompatibilityMSDOS:
attrCompat = "MS-DOS or OS/2";
break;
case OFZIPArchiveEntryAttributeCompatibilityAmiga:
attrCompat = "Amiga";
break;
case OFZIPArchiveEntryAttributeCompatibilityOpenVMS:
attrCompat = "OpenVMS";
break;
case OFZIPArchiveEntryAttributeCompatibilityUNIX:
attrCompat = "UNIX";
break;
case OFZIPArchiveEntryAttributeCompatibilityVM_CMS:
attrCompat = "VM/CMS";
break;
case OFZIPArchiveEntryAttributeCompatibilityAtariST:
attrCompat = "Atari ST";
break;
case OFZIPArchiveEntryAttributeCompatibilityOS2HPFS:
attrCompat = "OS/2 HPFS";
break;
case OFZIPArchiveEntryAttributeCompatibilityMacintosh:
attrCompat = "Macintosh";
break;
case OFZIPArchiveEntryAttributeCompatibilityZSystem:
attrCompat = "Z-System";
break;
case OFZIPArchiveEntryAttributeCompatibilityCPM:
attrCompat = "CP/M";
break;
case OFZIPArchiveEntryAttributeCompatibilityWindowsNTFS:
attrCompat = "Windows NTFS";
break;
case OFZIPArchiveEntryAttributeCompatibilityMVS:
attrCompat = "MVS (OS/390 - Z/OS)";
break;
case OFZIPArchiveEntryAttributeCompatibilityVSE:
attrCompat = "VSE";
break;
case OFZIPArchiveEntryAttributeCompatibilityAcornRISCOS:
attrCompat = "Acorn RISC OS";
break;
case OFZIPArchiveEntryAttributeCompatibilityVFAT:
attrCompat = "VFAT";
break;
case OFZIPArchiveEntryAttributeCompatibilityAlternateMVS:
attrCompat = "Alternate MVS";
break;
case OFZIPArchiveEntryAttributeCompatibilityBeOS:
attrCompat = "BeOS";
break;
case OFZIPArchiveEntryAttributeCompatibilityTandem:
attrCompat = "Tandem";
break;
case OFZIPArchiveEntryAttributeCompatibilityOS400:
attrCompat = "OS/400";
break;
case OFZIPArchiveEntryAttributeCompatibilityOSX:
attrCompat = "OS X (Darwin)";
break;
}
if (attrCompat != NULL)
return [OFString stringWithFormat:
@"%u.%u, %s",
(version & 0xFF) / 10, (version & 0xFF) % 10, attrCompat];
else
return [OFString stringWithFormat:
@"%u.%u, unknown %02X",
(version % 0xFF) / 10, (version & 0xFF) % 10, version >> 8];
}
OFString *
OFZIPArchiveEntryCompressionMethodName(
OFZIPArchiveEntryCompressionMethod compressionMethod)
{
switch (compressionMethod) {
case OFZIPArchiveEntryCompressionMethodNone:
return @"none";
case OFZIPArchiveEntryCompressionMethodShrink:
return @"Shrink";
case OFZIPArchiveEntryCompressionMethodReduceFactor1:
return @"Reduce (factor 1)";
case OFZIPArchiveEntryCompressionMethodReduceFactor2:
return @"Reduce (factor 2)";
case OFZIPArchiveEntryCompressionMethodReduceFactor3:
return @"Reduce (factor 3)";
case OFZIPArchiveEntryCompressionMethodReduceFactor4:
return @"Reduce (factor 4)";
case OFZIPArchiveEntryCompressionMethodImplode:
return @"Implode";
case OFZIPArchiveEntryCompressionMethodDeflate:
return @"Deflate";
case OFZIPArchiveEntryCompressionMethodDeflate64:
return @"Deflate64";
case OFZIPArchiveEntryCompressionMethodBZIP2:
return @"BZip2";
case OFZIPArchiveEntryCompressionMethodLZMA:
return @"LZMA";
case OFZIPArchiveEntryCompressionMethodWavPack:
return @"WavPack";
case OFZIPArchiveEntryCompressionMethodPPMd:
return @"PPMd";
default:
return @"unknown";
}
}
size_t
OFZIPArchiveEntryExtraFieldFind(OFData *extraField,
OFZIPArchiveEntryExtraFieldTag tag, uint16_t *size)
{
const uint8_t *bytes = extraField.items;
size_t count = extraField.count;
for (size_t i = 0; i < count;) {
uint16_t currentTag, currentSize;
|
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
|
extraField = [[[stream readDataWithCount:
extraFieldLength] mutableCopy] autorelease];
if (fileCommentLength > 0)
_fileComment = [[stream
readStringWithLength: fileCommentLength
encoding: encoding] copy];
ZIP64Index = of_zip_archive_entry_extra_field_find(extraField,
OF_ZIP_ARCHIVE_ENTRY_EXTRA_FIELD_ZIP64, &ZIP64Size);
if (ZIP64Index != OFNotFound) {
const uint8_t *ZIP64 =
[extraField itemAtIndex: ZIP64Index];
OFRange range =
OFRangeMake(ZIP64Index - 4, ZIP64Size + 4);
if (_uncompressedSize == 0xFFFFFFFF)
_uncompressedSize = of_zip_archive_read_field64(
&ZIP64, &ZIP64Size);
if (_compressedSize == 0xFFFFFFFF)
_compressedSize = of_zip_archive_read_field64(
&ZIP64, &ZIP64Size);
if (_localFileHeaderOffset == 0xFFFFFFFF)
_localFileHeaderOffset =
of_zip_archive_read_field64(&ZIP64,
&ZIP64Size);
_startDiskNumber = of_zip_archive_read_field32(
&ZIP64, &ZIP64Size);
if (ZIP64Size > 0 || _localFileHeaderOffset < 0)
@throw [OFInvalidFormatException exception];
[extraField removeItemsInRange: range];
}
|
|
|
|
|
<
|
|
|
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
|
extraField = [[[stream readDataWithCount:
extraFieldLength] mutableCopy] autorelease];
if (fileCommentLength > 0)
_fileComment = [[stream
readStringWithLength: fileCommentLength
encoding: encoding] copy];
ZIP64Index = OFZIPArchiveEntryExtraFieldFind(extraField,
OFZIPArchiveEntryExtraFieldTagZIP64, &ZIP64Size);
if (ZIP64Index != OFNotFound) {
const uint8_t *ZIP64 =
[extraField itemAtIndex: ZIP64Index];
OFRange range =
OFRangeMake(ZIP64Index - 4, ZIP64Size + 4);
if (_uncompressedSize == 0xFFFFFFFF)
_uncompressedSize = OFZIPArchiveReadField64(
&ZIP64, &ZIP64Size);
if (_compressedSize == 0xFFFFFFFF)
_compressedSize = OFZIPArchiveReadField64(
&ZIP64, &ZIP64Size);
if (_localFileHeaderOffset == 0xFFFFFFFF)
_localFileHeaderOffset =
OFZIPArchiveReadField64(&ZIP64, &ZIP64Size);
if (_startDiskNumber == 0xFFFF)
_startDiskNumber = OFZIPArchiveReadField32(
&ZIP64, &ZIP64Size);
if (ZIP64Size > 0 || _localFileHeaderOffset < 0)
@throw [OFInvalidFormatException exception];
[extraField removeItemsInRange: range];
}
|
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
|
}
- (OFData *)extraField
{
return _extraField;
}
- (uint16_t)versionMadeBy
{
return _versionMadeBy;
}
- (uint16_t)minVersionNeeded
{
return _minVersionNeeded;
}
- (OFDate *)modificationDate
{
void *pool = objc_autoreleasePoolPush();
|
|
|
|
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
|
}
- (OFData *)extraField
{
return _extraField;
}
- (OFZIPArchiveEntryAttributeCompatibility)versionMadeBy
{
return _versionMadeBy;
}
- (OFZIPArchiveEntryAttributeCompatibility)minVersionNeeded
{
return _minVersionNeeded;
}
- (OFDate *)modificationDate
{
void *pool = objc_autoreleasePoolPush();
|
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
|
format: @"%Y-%m-%d %H:%M:%S"];
objc_autoreleasePoolPop(pool);
return [date autorelease];
}
- (uint16_t)compressionMethod
{
return _compressionMethod;
}
- (uint64_t)compressedSize
{
return _compressedSize;
|
|
|
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
|
format: @"%Y-%m-%d %H:%M:%S"];
objc_autoreleasePoolPop(pool);
return [date autorelease];
}
- (OFZIPArchiveEntryCompressionMethod)compressionMethod
{
return _compressionMethod;
}
- (uint64_t)compressedSize
{
return _compressedSize;
|
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
|
return _localFileHeaderOffset;
}
- (OFString *)description
{
void *pool = objc_autoreleasePoolPush();
OFString *compressionMethod =
of_zip_archive_entry_compression_method_to_string(
_compressionMethod);
|
<
|
|
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
|
return _localFileHeaderOffset;
}
- (OFString *)description
{
void *pool = objc_autoreleasePoolPush();
OFString *compressionMethod =
OFZIPArchiveEntryCompressionMethodName(_compressionMethod);
OFString *ret = [OFString stringWithFormat:
@"<%@:\n"
@"\tFile name = %@\n"
@"\tFile comment = %@\n"
@"\tGeneral purpose bit flag = %u\n"
@"\tCompressed size = %" @PRIu64 "\n"
@"\tUncompressed size = %" @PRIu64 "\n"
|
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
|
[stream writeLittleEndianInt32: _versionSpecificAttributes];
[stream writeLittleEndianInt32: 0xFFFFFFFF];
size += (4 + (6 * 2) + (3 * 4) + (5 * 2) + (2 * 4));
[stream writeString: _fileName];
size += (uint64_t)_fileName.UTF8StringLength;
[stream writeLittleEndianInt16: OF_ZIP_ARCHIVE_ENTRY_EXTRA_FIELD_ZIP64];
[stream writeLittleEndianInt16: 28];
[stream writeLittleEndianInt64: _uncompressedSize];
[stream writeLittleEndianInt64: _compressedSize];
[stream writeLittleEndianInt64: _localFileHeaderOffset];
[stream writeLittleEndianInt32: _startDiskNumber];
size += (2 * 2) + (3 * 8) + 4;
|
|
|
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
|
[stream writeLittleEndianInt32: _versionSpecificAttributes];
[stream writeLittleEndianInt32: 0xFFFFFFFF];
size += (4 + (6 * 2) + (3 * 4) + (5 * 2) + (2 * 4));
[stream writeString: _fileName];
size += (uint64_t)_fileName.UTF8StringLength;
[stream writeLittleEndianInt16: OFZIPArchiveEntryExtraFieldTagZIP64];
[stream writeLittleEndianInt16: 28];
[stream writeLittleEndianInt64: _uncompressedSize];
[stream writeLittleEndianInt64: _compressedSize];
[stream writeLittleEndianInt64: _localFileHeaderOffset];
[stream writeLittleEndianInt32: _startDiskNumber];
size += (2 * 2) + (3 * 8) + 4;
|