File: ZipConstants.cs

package info (click to toggle)
mono 4.6.2.7+dfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 778,148 kB
  • ctags: 914,052
  • sloc: cs: 5,779,509; xml: 2,773,713; ansic: 432,645; sh: 14,749; makefile: 12,361; perl: 2,488; python: 1,434; cpp: 849; asm: 531; sql: 95; sed: 16; php: 1
file content (465 lines) | stat: -rw-r--r-- 13,195 bytes parent folder | download
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
// ZipConstants.cs
//
// Copyright (C) 2001 Mike Krueger
// Copyright (C) 2004 John Reilly
//
// This file was translated from java, it was part of the GNU Classpath
// Copyright (C) 2001 Free Software Foundation, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library.  Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
// 
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent
// modules, and to copy and distribute the resulting executable under
// terms of your choice, provided that you also meet, for each linked
// independent module, the terms and conditions of the license of that
// module.  An independent module is a module which is not derived from
// or based on this library.  If you modify this library, you may extend
// this exception to your version of the library, but you are not
// obligated to do so.  If you do not wish to do so, delete this
// exception statement from your version.

using System;
using System.Text;

namespace ICSharpCode.SharpZipLib.Zip 
{
	
	/// <summary>
	/// The kind of compression used for an entry in an archive
	/// </summary>
	public enum CompressionMethod
	{
		/// <summary>
		/// A direct copy of the file contents is held in the archive
		/// </summary>
		Stored     = 0,
		
		/// <summary>
		/// Common Zip compression method using a sliding dictionary 
		/// of up to 32KB and secondary compression from Huffman/Shannon-Fano trees
		/// </summary>
		Deflated   = 8,
		
		/// <summary>
		/// An extension to deflate with a 64KB window. Not supported by #Zip
		/// </summary>
		Deflate64  = 9,
		
		/// <summary>
		/// Not supported by #Zip
		/// </summary>
		BZip2      = 11,
		
		/// <summary>
		/// WinZip special for AES encryption, Not supported by #Zip
		/// </summary>
		WinZipAES  = 99,
		
	}
	
	/// <summary>
	/// Defines the contents of the general bit flags field for an archive entry.
	/// </summary>
	[Flags]
	enum GeneralBitFlags : int
	{
		/// <summary>
		/// If set indicates that the file is encrypted
		/// </summary>
		Encrypted         = 0x0001,
		/// <summary>
		/// Two bits defining the compression method (only for Method 6 Imploding and 8,9 Deflating)
		/// </summary>
		Method            = 0x0006,
		/// <summary>
		/// If set a trailing data desciptor is appended to the entry data
		/// </summary>
		Descriptor        = 0x0008,
		Reserved          = 0x0010,
		/// <summary>
		/// If set indicates the file contains Pkzip compressed patched data.
		/// </summary>
		Patched           = 0x0020,
		/// <summary>
		/// If set strong encryption has been used for this entry.
		/// </summary>
		StrongEncryption  = 0x0040,
		/// <summary>
		/// Reserved by PKWare for enhanced compression.
		/// </summary>
		EnhancedCompress  = 0x1000,
		/// <summary>
		/// If set indicates that values in the local header are masked to hide
		/// their actual values.
		/// </summary>
		/// <remarks>
		/// Used when encrypting ht ecentral directory contents.
		/// </remarks>
		HeaderMasked      = 0x2000
	}
	
	/// <summary>
	/// This class contains constants used for Zip format files
	/// </summary>
	public sealed class ZipConstants
	{
		/// <summary>
		/// The version made by field for entries in the central header when created by this library
		/// </summary>
		/// <remarks>
		/// This is also the Zip version for the library when comparing against the version required to extract
		/// for an entry.  See <see cref="ZipInputStream.CanDecompressEntry">ZipInputStream.CanDecompressEntry</see>.
		/// </remarks>
		public const int VERSION_MADE_BY = 20;
		
		/// <summary>
		/// The minimum version required to support strong encryption
		/// </summary>
		public const int VERSION_STRONG_ENCRYPTION = 50;
		
		// The local entry header
		
		/// <summary>
		/// Size of local entry header (excluding variable length fields at end)
		/// </summary>
		public const int LOCHDR = 30;
		
		/// <summary>
		/// Signature for local entry header
		/// </summary>
		public const int LOCSIG = 'P' | ('K' << 8) | (3 << 16) | (4 << 24);

		/// <summary>
		/// Offset of version to extract in local entry header
		/// </summary>		
		public const int LOCVER =  4;
		
		/// <summary>
		/// Offset of general purpose flags in local entry header
		/// </summary>
		public const int LOCFLG =  6;
		
		/// <summary>
		/// Offset of compression method in local entry header
		/// </summary>
		public const int LOCHOW =  8;
		
		/// <summary>
		/// Offset of last mod file time + date in local entry header
		/// </summary>
		public const int LOCTIM = 10;
		
		/// <summary>
		/// Offset of crc-32 in local entry header
		/// </summary>
		public const int LOCCRC = 14;
		
		/// <summary>
		/// Offset of compressed size in local entry header
		/// </summary>
		public const int LOCSIZ = 18;
		
		/// <summary>
		/// Offset of uncompressed size in local entry header
		/// </summary>
		public const int LOCLEN = 22;
		
		/// <summary>
		/// Offset of file name length in local entry header
		/// </summary>
		public const int LOCNAM = 26;
		
		/// <summary>
		/// Offset of extra field length in local entry header
		/// </summary>
		public const int LOCEXT = 28;

		
		/// <summary>
		/// Signature for spanning entry
		/// </summary>
		public const int SPANNINGSIG = 'P' | ('K' << 8) | (7 << 16) | (8 << 24);
		
		/// <summary>
		/// Signature for temporary spanning entry
		/// </summary>
		public const int SPANTEMPSIG = 'P' | ('K' << 8) | ('0' << 16) | ('0' << 24);
		
		/// <summary>
		/// Signature for data descriptor
		/// </summary>
		/// <remarks>
		/// This is only used where the length, Crc, or compressed size isnt known when the
		/// entry is created and the output stream doesnt support seeking.
		/// The local entry cannot be 'patched' with the correct values in this case
		/// so the values are recorded after the data prefixed by this header, as well as in the central directory.
		/// </remarks>
		public const int EXTSIG = 'P' | ('K' << 8) | (7 << 16) | (8 << 24);
		
		/// <summary>
		/// Size of data descriptor
		/// </summary>
		public const int EXTHDR = 16;
		
		/// <summary>
		/// Offset of crc-32 in data descriptor
		/// </summary>
		public const int EXTCRC =  4;
		
		/// <summary>
		/// Offset of compressed size in data descriptor
		/// </summary>
		public const int EXTSIZ =  8;
		
		/// <summary>
		/// Offset of uncompressed length in data descriptor
		/// </summary>
		public const int EXTLEN = 12;
		
		
		/// <summary>
		/// Signature for central header
		/// </summary>
		public const int CENSIG = 'P' | ('K' << 8) | (1 << 16) | (2 << 24);
		
		/// <summary>
		/// Size of central header entry
		/// </summary>
		public const int CENHDR = 46;
		
		/// <summary>
		/// Offset of version made by in central file header
		/// </summary>
		public const int CENVEM =  4;
		
		/// <summary>
		/// Offset of version needed to extract in central file header
		/// </summary>
		public const int CENVER =  6;
		
		/// <summary>
		/// Offset of general purpose bit flag in central file header
		/// </summary>
		public const int CENFLG =  8;
		
		/// <summary>
		/// Offset of compression method in central file header
		/// </summary>
		public const int CENHOW = 10;
		
		/// <summary>
		/// Offset of time/date in central file header
		/// </summary>
		public const int CENTIM = 12;
		
		/// <summary>
		/// Offset of crc-32 in central file header
		/// </summary>
		public const int CENCRC = 16;
		
		/// <summary>
		/// Offset of compressed size in central file header
		/// </summary>
		public const int CENSIZ = 20;
		
		/// <summary>
		/// Offset of uncompressed size in central file header
		/// </summary>
		public const int CENLEN = 24;
		
		/// <summary>
		/// Offset of file name length in central file header
		/// </summary>
		public const int CENNAM = 28;
		
		/// <summary>
		/// Offset of extra field length in central file header
		/// </summary>
		public const int CENEXT = 30;
		
		/// <summary>
		/// Offset of file comment length in central file header
		/// </summary>
		public const int CENCOM = 32;
		
		/// <summary>
		/// Offset of disk start number in central file header
		/// </summary>
		public const int CENDSK = 34;
		
		/// <summary>
		/// Offset of internal file attributes in central file header
		/// </summary>
		public const int CENATT = 36;
		
		/// <summary>
		/// Offset of external file attributes in central file header
		/// </summary>
		public const int CENATX = 38;
		
		/// <summary>
		/// Offset of relative offset of local header in central file header
		/// </summary>
		public const int CENOFF = 42;
		
		
		/// <summary>
		/// Signature for Zip64 central file header
		/// </summary>
		public const int CENSIG64 = 'P' | ('K' << 8) | (6 << 16) | (6 << 24);
		
		
		
		/// <summary>
		/// Central header digitial signature
		/// </summary>
		public const int CENDIGITALSIG = 'P' | ('K' << 8) | (5 << 16) | (5 << 24);
		
		
		// The entries at the end of central directory
		
		/// <summary>
		/// End of central directory record signature
		/// </summary>
		public const int ENDSIG = 'P' | ('K' << 8) | (5 << 16) | (6 << 24);
		
		/// <summary>
		/// Size of end of central record (excluding variable fields)
		/// </summary>
		public const int ENDHDR = 22;
		
		// The following two fields are missing in SUN JDK
		
		/// <summary>
		/// Offset of number of this disk
		/// </summary>
		public const int ENDNRD =  4;
		
		/// <summary>
		/// Offset of number of disk with start of central directory
		/// </summary>
		public const int ENDDCD =  6;
		
		/// <summary>
		/// Offset of number of entries in the central directory of this disk
		/// </summary>
		public const int ENDSUB =  8;
		
		/// <summary>
		/// Offset of total number of entries in the central directory
		/// </summary>
		public const int ENDTOT = 10;
		
		/// <summary>
		/// Offset of size of central directory
		/// </summary>
		public const int ENDSIZ = 12;
		
		/// <summary>
		/// Offset of offset of start of central directory with respect to starting disk number
		/// </summary>
		public const int ENDOFF = 16;
		
		/// <summary>
		/// Offset of ZIP file comment length
		/// </summary>
		public const int ENDCOM = 20;
		
		/// <summary>
		/// Size of cryptographic header stored before entry data
		/// </summary>
		public const int CRYPTO_HEADER_SIZE = 12;

		
#if !COMPACT_FRAMEWORK

		static int defaultCodePage = 0;
		
		/// <summary>
		/// Default encoding used for string conversion.  0 gives the default system Ansi code page.
		/// Dont use unicode encodings if you want to be Zip compatible!
		/// Using the default code page isnt the full solution neccessarily
		/// there are many variable factors, codepage 850 is often a good choice for
		/// European users, however be careful about compatability.
		/// </summary>
		public static int DefaultCodePage {
			get {
				return defaultCodePage; 
			}
			set {
				defaultCodePage = value; 
			}
		}
#endif

		/// <summary>
		/// Convert a portion of a byte array to a string.
		/// </summary>		
		/// <param name="data">
		/// Data to convert to string
		/// </param>
		/// <param name="length">
		/// Number of bytes to convert starting from index 0
		/// </param>
		/// <returns>
		/// data[0]..data[length - 1] converted to a string
		/// </returns>
		public static string ConvertToString(byte[] data, int length)
		{
#if COMPACT_FRAMEWORK
			return Encoding.ASCII.GetString(data, 0, length);
#else
			return Encoding.GetEncoding(DefaultCodePage).GetString(data, 0, length);
#endif
		}
	
		/// <summary>
		/// Convert byte array to string
		/// </summary>
		/// <param name="data">
		/// Byte array to convert
		/// </param>
		/// <returns>
		/// <paramref name="data">data</paramref>converted to a string
		/// </returns>
		public static string ConvertToString(byte[] data)
		{
			return ConvertToString(data, data.Length);
		}

		/// <summary>
		/// Convert a string to a byte array
		/// </summary>
		/// <param name="str">
		/// String to convert to an array
		/// </param>
		/// <returns>Converted array</returns>
		public static byte[] ConvertToArray(string str)
		{
#if COMPACT_FRAMEWORK
			return Encoding.ASCII.GetBytes(str);
#else
			return Encoding.GetEncoding(DefaultCodePage).GetBytes(str);
#endif
		}
	}
}