Mercurial > projects > ldc

comparison tango/tango/io/archive/Zip.d @ 132:1700239cab2e trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r136] MAJOR UNSTABLE UPDATE!!! Initial commit after moving to Tango instead of Phobos. Lots of bugfixes... This build is not suitable for most things.
author lindquist
date Fri, 11 Jan 2008 17:57:40 +0100
parents
children
comparison
equal deleted inserted replaced
131:5825d48b27d1 132:1700239cab2e
1 /*******************************************************************************
2 *
3 * copyright: Copyright © 2007 Daniel Keep. All rights reserved.
4 *
5 * license: BSD style: $(LICENSE)
6 *
7 * version: Initial release: December 2007
8 *
9 * author: Daniel Keep
10 *
11 ******************************************************************************/
12
13 module tango.io.archive.Zip;
14
15 /*
16
17 TODO
18 ====
19
20 * Disable UTF encoding until I've worked out what version of Zip that's
21 related to... (actually; it's entirely possible that's it's merely a
22 *proposal* at the moment.) (*Done*)
23
24 * Make ZipEntry safe: make them aware that their creating reader has been
25 destroyed.
26
27 */
28
29 import tango.core.ByteSwap : ByteSwap;
30 import tango.io.Buffer : Buffer;
31 import tango.io.FileConduit : FileConduit;
32 import tango.io.FilePath : FilePath, PathView;
33 import tango.io.MappedBuffer : MappedBuffer;
34 import tango.io.compress.ZlibStream : ZlibInput, ZlibOutput;
35 import tango.io.digest.Crc32 : Crc32;
36 import tango.io.model.IConduit : IConduit, InputStream, OutputStream;
37 import tango.io.stream.DigestStream : DigestInput;
38 import tango.time.Time : Time, TimeSpan;
39 import tango.time.WallClock : WallClock;
40 import tango.time.chrono.Gregorian : Gregorian;
41
42 import Integer = tango.text.convert.Integer;
43
44 debug(Zip) import tango.io.Stdout : Stderr;
45
46 //////////////////////////////////////////////////////////////////////////////
47 //////////////////////////////////////////////////////////////////////////////
48 //
49 // Implementation crap
50 //
51 // Why is this here, you ask? Because of bloody DMD forward reference bugs.
52 // For pete's sake, Walter, FIX THEM, please!
53 //
54 // To skip to the actual user-visible stuff, search for "Shared stuff".
55
56 private
57 {
58
59 //////////////////////////////////////////////////////////////////////////////
60 //////////////////////////////////////////////////////////////////////////////
61 //
62 // LocalFileHeader
63 //
64
65 align(1)
66 struct LocalFileHeaderData
67 {
68 ushort extract_version = ushort.max;
69 ushort general_flags = 0;
70 ushort compression_method = 0;
71 ushort modification_file_time = 0;
72 ushort modification_file_date = 0;
73 uint crc_32 = 0; // offsetof = 10
74 uint compressed_size = 0;
75 uint uncompressed_size = 0;
76 ushort file_name_length = 0;
77 ushort extra_field_length = 0;
78
79 debug(Zip) void dump()
80 {
81 Stderr
82 ("LocalFileHeader.Data {")("\n")
83 (" extract_version = ")(extract_version)("\n")
84 (" general_flags = ")(general_flags)("\n")
85 (" compression_method = ")(compression_method)("\n")
86 (" modification_file_time = ")(modification_file_time)("\n")
87 (" modification_file_date = ")(modification_file_date)("\n")
88 (" crc_32 = ")(crc_32)("\n")
89 (" compressed_size = ")(compressed_size)("\n")
90 (" uncompressed_size = ")(uncompressed_size)("\n")
91 (" file_name_length = ")(file_name_length)("\n")
92 (" extra_field_length = ")(extra_field_length)("\n")
93 ("}").newline;
94 }
95 }
96
97 struct LocalFileHeader
98 {
99 const uint signature = 0x04034b50;
100
101 alias LocalFileHeaderData Data;
102 Data data;
103 static assert( Data.sizeof == 26 );
104
105 char[] file_name;
106 ubyte[] extra_field;
107
108 void[] data_arr()
109 {
110 return (&data)[0..1];
111 }
112
113 void put(OutputStream output)
114 {
115 // Make sure var-length fields will fit.
116 if( file_name.length > ushort.max )
117 ZipException.fntoolong;
118
119 if( extra_field.length > ushort.max )
120 ZipException.eftoolong;
121
122 // Encode filename
123 auto file_name = utf8_to_cp437(this.file_name);
124 scope(exit) if( file_name !is cast(ubyte[])this.file_name )
125 delete file_name;
126
127 if( file_name is null )
128 ZipException.fnencode;
129
130 // Update lengths in data
131 Data data = this.data;
132 data.file_name_length = file_name.length;
133 data.extra_field_length = extra_field.length;
134
135 // Do it
136 version( BigEndian ) swapAll(data);
137 writeExact(output, (&data)[0..1]);
138 writeExact(output, file_name);
139 writeExact(output, extra_field);
140 }
141
142 void fill(InputStream src)
143 {
144 readExact(src, data_arr);
145 version( BigEndian ) swapAll(data);
146
147 //debug(Zip) data.dump;
148
149 auto tmp = new ubyte[data.file_name_length];
150 readExact(src, tmp);
151 file_name = cp437_to_utf8(tmp);
152 if( cast(char*) tmp.ptr !is file_name.ptr ) delete tmp;
153
154 extra_field = new ubyte[data.extra_field_length];
155 readExact(src, extra_field);
156 }
157
158 /*
159 * This method will check to make sure that the local and central headers
160 * are the same; if they're not, then that indicates that the archive is
161 * corrupt.
162 */
163 bool agrees_with(FileHeader h)
164 {
165 if( data.extract_version != h.data.extract_version
166 || data.general_flags != h.data.general_flags
167 || data.compression_method != h.data.compression_method
168 || data.modification_file_time != h.data.modification_file_time
169 || data.modification_file_date != h.data.modification_file_date
170 || data.crc_32 != h.data.crc_32
171 || data.compressed_size != h.data.compressed_size
172 || data.uncompressed_size != h.data.uncompressed_size
173 || file_name != h.file_name
174 || extra_field != h.extra_field )
175 return false;
176
177 // We need a separate check for the sizes and crc32, since these will
178 // be zero if a trailing descriptor was used.
179 if( !h.usingDataDescriptor && (
180 data.crc_32 != h.data.crc_32
181 || data.compressed_size != h.data.compressed_size
182 || data.uncompressed_size != h.data.uncompressed_size ) )
183 return false;
184
185 return true;
186 }
187 }
188
189 //////////////////////////////////////////////////////////////////////////////
190 //////////////////////////////////////////////////////////////////////////////
191 //
192 // FileHeader
193 //
194
195 align(1)
196 struct FileHeaderData
197 {
198 ubyte zip_version;
199 ubyte file_attribute_type;
200 ushort extract_version;
201 ushort general_flags;
202 ushort compression_method;
203 ushort modification_file_time;
204 ushort modification_file_date;
205 uint crc_32;
206 uint compressed_size;
207 uint uncompressed_size;
208 ushort file_name_length;
209 ushort extra_field_length;
210 ushort file_comment_length;
211 ushort disk_number_start;
212 ushort internal_file_attributes = 0;
213 uint external_file_attributes = 0;
214 int relative_offset_of_local_header;
215
216 debug(Zip) void dump()
217 {
218 Stderr
219 ("FileHeader.Data {\n")
220 (" zip_version = ")(zip_version)("\n")
221 (" file_attribute_type = ")(file_attribute_type)("\n")
222 (" extract_version = ")(extract_version)("\n")
223 (" general_flags = ")(general_flags)("\n")
224 (" compression_method = ")(compression_method)("\n")
225 (" modification_file_time = ")(modification_file_time)("\n")
226 (" modification_file_date = ")(modification_file_date)("\n")
227 (" crc_32 = ")(crc_32)("\n")
228 (" compressed_size = ")(compressed_size)("\n")
229 (" uncompressed_size = ")(uncompressed_size)("\n")
230 (" file_name_length = ")(file_name_length)("\n")
231 (" extra_field_length = ")(extra_field_length)("\n")
232 (" file_comment_length = ")(file_comment_length)("\n")
233 (" disk_number_start = ")(disk_number_start)("\n")
234 (" internal_file_attributes = ")(internal_file_attributes)("\n")
235 (" external_file_attributes = ")(external_file_attributes)("\n")
236 (" relative_offset_of_local_header = ")(relative_offset_of_local_header)
237 ("\n")
238 ("}").newline;
239 }
240
241 void fromLocal(LocalFileHeader.Data data)
242 {
243 extract_version = data.extract_version;
244 general_flags = data.general_flags;
245 compression_method = data.compression_method;
246 modification_file_time = data.modification_file_time;
247 modification_file_date = data.modification_file_date;
248 crc_32 = data.crc_32;
249 compressed_size = data.compressed_size;
250 uncompressed_size = data.uncompressed_size;
251 file_name_length = data.file_name_length;
252 extra_field_length = data.extra_field_length;
253 }
254 }
255
256 struct FileHeader
257 {
258 const uint signature = 0x02014b50;
259
260 alias FileHeaderData Data;
261 Data* data;
262 static assert( Data.sizeof == 42 );
263
264 char[] file_name;
265 ubyte[] extra_field;
266 char[] file_comment;
267
268 bool usingDataDescriptor()
269 {
270 return !!(data.general_flags & 1<<3);
271 }
272
273 uint compressionOptions()
274 {
275 return (data.general_flags >> 1) & 0b11;
276 }
277
278 bool usingUtf8()
279 {
280 //return !!(data.general_flags & 1<<11);
281 return false;
282 }
283
284 void[] data_arr()
285 {
286 return (cast(void*)data)[0 .. Data.sizeof];
287 }
288
289 void put(OutputStream output)
290 {
291 // Make sure the var-length fields will fit.
292 if( file_name.length > ushort.max )
293 ZipException.fntoolong;
294
295 if( extra_field.length > ushort.max )
296 ZipException.eftoolong;
297
298 if( file_comment.length > ushort.max )
299 ZipException.cotoolong;
300
301 // encode the filename and comment
302 auto file_name = utf8_to_cp437(this.file_name);
303 scope(exit) if( file_name !is cast(ubyte[])this.file_name )
304 delete file_name;
305 auto file_comment = utf8_to_cp437(this.file_comment);
306 scope(exit) if( file_comment !is cast(ubyte[])this.file_comment )
307 delete file_comment;
308
309 if( file_name is null )
310 ZipException.fnencode;
311
312 if( file_comment is null && this.file_comment !is null )
313 ZipException.coencode;
314
315 // Update the lengths
316 Data data = *(this.data);
317 data.file_name_length = file_name.length;
318 data.extra_field_length = extra_field.length;
319 data.file_comment_length = file_comment.length;
320
321 // Ok; let's do this!
322 version( BigEndian ) swapAll(data);
323 writeExact(output, (&data)[0..1]);
324 writeExact(output, file_name);
325 writeExact(output, extra_field);
326 writeExact(output, file_comment);
327 }
328
329 long map(void[] src)
330 {
331 //debug(Zip) Stderr.formatln("FileHeader.map([0..{}])",src.length);
332
333 auto old_ptr = src.ptr;
334
335 data = cast(Data*) src.ptr;
336 src = src[Data.sizeof..$];
337 version( BigEndian ) swapAll(*data);
338
339 //debug(Zip) data.dump;
340
341 char[] function(ubyte[]) conv_fn;
342 if( usingUtf8 )
343 conv_fn = &cp437_to_utf8;
344 else
345 conv_fn = &utf8_to_utf8;
346
347 file_name = conv_fn(
348 cast(ubyte[]) src[0..data.file_name_length]);
349 src = src[data.file_name_length..$];
350
351 extra_field = cast(ubyte[]) src[0..data.extra_field_length];
352 src = src[data.extra_field_length..$];
353
354 file_comment = conv_fn(
355 cast(ubyte[]) src[0..data.file_comment_length]);
356 src = src[data.file_comment_length..$];
357
358 // Return how many bytes we've eaten
359 //debug(Zip) Stderr.formatln(" . used {} bytes", cast(long)(src.ptr - old_ptr));
360 return cast(long)(src.ptr - old_ptr);
361 }
362 }
363
364 //////////////////////////////////////////////////////////////////////////////
365 //////////////////////////////////////////////////////////////////////////////
366 //
367 // EndOfCDRecord
368 //
369
370 align(1)
371 struct EndOfCDRecordData
372 {
373 ushort disk_number = 0;
374 ushort disk_with_start_of_central_directory = 0;
375 ushort central_directory_entries_on_this_disk;
376 ushort central_directory_entries_total;
377 uint size_of_central_directory;
378 uint offset_of_start_of_cd_from_starting_disk;
379 ushort file_comment_length;
380
381 debug(Zip) void dump()
382 {
383 Stderr
384 .formatln("EndOfCDRecord.Data {}","{")
385 .formatln(" disk_number = {}", disk_number)
386 .formatln(" disk_with_start_of_central_directory = {}",
387 disk_with_start_of_central_directory)
388 .formatln(" central_directory_entries_on_this_disk = {}",
389 central_directory_entries_on_this_disk)
390 .formatln(" central_directory_entries_total = {}",
391 central_directory_entries_total)
392 .formatln(" size_of_central_directory = {}",
393 size_of_central_directory)
394 .formatln(" offset_of_start_of_cd_from_starting_disk = {}",
395 offset_of_start_of_cd_from_starting_disk)
396 .formatln(" file_comment_length = {}", file_comment_length)
397 .formatln("}");
398 }
399 }
400
401 struct EndOfCDRecord
402 {
403 const uint signature = 0x06054b50;
404
405 alias EndOfCDRecordData Data;
406 Data data;
407 static assert( data.sizeof == 18 );
408
409 char[] file_comment;
410
411 void[] data_arr()
412 {
413 return (cast(void*)&data)[0 .. data.sizeof];
414 }
415
416 void put(OutputStream output)
417 {
418 // Set up the comment; check length, encode
419 if( file_comment.length > ushort.max )
420 ZipException.cotoolong;
421
422 auto file_comment = utf8_to_cp437(this.file_comment);
423 scope(exit) if( file_comment !is cast(ubyte[])this.file_comment )
424 delete file_comment;
425
426 // Set up data block
427 Data data = this.data;
428 data.file_comment_length = file_comment.length;
429
430 version( BigEndian ) swapAll(data);
431 writeExact(output, (&data)[0..1]);
432 }
433
434 void fill(void[] src)
435 {
436 //Stderr.formatln("EndOfCDRecord.fill([0..{}])",src.length);
437
438 auto _data = data_arr;
439 _data[] = src[0.._data.length];
440 src = src[_data.length..$];
441 version( BigEndian ) swapAll(data);
442
443 //data.dump;
444
445 file_comment = cast(char[]) src[0..data.file_comment_length].dup;
446 }
447 }
448
449 // End of implementation crap
450 }
451
452 //////////////////////////////////////////////////////////////////////////////
453 //////////////////////////////////////////////////////////////////////////////
454 //
455 // Shared stuff
456
457 public
458 {
459 /**
460 * This enumeration denotes the kind of compression used on a file.
461 */
462 enum Method
463 {
464 /// No compression should be used.
465 Store,
466 /// Deflate compression.
467 Deflate,
468 /**
469 * This is a special value used for unsupported or unrecognised
470 * compression methods. This value is only used internally.
471 */
472 Unsupported
473 }
474 }
475
476 private
477 {
478 const ushort ZIP_VERSION = 20;
479 const ushort MAX_EXTRACT_VERSION = 20;
480
481 /* compression flags
482 uses trailing descriptor |
483 utf-8 encoding | |
484 ^ ^ /\ */
485 const ushort SUPPORTED_FLAGS = 0b00_0_0_0_0000_0_0_0_1_11_0;
486 const ushort UNSUPPORTED_FLAGS = ~SUPPORTED_FLAGS;
487
488 Method toMethod(ushort method)
489 {
490 switch( method )
491 {
492 case 0: return Method.Store;
493 case 8: return Method.Deflate;
494 default: return Method.Unsupported;
495 }
496 }
497
498 ushort fromMethod(Method method)
499 {
500 switch( method )
501 {
502 case Method.Store: return 0;
503 case Method.Deflate: return 8;
504 default:
505 assert(false, "unsupported compression method");
506 }
507 }
508
509 /* NOTE: This doesn't actually appear to work. Using the default magic
510 * number with Tango's Crc32 digest works, however.
511 */
512 //const CRC_MAGIC = 0xdebb20e3u;
513 }
514
515 //////////////////////////////////////////////////////////////////////////////
516 //////////////////////////////////////////////////////////////////////////////
517 //
518 // ZipReader
519
520 interface ZipReader
521 {
522 bool streamed();
523 void close();
524 bool more();
525 ZipEntry get();
526 ZipEntry get(ZipEntry);
527 int opApply(int delegate(ref ZipEntry));
528 }
529
530 //////////////////////////////////////////////////////////////////////////////
531 //////////////////////////////////////////////////////////////////////////////
532 //
533 // ZipWriter
534
535 interface ZipWriter
536 {
537 void finish();
538 void putFile(ZipEntryInfo info, char[] path);
539 void putFile(ZipEntryInfo info, PathView path);
540 void putStream(ZipEntryInfo info, InputStream source);
541 void putEntry(ZipEntryInfo info, ZipEntry entry);
542 void putData(ZipEntryInfo info, void[] data);
543 Method method();
544 Method method(Method);
545 }
546
547 //////////////////////////////////////////////////////////////////////////////
548 //////////////////////////////////////////////////////////////////////////////
549 //
550 // ZipBlockReader
551
552 /**
553 * The ZipBlockReader class is used to parse a Zip archive. It exposes the
554 * contents of the archive via an iteration interface. For instance, to loop
555 * over all files in an archive, one can use either
556 *
557 * -----
558 * foreach( entry ; reader )
559 * ...
560 * -----
561 *
562 * Or
563 *
564 * -----
565 * while( reader.more )
566 * {
567 * auto entry = reader.get;
568 * ...
569 * }
570 * -----
571 *
572 * See the ZipEntry class for more information on the contents of entries.
573 *
574 * Note that this class can only be used with input sources which can be
575 * freely seeked. Also note that you may open a ZipEntry instance produced by
576 * this reader at any time until the ZipReader that created it is closed.
577 */
578 class ZipBlockReader : ZipReader
579 {
580 /**
581 * Creates a ZipBlockReader using the specified file on the local
582 * filesystem.
583 */
584 this(char[] path)
585 {
586 this(FilePath(path));
587 }
588
589 /// ditto
590 this(PathView path)
591 {
592 file_source = new FileConduit(path);
593 this(file_source);
594 }
595
596 version( none )
597 {
598 /**
599 * Creates a ZipBlockReader using the provided FileConduit instance. Where
600 * possible, the conduit will be wrapped in a memory-mapped buffer for
601 * optimum performance. If you do not want the FileConduit memory-mapped,
602 * either cast it to an InputStream first, or pass source.input to the
603 * constructor.
604 */
605 this(FileConduit source)
606 {
607 // BUG: MappedBuffer doesn't implement IConduit.Seek
608 //mm_source = new MappedBuffer(source);
609 //this(mm_source);
610 this(source.input);
611 }
612 }
613
614 /**
615 * Creates a ZipBlockReader using the provided InputStream. Please note
616 * that this InputStream must also implement the IConduit.Seek interface.
617 */
618 this(InputStream source)
619 in
620 {
621 assert( cast(IConduit.Seek) source, "source stream must be seekable" );
622 }
623 body
624 {
625 this.source = source;
626 this.seeker = cast(IConduit.Seek) source;
627 }
628
629 bool streamed() { return false; }
630
631 /**
632 * Closes the reader, and releases all resources. After this operation,
633 * all ZipEntry instances created by this ZipReader are invalid and should
634 * not be used.
635 */
636 void close()
637 {
638 state = State.Done;
639 source = null;
640 seeker = null;
641 delete headers;
642 delete cd_data;
643
644 if( file_source !is null ) delete file_source;
645 if( mm_source !is null ) delete mm_source;
646 }
647
648 /**
649 * Returns true if and only if there are additional files in the archive
650 * which have not been read via the get method. This returns true before
651 * the first call to get (assuming the opened archive is non-empty), and
652 * false after the last file has been accessed.
653 */
654 bool more()
655 {
656 switch( state )
657 {
658 case State.Init:
659 read_cd;
660 assert( state == State.Open );
661 return more;
662
663 case State.Open:
664 return (current_index < headers.length);
665
666 case State.Done:
667 return false;
668 }
669 }
670
671 /**
672 * Retrieves the next file from the archive. Note that although this does
673 * perform IO operations, it will not read the contents of the file.
674 *
675 * The optional reuse argument can be used to instruct the reader to reuse
676 * an existing ZipEntry instance. If passed a null reference, it will
677 * create a new ZipEntry instance.
678 */
679 ZipEntry get()
680 {
681 if( !more )
682 ZipExhaustedException();
683
684 return new ZipEntry(headers[current_index++], &open_file);
685 }
686
687 /// ditto
688 ZipEntry get(ZipEntry reuse)
689 {
690 if( !more )
691 ZipExhaustedException();
692
693 if( reuse is null )
694 return new ZipEntry(headers[current_index++], &open_file);
695 else
696 return reuse.reset(headers[current_index++], &open_file);
697 }
698
699 /**
700 * This is used to iterate over the contents of an archive using a foreach
701 * loop. Please note that the iteration will reuse the ZipEntry instance
702 * passed to your loop. If you wish to keep the instance and re-use it
703 * later, you $(B must) use the dup member to create a copy.
704 */
705 int opApply(int delegate(ref ZipEntry) dg)
706 {
707 int result = 0;
708 ZipEntry entry;
709
710 while( more )
711 {
712 entry = get(entry);
713
714 result = dg(entry);
715 if( result )
716 break;
717 }
718
719 if( entry !is null )
720 delete entry;
721
722 return result;
723 }
724
725 private:
726 InputStream source;
727 IConduit.Seek seeker;
728
729 enum State { Init, Open, Done }
730 State state;
731 size_t current_index = 0;
732 FileHeader[] headers;
733
734 // These should be killed when the reader is closed.
735 ubyte[] cd_data;
736 FileConduit file_source = null;
737 MappedBuffer mm_source = null;
738
739 /*
740 * This function will read the contents of the central directory. Split
741 * or spanned archives aren't supported.
742 */
743 void read_cd()
744 in
745 {
746 assert( state == State.Init );
747 assert( headers is null );
748 assert( cd_data is null );
749 }
750 out
751 {
752 assert( state == State.Open );
753 assert( headers !is null );
754 assert( cd_data !is null );
755 assert( current_index == 0 );
756 }
757 body
758 {
759 //Stderr.formatln("ZipReader.read_cd()");
760
761 // First, we need to locate the end of cd record, so that we know
762 // where the cd itself is, and how big it is.
763 auto eocdr = read_eocd_record;
764
765 // Now, make sure the archive is all in one file.
766 if( eocdr.data.disk_number !=
767 eocdr.data.disk_with_start_of_central_directory
768 || eocdr.data.central_directory_entries_on_this_disk !=
769 eocdr.data.central_directory_entries_total )
770 ZipNotSupportedException.spanned;
771
772 // Ok, read the whole damn thing in one go.
773 cd_data = new ubyte[eocdr.data.size_of_central_directory];
774 long cd_offset = eocdr.data.offset_of_start_of_cd_from_starting_disk;
775 seeker.seek(cd_offset, IConduit.Seek.Anchor.Begin);
776 readExact(source, cd_data);
777
778 // Cake. Now, we need to break it up into records.
779 headers = new FileHeader[
780 eocdr.data.central_directory_entries_total];
781
782 long cdr_offset = cd_offset;
783
784 // Ok, map the CD data into file headers.
785 foreach( i,ref header ; headers )
786 {
787 //Stderr.formatln(" . reading header {}...", i);
788
789 // Check signature
790 {
791 uint sig = (cast(uint[])(cd_data[0..4]))[0];
792 version( BigEndian ) swap(sig);
793 if( sig != FileHeader.signature )
794 ZipException.badsig("file header");
795 }
796
797 auto used = header.map(cd_data[4..$]);
798 cd_data = cd_data[4+used..$];
799
800 // Update offset for next record
801 cdr_offset += 4 /* for sig. */ + used;
802 }
803
804 // Done!
805 state = State.Open;
806 }
807
808 /*
809 * This will locate the end of CD record in the open stream.
810 *
811 * This code sucks, but that's because Zip sucks.
812 *
813 * Basically, the EOCD record is stuffed somewhere at the end of the file.
814 * In a brilliant move, the record is *variably sized*, which means we
815 * have to do a linear backwards search to find it.
816 *
817 * The header itself (including the signature) is at minimum 22 bytes
818 * long, plus anywhere between 0 and 2^16-1 bytes of comment. That means
819 * we need to read the last 2^16-1 + 22 bytes from the file, and look for
820 * the signature [0x50,0x4b,0x05,0x06] in [0 .. $-18].
821 *
822 * If we find the EOCD record, we'll return its contents. If we couldn't
823 * find it, we'll throw an exception.
824 */
825 EndOfCDRecord read_eocd_record()
826 in
827 {
828 assert( state == State.Init );
829 }
830 body
831 {
832 //Stderr.formatln("read_eocd_record()");
833
834 // Signature + record + max. comment length
835 const max_chunk_len = 4 + EndOfCDRecord.Data.sizeof + ushort.max;
836
837 auto file_len = seeker.seek(0, IConduit.Seek.Anchor.End);
838
839 // We're going to need min(max_chunk_len, file_len) bytes.
840 long chunk_len = max_chunk_len;
841 if( file_len < max_chunk_len )
842 chunk_len = file_len;
843 //Stderr.formatln(" . chunk_len = {}", chunk_len);
844
845 // Seek back and read in the chunk. Don't forget to clean up after
846 // ourselves.
847 seeker.seek(-chunk_len, IConduit.Seek.Anchor.End);
848 auto chunk_offset = seeker.seek(0, IConduit.Seek.Anchor.Current);
849 //Stderr.formatln(" . chunk_offset = {}", chunk_offset);
850 auto chunk = new ubyte[chunk_len];
851 scope(exit) delete chunk;
852 readExact(source, chunk);
853
854 // Now look for our magic number. Don't forget that on big-endian
855 // machines, we need to byteswap the value we're looking for.
856 version( BigEndian )
857 uint eocd_magic = swap(EndOfCDRecord.signature);
858 else
859 uint eocd_magic = EndOfCDRecord.signature;
860
861 size_t eocd_loc = -1;
862
863 for( size_t i=chunk_len-18; i>=0; --i )
864 {
865 if( *(cast(uint*)(chunk.ptr+i)) == eocd_magic )
866 {
867 // Found the bugger! Make sure we skip the signature (forgot
868 // to do that originally; talk about weird errors :P)
869 eocd_loc = i+4;
870 break;
871 }
872 }
873
874 // If we didn't find it, then we'll assume that this is not a valid
875 // archive.
876 if( eocd_loc == -1 )
877 ZipException.missingdir;
878
879 // Ok, so we found it; now what? Now we need to read the record
880 // itself in. eocd_loc is the offset within the chunk where the eocd
881 // record was found, so slice it out.
882 EndOfCDRecord eocdr;
883 eocdr.fill(chunk[eocd_loc..$]);
884
885 // Excellent. We're done here.
886 return eocdr;
887 }
888
889 /*
890 * Opens the specified file for reading. If the raw argument passed is
891 * true, then the file is *not* decompressed.
892 */
893 InputStream open_file(FileHeader header, bool raw)
894 {
895 // Check to make sure that we actually *can* open this file.
896 if( header.data.extract_version > MAX_EXTRACT_VERSION )
897 ZipNotSupportedException.zipver(header.data.extract_version);
898
899 if( header.data.general_flags & UNSUPPORTED_FLAGS )
900 ZipNotSupportedException.flags;
901
902 if( toMethod(header.data.compression_method) == Method.Unsupported )
903 ZipNotSupportedException.method(header.data.compression_method);
904
905 // Open a raw stream
906 InputStream stream = open_file_raw(header);
907
908 // If that's all they wanted, pass it back.
909 if( raw )
910 return stream;
911
912 // Next up, wrap in an appropriate decompression stream
913 switch( toMethod(header.data.compression_method) )
914 {
915 case Method.Store:
916 // Do nothing: \o/
917 break;
918
919 case Method.Deflate:
920 // Wrap in a zlib stream. -15 means to use a 32KB window, and
921 // not to look for the normal zlib header and trailer.
922 stream = new ZlibInput(stream, -15);
923 break;
924
925 default:
926 assert(false);
927 }
928
929 // We done, yo!
930 return stream;
931 }
932
933 /*
934 * Opens a file's raw input stream. Basically, this returns a slice of
935 * the archive's input stream.
936 */
937 InputStream open_file_raw(FileHeader header)
938 {
939 // Seek to and parse the local file header
940 seeker.seek(header.data.relative_offset_of_local_header,
941 IConduit.Seek.Anchor.Begin);
942
943 {
944 uint sig;
945 readExact(source, (&sig)[0..1]);
946 version( BigEndian ) swap(sig);
947 if( sig != LocalFileHeader.signature )
948 ZipException.badsig("local file header");
949 }
950
951 LocalFileHeader lheader; lheader.fill(source);
952
953 if( !lheader.agrees_with(header) )
954 ZipException.incons(header.file_name);
955
956 // Ok; get a slice stream for the file
957 return new SliceSeekInputStream(
958 source, seeker.seek(0, IConduit.Seek.Anchor.Current),
959 header.data.compressed_size);
960 }
961 }
962
963 //////////////////////////////////////////////////////////////////////////////
964 //////////////////////////////////////////////////////////////////////////////
965 //
966 // ZipBlockWriter
967
968 /**
969 * The ZipBlockWriter class is used to create a Zip archive. It uses a
970 * writing iterator interface.
971 *
972 * Note that this class can only be used with output streams which can be
973 * freely seeked.
974 */
975
976 class ZipBlockWriter : ZipWriter
977 {
978 /**
979 * Creates a ZipBlockWriter using the specified file on the local
980 * filesystem.
981 */
982 this(char[] path)
983 {
984 this(FilePath(path));
985 }
986
987 /// ditto
988 this(PathView path)
989 {
990 file_output = new FileConduit(path, FileConduit.WriteCreate);
991 this(file_output);
992 }
993
994 /**
995 * Creates a ZipBlockWriter using the provided OutputStream. Please note
996 * that this OutputStream must also implement the IConduit.Seek interface.
997 */
998 this(OutputStream output)
999 in
1000 {
1001 assert( output !is null );
1002 assert( (cast(IConduit.Seek) output) !is null );
1003 }
1004 body
1005 {
1006 this.output = output;
1007 this.seeker = cast(IConduit.Seek) output;
1008
1009 // Default to Deflate compression
1010 method = Method.Deflate;
1011 }
1012
1013 /**
1014 * Finalises the archive, writes out the central directory, and closes the
1015 * output stream.
1016 */
1017 void finish()
1018 {
1019 put_cd;
1020 output.close();
1021 output = null;
1022 seeker = null;
1023
1024 if( file_output !is null ) delete file_output;
1025 }
1026
1027 /**
1028 * Adds a file from the local filesystem to the archive.
1029 */
1030 void putFile(ZipEntryInfo info, char[] path)
1031 {
1032 putFile(info, FilePath(path));
1033 }
1034
1035 /// ditto
1036 void putFile(ZipEntryInfo info, PathView path)
1037 {
1038 scope file = new FileConduit(path);
1039 scope(exit) file.close();
1040 putStream(info, file);
1041 }
1042
1043 /**
1044 * Adds a file using the contents of the given InputStream to the archive.
1045 */
1046 void putStream(ZipEntryInfo info, InputStream source)
1047 {
1048 put_compressed(info, source);
1049 }
1050
1051 /**
1052 * Transfers a file from another archive into this archive. Note that
1053 * this method will not perform any compression: whatever compression was
1054 * applied to the file originally will be preserved.
1055 */
1056 void putEntry(ZipEntryInfo info, ZipEntry entry)
1057 {
1058 put_raw(info, entry);
1059 }
1060
1061 /**
1062 * Adds a file using the contents of the given array to the archive.
1063 */
1064 void putData(ZipEntryInfo info, void[] data)
1065 {
1066 //scope mc = new MemoryConduit(data);
1067 scope mc = new Buffer(data);
1068 scope(exit) mc.close;
1069 put_compressed(info, mc);
1070 }
1071
1072 /**
1073 * This property allows you to control what compression method should be
1074 * used for files being added to the archive.
1075 */
1076 Method method() { return _method; }
1077 Method method(Method v) { return _method = v; } /// ditto
1078
1079 private:
1080 OutputStream output;
1081 IConduit.Seek seeker;
1082 FileConduit file_output;
1083
1084 Method _method;
1085
1086 struct Entry
1087 {
1088 FileHeaderData data;
1089 long header_position;
1090 char[] filename;
1091 char[] comment;
1092 ubyte[] extra;
1093 }
1094 Entry[] entries;
1095
1096 void put_cd()
1097 {
1098 // check that there aren't too many CD entries
1099 if( entries.length > ushort.max )
1100 ZipException.toomanyentries;
1101
1102 auto cd_pos = seeker.seek(0, IConduit.Seek.Anchor.Current);
1103 if( cd_pos > uint.max )
1104 ZipException.toolong;
1105
1106 foreach( entry ; entries )
1107 {
1108 FileHeader header;
1109 header.data = &entry.data;
1110 header.file_name = entry.filename;
1111 header.extra_field = entry.extra;
1112 header.file_comment = entry.comment;
1113
1114 write(output, FileHeader.signature);
1115 header.put(output);
1116 }
1117
1118 auto cd_len = seeker.seek(0, IConduit.Seek.Anchor.Current) - cd_pos;
1119
1120 if( cd_len > uint.max )
1121 ZipException.cdtoolong;
1122
1123 {
1124 EndOfCDRecord eocdr;
1125 eocdr.data.central_directory_entries_on_this_disk =
1126 entries.length;
1127 eocdr.data.central_directory_entries_total = entries.length;
1128 eocdr.data.size_of_central_directory = cd_len;
1129 eocdr.data.offset_of_start_of_cd_from_starting_disk = cd_pos;
1130
1131 write(output, EndOfCDRecord.signature);
1132 eocdr.put(output);
1133 }
1134 }
1135
1136 void put_raw(ZipEntryInfo info, ZipEntry entry)
1137 {
1138 // Write out local file header
1139 LocalFileHeader.Data lhdata;
1140 auto chdata = entry.header.data;
1141 lhdata.extract_version = chdata.extract_version;
1142 lhdata.general_flags = chdata.general_flags;
1143 lhdata.compression_method = chdata.compression_method;
1144 lhdata.crc_32 = chdata.crc_32;
1145 lhdata.compressed_size = chdata.compressed_size;
1146 lhdata.uncompressed_size = chdata.uncompressed_size;
1147
1148 timeToDos(info.modified, lhdata.modification_file_time,
1149 lhdata.modification_file_date);
1150
1151 put_local_header(lhdata, info.name);
1152
1153 // Store comment
1154 entries[$-1].comment = info.comment;
1155
1156 // Output file contents
1157 {
1158 auto input = entry.open_raw;
1159 scope(exit) input.close;
1160 output.copy(input).flush();
1161 }
1162 }
1163
1164 void put_compressed(ZipEntryInfo info, InputStream source)
1165 {
1166 debug(Zip) Stderr.formatln("ZipBlockWriter.put_compressed()");
1167
1168 // Write out partial local file header
1169 auto header_pos = seeker.seek(0, IConduit.Seek.Anchor.Current);
1170 debug(Zip) Stderr.formatln(" . header for {} at {}", info.name, header_pos);
1171 put_local_header(info, _method);
1172
1173 // Store comment
1174 entries[$-1].comment = info.comment;
1175
1176 uint crc;
1177 uint compressed_size;
1178 uint uncompressed_size;
1179
1180 // Output file contents
1181 {
1182 // Input/output chains
1183 InputStream in_chain = source;
1184 OutputStream out_chain = new WrapSeekOutputStream(output);
1185
1186 // Count number of bytes coming in from the source file
1187 scope in_counter = new CounterInput(in_chain);
1188 in_chain = in_counter;
1189 scope(success) uncompressed_size = in_counter.count;
1190
1191 // Count the number of bytes going out to the archive
1192 scope out_counter = new CounterOutput(out_chain);
1193 out_chain = out_counter;
1194 scope(success) compressed_size = out_counter.count;
1195
1196 // Add crc
1197 scope crc_d = new Crc32(/*CRC_MAGIC*/);
1198 scope crc_s = new DigestInput(in_chain, crc_d);
1199 in_chain = crc_s;
1200 scope(success)
1201 {
1202 debug(Zip) Stderr.formatln(" . Success: storing CRC.");
1203 crc = crc_d.crc32Digest;
1204 }
1205
1206 // Add compression
1207 ZlibOutput compress;
1208 scope(exit) if( compress !is null ) delete compress;
1209
1210 switch( _method )
1211 {
1212 case Method.Store:
1213 break;
1214
1215 case Method.Deflate:
1216 compress = new ZlibOutput(out_chain,
1217 ZlibOutput.Level.init, -15);
1218 out_chain = compress;
1219 break;
1220 }
1221
1222 // All done.
1223 scope(exit) in_chain.close();
1224 scope(success) in_chain.clear();
1225 scope(exit) out_chain.close();
1226
1227 out_chain.copy(in_chain).flush;
1228
1229 debug(Zip) if( compress !is null )
1230 {
1231 Stderr.formatln(" . compressed to {} bytes", compress.written);
1232 }
1233
1234 debug(Zip) Stderr.formatln(" . wrote {} bytes", out_counter.count);
1235 debug(Zip) Stderr.formatln(" . contents written");
1236 }
1237
1238 debug(Zip) Stderr.formatln(" . CRC for \"{}\": 0x{:x8}", info.name, crc);
1239
1240 // Rewind, and patch the header
1241 auto final_pos = seeker.seek(0, IConduit.Seek.Anchor.Current);
1242 seeker.seek(header_pos);
1243 patch_local_header(crc, compressed_size, uncompressed_size);
1244
1245 // Seek back to the end of the file, and we're done!
1246 seeker.seek(final_pos);
1247 }
1248
1249 /*
1250 * Patches the local file header starting at the current output location
1251 * with updated crc and size information. Also updates the current last
1252 * Entry.
1253 */
1254 void patch_local_header(uint crc_32, uint compressed_size,
1255 uint uncompressed_size)
1256 {
1257 /* BUG: For some reason, this code won't compile. No idea why... if
1258 * you instantiate LFHD, it says that there is no "offsetof" property.
1259 */
1260 /+
1261 alias LocalFileHeaderData LFHD;
1262 static assert( LFHD.compressed_size.offsetof
1263 == LFHD.crc_32.offsetof + 4 );
1264 static assert( LFHD.uncompressed_size.offsetof
1265 == LFHD.compressed_size.offsetof + 4 );
1266 +/
1267
1268 // Don't forget we have to seek past the signature, too
1269 // BUG: .offsetof is broken here
1270 /+seeker.seek(LFHD.crc_32.offsetof+4, IConduit.Seek.Anchor.Current);+/
1271 seeker.seek(10+4, IConduit.Seek.Anchor.Current);
1272 write(output, crc_32);
1273 write(output, compressed_size);
1274 write(output, uncompressed_size);
1275
1276 with( entries[$-1] )
1277 {
1278 data.crc_32 = crc_32;
1279 data.compressed_size = compressed_size;
1280 data.uncompressed_size = uncompressed_size;
1281 }
1282 }
1283
1284 /*
1285 * Generates and outputs a local file header from the given info block and
1286 * compression method. Note that the crc_32, compressed_size and
1287 * uncompressed_size header fields will be set to zero, and must be
1288 * patched.
1289 */
1290 void put_local_header(ZipEntryInfo info, Method method)
1291 {
1292 LocalFileHeader.Data data;
1293
1294 data.compression_method = fromMethod(method);
1295 timeToDos(info.modified, data.modification_file_time,
1296 data.modification_file_date);
1297
1298 put_local_header(data, info.name);
1299 }
1300
1301 /*
1302 * Writes the given local file header data and filename out to the output
1303 * stream. It also appends a new Entry with the data and filename.
1304 */
1305 void put_local_header(LocalFileHeaderData data,
1306 char[] file_name)
1307 {
1308 // Compute Zip version
1309 if( data.extract_version == data.extract_version.max )
1310 {
1311 ushort zipver = 10;
1312 void minver(ushort v) { zipver = v>zipver ? v : zipver; }
1313
1314 {
1315 // Compression method
1316 switch( data.compression_method )
1317 {
1318 case 0: minver(10); break;
1319 case 8: minver(20); break;
1320 }
1321
1322 // File is a folder
1323 if( file_name.length > 0 && file_name[$-1] == '/'
1324 || file_name[$-1] == '\\' )
1325 // Is a directory, not a real file
1326 minver(20);
1327 }
1328 data.extract_version = zipver;
1329 }
1330
1331 /+// Encode filename
1332 auto file_name_437 = utf8_to_cp437(file_name);
1333 if( file_name_437 is null )
1334 ZipException.fnencode;+/
1335
1336 /+// Set up file name length
1337 if( file_name_437.length > ushort.max )
1338 ZipException.fntoolong;
1339
1340 data.file_name_length = file_name_437.length;+/
1341
1342 LocalFileHeader header;
1343 header.data = data;
1344 header.file_name = file_name;
1345
1346 // Write out the header and the filename
1347 auto header_pos = seeker.seek(0, IConduit.Seek.Anchor.Current);
1348
1349 write(output, LocalFileHeader.signature);
1350 header.put(output);
1351
1352 // Save the header
1353 Entry entry;
1354 entry.data.fromLocal(header.data);
1355 entry.filename = file_name;
1356 entry.header_position = header_pos;
1357 entry.data.relative_offset_of_local_header = header_pos;
1358 entries ~= entry;
1359 }
1360 }
1361
1362 //////////////////////////////////////////////////////////////////////////////
1363 //////////////////////////////////////////////////////////////////////////////
1364 //
1365 // ZipEntry
1366
1367 /**
1368 * This class is used to represent a single entry in an archive.
1369 * Specifically, it combines meta-data about the file (see the info field)
1370 * along with the two basic operations on an entry: open and verify.
1371 */
1372 class ZipEntry
1373 {
1374 /**
1375 * Header information on the file. See the ZipEntryInfo structure for
1376 * more information.
1377 */
1378 ZipEntryInfo info;
1379
1380 /**
1381 * Size (in bytes) of the file's uncompressed contents.
1382 */
1383 uint size()
1384 {
1385 return header.data.uncompressed_size;;
1386 }
1387
1388 /**
1389 * Opens a stream for reading from the file. The contents of this stream
1390 * represent the decompressed contents of the file stored in the archive.
1391 *
1392 * You should not assume that the returned stream is seekable.
1393 *
1394 * Note that the returned stream may be safely closed without affecting
1395 * the underlying archive stream.
1396 *
1397 * If the file has not yet been verified, then the stream will be checked
1398 * as you read from it. When the stream is either exhausted or closed,
1399 * then the integrity of the file's data will be checked. This means that
1400 * if the file is corrupt, an exception will be thrown only after you have
1401 * finished reading from the stream. If you wish to make sure the data is
1402 * valid before you read from the file, call the verify method.
1403 */
1404 InputStream open()
1405 {
1406 // If we haven't verified yet, wrap the stream in the appropriate
1407 // decorators.
1408 if( !verified )
1409 return new ZipEntryVerifier(this, open_dg(header, false));
1410
1411 else
1412 return open_dg(header, false);
1413 }
1414
1415 /**
1416 * Verifies the contents of this file by computing the CRC32 checksum,
1417 * and comparing it against the stored one. Throws an exception if the
1418 * checksums do not match.
1419 *
1420 * Not valid on streamed Zip archives.
1421 */
1422 void verify()
1423 {
1424 // If we haven't verified the contents yet, just read everything in
1425 // to trigger it.
1426 scope s = open;
1427 auto buffer = new ubyte[s.conduit.bufferSize];
1428 while( s.read(buffer) != s.Eof )
1429 {/*Do nothing*/}
1430 s.close;
1431 }
1432
1433 /**
1434 * Creates a new, independent copy of this instance.
1435 */
1436 ZipEntry dup()
1437 {
1438 return new ZipEntry(header, open_dg);
1439 }
1440
1441 private:
1442 /*
1443 * Callback used to open the file.
1444 */
1445 alias InputStream delegate(FileHeader, bool raw) open_dg_t;
1446 open_dg_t open_dg;
1447
1448 /*
1449 * Raw ZIP header.
1450 */
1451 FileHeader header;
1452
1453 /*
1454 * The flag used to keep track of whether the file's contents have been
1455 * verified.
1456 */
1457 bool verified = false;
1458
1459 /*
1460 * Opens a stream that does not perform any decompression or
1461 * transformation of the file contents. This is used internally by
1462 * ZipWriter to perform fast zip to zip transfers without having to
1463 * decompress and then recompress the contents.
1464 *
1465 * Note that because zip stores CRCs for the *uncompressed* data, this
1466 * method currently does not do any verification.
1467 */
1468 InputStream open_raw()
1469 {
1470 return open_dg(header, true);
1471 }
1472
1473 /*
1474 * Creates a new ZipEntry from the FileHeader.
1475 */
1476 this(FileHeader header, open_dg_t open_dg)
1477 {
1478 this.reset(header, open_dg);
1479 }
1480
1481 /*
1482 * Resets the current instance with new values.
1483 */
1484 ZipEntry reset(FileHeader header, open_dg_t open_dg)
1485 {
1486 this.header = header;
1487 this.open_dg = open_dg;
1488 with( info )
1489 {
1490 name = header.file_name.dup;
1491 dosToTime(header.data.modification_file_time,
1492 header.data.modification_file_date,
1493 modified);
1494 comment = header.file_comment.dup;
1495 }
1496
1497 this.verified = false;
1498
1499 return this;
1500 }
1501 }
1502
1503 /**
1504 * This structure contains various pieces of meta-data on a file. The
1505 * contents of this structure may be safely mutated.
1506 *
1507 * This structure is also used to specify meta-data about a file when adding
1508 * it to an archive.
1509 */
1510 struct ZipEntryInfo
1511 {
1512 /// Full path and file name of this file.
1513 char[] name;
1514 /// Modification timestamp. If this is left uninitialised when passed to
1515 /// a ZipWriter, it will be reset to the current system time.
1516 Time modified = Time.min;
1517 /// Comment on the file.
1518 char[] comment;
1519 }
1520
1521 //////////////////////////////////////////////////////////////////////////////
1522 //////////////////////////////////////////////////////////////////////////////
1523 //////////////////////////////////////////////////////////////////////////////
1524 //
1525 // Exceptions
1526 //
1527
1528 import tango.core.Exception : TracedException;
1529
1530 /**
1531 * This is the base class from which all exceptions generated by this module
1532 * derive from.
1533 */
1534 class ZipException : TracedException
1535 {
1536 this(char[] msg) { super(msg); }
1537
1538 private:
1539 alias typeof(this) thisT;
1540 static void opCall(char[] msg) { throw new ZipException(msg); }
1541
1542 static void badsig()
1543 {
1544 thisT("corrupt signature or unexpected section found");
1545 }
1546
1547 static void badsig(char[] type)
1548 {
1549 thisT("corrupt "~type~" signature or unexpected section found");
1550 }
1551
1552 static void incons(char[] name)
1553 {
1554 thisT("inconsistent headers for file \""~name~"\"; "
1555 "archive is likely corrupted");
1556 }
1557
1558 static void missingdir()
1559 {
1560 thisT("could not locate central archive directory; "
1561 "file is corrupt or possibly not a Zip archive");
1562 }
1563
1564 static void toomanyentries()
1565 {
1566 thisT("too many archive entries");
1567 }
1568
1569 static void toolong()
1570 {
1571 thisT("archive is too long; limited to 4GB total");
1572 }
1573
1574 static void cdtoolong()
1575 {
1576 thisT("central directory is too long; limited to 4GB total");
1577 }
1578
1579 static void fntoolong()
1580 {
1581 thisT("file name too long; limited to 65,535 characters");
1582 }
1583
1584 static void eftoolong()
1585 {
1586 thisT("extra field too long; limited to 65,535 characters");
1587 }
1588
1589 static void cotoolong()
1590 {
1591 thisT("extra field too long; limited to 65,535 characters");
1592 }
1593
1594 static void fnencode()
1595 {
1596 thisT("could not encode filename into codepage 437");
1597 }
1598
1599 static void coencode()
1600 {
1601 thisT("could not encode comment into codepage 437");
1602 }
1603
1604 static void tooold()
1605 {
1606 thisT("cannot represent dates before January 1, 1980");
1607 }
1608 }
1609
1610 /**
1611 * This exception is thrown if a ZipReader detects that a file's contents do
1612 * not match the stored checksum.
1613 */
1614 class ZipChecksumException : ZipException
1615 {
1616 this(char[] name)
1617 {
1618 super("checksum failed on zip entry \""~name~"\"");
1619 }
1620
1621 private:
1622 static void opCall(char[] name) { throw new ZipChecksumException(name); }
1623 }
1624
1625 /**
1626 * This exception is thrown if you call get reader method when there are no
1627 * more files in the archive.
1628 */
1629 class ZipExhaustedException : ZipException
1630 {
1631 this() { super("no more entries in archive"); }
1632
1633 private:
1634 static void opCall() { throw new ZipExhaustedException; }
1635 }
1636
1637 /**
1638 * This exception is thrown if you attempt to read an archive that uses
1639 * features not supported by the reader.
1640 */
1641 class ZipNotSupportedException : ZipException
1642 {
1643 this(char[] msg) { super(msg); }
1644
1645 private:
1646 alias ZipNotSupportedException thisT;
1647
1648 static void opCall(char[] msg)
1649 {
1650 throw new thisT(msg ~ " not supported");
1651 }
1652
1653 static void spanned()
1654 {
1655 thisT("split and multi-disk archives");
1656 }
1657
1658 static void zipver(ushort ver)
1659 {
1660 throw new thisT("zip format version "
1661 ~Integer.toString(ver / 10)
1662 ~"."
1663 ~Integer.toString(ver % 10)
1664 ~" not supported; maximum of version "
1665 ~Integer.toString(MAX_EXTRACT_VERSION / 10)
1666 ~"."
1667 ~Integer.toString(MAX_EXTRACT_VERSION % 10)
1668 ~" supported.");
1669 }
1670
1671 static void flags()
1672 {
1673 throw new thisT("unknown or unsupported file flags enabled");
1674 }
1675
1676 static void method(ushort m)
1677 {
1678 // Cheat here and work out what the method *actually* is
1679 char[] ms;
1680 switch( m )
1681 {
1682 case 0:
1683 case 8: assert(false); // supported
1684
1685 case 1: ms = "Shrink"; break;
1686 case 2: ms = "Reduce (factor 1)"; break;
1687 case 3: ms = "Reduce (factor 2)"; break;
1688 case 4: ms = "Reduce (factor 3)"; break;
1689 case 5: ms = "Reduce (factor 4)"; break;
1690 case 6: ms = "Implode"; break;
1691
1692 case 9: ms = "Deflate64"; break;
1693 case 10: ms = "TERSE (old)"; break;
1694
1695 case 12: ms = "Bzip2"; break;
1696 case 14: ms = "LZMA"; break;
1697
1698 case 18: ms = "TERSE (new)"; break;
1699 case 19: ms = "LZ77"; break;
1700
1701 case 97: ms = "WavPack"; break;
1702 case 98: ms = "PPMd"; break;
1703
1704 default: ms = "unknown";
1705 }
1706
1707 thisT(ms ~ " compression method");
1708 }
1709 }
1710
1711 //////////////////////////////////////////////////////////////////////////////
1712 //////////////////////////////////////////////////////////////////////////////
1713 //
1714 // Convenience methods
1715
1716 void createArchive(char[] archive, Method method, char[][] files...)
1717 {
1718 scope zw = new ZipBlockWriter(archive);
1719 zw.method = method;
1720
1721 foreach( file ; files )
1722 zw.putFile(ZipEntryInfo(file), file);
1723
1724 zw.finish;
1725 }
1726
1727 void createArchive(PathView archive, Method method, PathView[] files...)
1728 {
1729 scope zw = new ZipBlockWriter(archive);
1730 zw.method = method;
1731
1732 foreach( file ; files )
1733 zw.putFile(ZipEntryInfo(file.toString), file);
1734
1735 zw.finish;
1736 }
1737
1738 void extractArchive(char[] archive, char[] folder)
1739 {
1740 extractArchive(FilePath(archive), FilePath(folder));
1741 }
1742
1743 void extractArchive(PathView archive, PathView dest)
1744 {
1745 scope folder = FilePath(dest.toString);
1746 scope zr = new ZipBlockReader(archive);
1747
1748 foreach( entry ; zr )
1749 {
1750 // Skip directories
1751 if( entry.info.name[$-1] == '/' ) continue;
1752
1753 auto path = folder.dup.append(entry.info.name);
1754 scope fout = new FileConduit(path, FileConduit.WriteCreate);
1755 fout.output.copy(entry.open);
1756 }
1757 }
1758
1759 //////////////////////////////////////////////////////////////////////////////
1760 //////////////////////////////////////////////////////////////////////////////
1761 //////////////////////////////////////////////////////////////////////////////
1762 //
1763 // Private implementation stuff
1764 //
1765
1766 private:
1767
1768 //////////////////////////////////////////////////////////////////////////////
1769 //////////////////////////////////////////////////////////////////////////////
1770 //
1771 // Verification stuff
1772
1773 /*
1774 * This class wraps an input stream, and computes the CRC as it passes
1775 * through. On the event of either a close or EOF, it checks the CRC against
1776 * the one in the provided ZipEntry. If they don't match, it throws an
1777 * exception.
1778 */
1779
1780 class ZipEntryVerifier : InputStream
1781 {
1782 this(ZipEntry entry, InputStream source)
1783 in
1784 {
1785 assert( entry !is null );
1786 assert( source !is null );
1787 }
1788 body
1789 {
1790 this.entry = entry;
1791 this.digest = new Crc32;
1792 this.source = new DigestInput(source, digest);
1793 }
1794
1795 IConduit conduit()
1796 {
1797 return source.conduit;
1798 }
1799
1800 void close()
1801 {
1802 check;
1803
1804 this.source.close;
1805 this.entry = null;
1806 this.digest = null;
1807 this.source = null;
1808 }
1809
1810 uint read(void[] dst)
1811 {
1812 auto bytes = source.read(dst);
1813 if( bytes == IConduit.Eof )
1814 check;
1815 return bytes;
1816 }
1817
1818 InputStream clear()
1819 {
1820 this.source.clear;
1821 return this;
1822 }
1823
1824 private:
1825 Crc32 digest;
1826 InputStream source;
1827 ZipEntry entry;
1828
1829 void check()
1830 {
1831 if( digest is null ) return;
1832
1833 auto crc = digest.crc32Digest;
1834 delete digest;
1835
1836 if( crc != entry.header.data.crc_32 )
1837 ZipChecksumException(entry.info.name);
1838
1839 else
1840 entry.verified = true;
1841 }
1842 }
1843
1844 //////////////////////////////////////////////////////////////////////////////
1845 //////////////////////////////////////////////////////////////////////////////
1846 //
1847 // IO functions
1848
1849 /*
1850 * Really, seriously, read some bytes without having to go through a sodding
1851 * buffer.
1852 */
1853 void readExact(InputStream s, void[] dst)
1854 {
1855 //Stderr.formatln("readExact(s, [0..{}])", dst.length);
1856 while( dst.length > 0 )
1857 {
1858 auto octets = s.read(dst);
1859 //Stderr.formatln(" . octets = {}", octets);
1860 if( octets == -1 ) // Beware the dangers of MAGICAL THINKING
1861 throw new Exception("unexpected end of stream");
1862 dst = dst[octets..$];
1863 }
1864 }
1865
1866 /*
1867 * Really, seriously, write some bytes.
1868 */
1869 void writeExact(OutputStream s, void[] src)
1870 {
1871 while( src.length > 0 )
1872 {
1873 auto octets = s.write(src);
1874 if( octets == -1 )
1875 throw new Exception("unexpected end of stream");
1876 src = src[octets..$];
1877 }
1878 }
1879
1880 void write(T)(OutputStream s, T value)
1881 {
1882 version( BigEndian ) swap(value);
1883 writeExact(s, (&value)[0..1]);
1884 }
1885
1886 //////////////////////////////////////////////////////////////////////////////
1887 //////////////////////////////////////////////////////////////////////////////
1888 //
1889 // Endian garbage
1890
1891 void swapAll(T)(inout T data)
1892 {
1893 static if( is(typeof(T.record_fields)) )
1894 const fields = T.record_fields;
1895 else
1896 const fields = data.tupleof.length;
1897
1898 foreach( i,_ ; data.tupleof )
1899 {
1900 if( i == fields ) break;
1901 swap(data.tupleof[i]);
1902 }
1903 }
1904
1905 void swap(T)(inout T data)
1906 {
1907 static if( T.sizeof == 1 )
1908 {}
1909 else static if( T.sizeof == 2 )
1910 ByteSwap.swap16(&data, 2);
1911 else static if( T.sizeof == 4 )
1912 ByteSwap.swap32(&data, 4);
1913 else static if( T.sizeof == 8 )
1914 ByteSwap.swap64(&data, 8);
1915 else static if( T.sizeof == 10 )
1916 ByteSwap.swap80(&data, 10);
1917 else
1918 static assert(false, "Can't swap "~T.stringof~"s.");
1919 }
1920
1921 //////////////////////////////////////////////////////////////////////////////
1922 //////////////////////////////////////////////////////////////////////////////
1923 //
1924 // IBM Code Page 437 stuff
1925 //
1926
1927 const char[][] cp437_to_utf8_map_low = [
1928 "\u0000"[], "\u263a", "\u263b", "\u2665",
1929 "\u2666", "\u2663", "\u2660", "\u2022",
1930 "\u25d8", "\u25cb", "\u25d9", "\u2642",
1931 "\u2640", "\u266a", "\u266b", "\u263c",
1932
1933 "\u25b6", "\u25c0", "\u2195", "\u203c",
1934 "\u00b6", "\u00a7", "\u25ac", "\u21a8",
1935 "\u2191", "\u2193", "\u2192", "\u2190",
1936 "\u221f", "\u2194", "\u25b2", "\u25bc"
1937 ];
1938
1939 const char[][] cp437_to_utf8_map_high = [
1940 "\u00c7"[], "\u00fc", "\u00e9", "\u00e2",
1941 "\u00e4", "\u00e0", "\u00e5", "\u00e7",
1942 "\u00ea", "\u00eb", "\u00e8", "\u00ef",
1943 "\u00ee", "\u00ec", "\u00c4", "\u00c5",
1944
1945 "\u00c9", "\u00e6", "\u00c6", "\u00f4",
1946 "\u00f6", "\u00f2", "\u00fb", "\u00f9",
1947 "\u00ff", "\u00d6", "\u00dc", "\u00f8",
1948 "\u00a3", "\u00a5", "\u20a7", "\u0192",
1949
1950 "\u00e1", "\u00ed", "\u00f3", "\u00fa",
1951 "\u00f1", "\u00d1", "\u00aa", "\u00ba",
1952 "\u00bf", "\u2310", "\u00ac", "\u00bd",
1953 "\u00bc", "\u00a1", "\u00ab", "\u00bb",
1954
1955 "\u2591", "\u2592", "\u2593", "\u2502",
1956 "\u2524", "\u2561", "\u2562", "\u2556",
1957 "\u2555", "\u2563", "\u2551", "\u2557",
1958 "\u255d", "\u255c", "\u255b", "\u2510",
1959
1960 "\u2514", "\u2534", "\u252c", "\u251c",
1961 "\u2500", "\u253c", "\u255e", "\u255f",
1962 "\u255a", "\u2554", "\u2569", "\u2566",
1963 "\u2560", "\u2550", "\u256c", "\u2567",
1964
1965 "\u2568", "\u2564", "\u2565", "\u2559",
1966 "\u2558", "\u2552", "\u2553", "\u256b",
1967 "\u256a", "\u2518", "\u250c", "\u2588",
1968 "\u2584", "\u258c", "\u2590", "\u2580",
1969 "\u03b1", "\u00df", "\u0393", "\u03c0",
1970 "\u03a3", "\u03c3", "\u00b5", "\u03c4",
1971 "\u03a6", "\u0398", "\u03a9", "\u03b4",
1972 "\u221e", "\u03c6", "\u03b5", "\u2229",
1973
1974 "\u2261", "\u00b1", "\u2265", "\u2264",
1975 "\u2320", "\u2321", "\u00f7", "\u2248",
1976 "\u00b0", "\u2219", "\u00b7", "\u221a",
1977 "\u207f", "\u00b2", "\u25a0", "\u00a0"
1978 ];
1979
1980 char[] cp437_to_utf8(ubyte[] s)
1981 {
1982 foreach( i,c ; s )
1983 {
1984 if( (1 <= c && c <= 31) || c >= 127 )
1985 {
1986 /* Damn; we got a character not in ASCII. Since this is the first
1987 * non-ASCII character we found, copy everything up to this point
1988 * into the output verbatim. We'll allocate twice as much space
1989 * as there are remaining characters to ensure we don't need to do
1990 * any further allocations.
1991 */
1992 auto r = new char[i+2*(s.length-i)];
1993 r[0..i] = cast(char[]) s[0..i];
1994 size_t k=i; // current length
1995
1996 // We insert new characters at r[i+j+k]
1997
1998 foreach( d ; s[i..$] )
1999 {
2000 if( 32 <= d && d <= 126 || d == 0 )
2001 {
2002 r[k++] = d;
2003 }
2004 else if( 1 <= d && d <= 31 )
2005 {
2006 char[] repl = cp437_to_utf8_map_low[d];
2007 r[k..k+repl.length] = repl[];
2008 k += repl.length;
2009 }
2010 else if( d == 127 )
2011 {
2012 char[] repl = "\u2302";
2013 r[k..k+repl.length] = repl[];
2014 k += repl.length;
2015 }
2016 else if( d > 127 )
2017 {
2018 char[] repl = cp437_to_utf8_map_high[d-128];
2019 r[k..k+repl.length] = repl[];
2020 k += repl.length;
2021 }
2022 else
2023 assert(false);
2024 }
2025
2026 return r[0..k];
2027 }
2028 }
2029
2030 /* If we got here, then all the characters in s are also in ASCII, which
2031 * means it's also valid UTF-8; return the string unmodified.
2032 */
2033 return cast(char[]) s;
2034 }
2035
2036 debug( UnitTest )
2037 {
2038 unittest
2039 {
2040 char[] c(char[] s) { return cp437_to_utf8(cast(ubyte[]) s); }
2041
2042 auto s = c("Hi there \x01 old \x0c!");
2043 assert( s == "Hi there \u263a old \u2640!", "\""~s~"\"" );
2044 s = c("Marker \x7f and divide \xf6.");
2045 assert( s == "Marker \u2302 and divide \u00f7.", "\""~s~"\"" );
2046 }
2047 }
2048
2049 const char[dchar] utf8_to_cp437_map;
2050
2051 static this()
2052 {
2053 utf8_to_cp437_map = [
2054 '\u0000': '\x00', '\u263a': '\x01', '\u263b': '\x02', '\u2665': '\x03',
2055 '\u2666': '\x04', '\u2663': '\x05', '\u2660': '\x06', '\u2022': '\x07',
2056 '\u25d8': '\x08', '\u25cb': '\x09', '\u25d9': '\x0a', '\u2642': '\x0b',
2057 '\u2640': '\x0c', '\u266a': '\x0d', '\u266b': '\x0e', '\u263c': '\x0f',
2058
2059 '\u25b6': '\x10', '\u25c0': '\x11', '\u2195': '\x12', '\u203c': '\x13',
2060 '\u00b6': '\x14', '\u00a7': '\x15', '\u25ac': '\x16', '\u21a8': '\x17',
2061 '\u2191': '\x18', '\u2193': '\x19', '\u2192': '\x1a', '\u2190': '\x1b',
2062 '\u221f': '\x1c', '\u2194': '\x1d', '\u25b2': '\x1e', '\u25bc': '\x1f',
2063
2064 /*
2065 * Printable ASCII range (well, most of it) is handled specially.
2066 */
2067
2068 '\u00c7': '\x80', '\u00fc': '\x81', '\u00e9': '\x82', '\u00e2': '\x83',
2069 '\u00e4': '\x84', '\u00e0': '\x85', '\u00e5': '\x86', '\u00e7': '\x87',
2070 '\u00ea': '\x88', '\u00eb': '\x89', '\u00e8': '\x8a', '\u00ef': '\x8b',
2071 '\u00ee': '\x8c', '\u00ec': '\x8d', '\u00c4': '\x8e', '\u00c5': '\x8f',
2072
2073 '\u00c9': '\x90', '\u00e6': '\x91', '\u00c6': '\x92', '\u00f4': '\x93',
2074 '\u00f6': '\x94', '\u00f2': '\x95', '\u00fb': '\x96', '\u00f9': '\x97',
2075 '\u00ff': '\x98', '\u00d6': '\x99', '\u00dc': '\x9a', '\u00f8': '\x9b',
2076 '\u00a3': '\x9c', '\u00a5': '\x9d', '\u20a7': '\x9e', '\u0192': '\x9f',
2077
2078 '\u00e1': '\xa0', '\u00ed': '\xa1', '\u00f3': '\xa2', '\u00fa': '\xa3',
2079 '\u00f1': '\xa4', '\u00d1': '\xa5', '\u00aa': '\xa6', '\u00ba': '\xa7',
2080 '\u00bf': '\xa8', '\u2310': '\xa9', '\u00ac': '\xaa', '\u00bd': '\xab',
2081 '\u00bc': '\xac', '\u00a1': '\xad', '\u00ab': '\xae', '\u00bb': '\xaf',
2082
2083 '\u2591': '\xb0', '\u2592': '\xb1', '\u2593': '\xb2', '\u2502': '\xb3',
2084 '\u2524': '\xb4', '\u2561': '\xb5', '\u2562': '\xb6', '\u2556': '\xb7',
2085 '\u2555': '\xb8', '\u2563': '\xb9', '\u2551': '\xba', '\u2557': '\xbb',
2086 '\u255d': '\xbc', '\u255c': '\xbd', '\u255b': '\xbe', '\u2510': '\xbf',
2087
2088 '\u2514': '\xc0', '\u2534': '\xc1', '\u252c': '\xc2', '\u251c': '\xc3',
2089 '\u2500': '\xc4', '\u253c': '\xc5', '\u255e': '\xc6', '\u255f': '\xc7',
2090 '\u255a': '\xc8', '\u2554': '\xc9', '\u2569': '\xca', '\u2566': '\xcb',
2091 '\u2560': '\xcc', '\u2550': '\xcd', '\u256c': '\xce', '\u2567': '\xcf',
2092
2093 '\u2568': '\xd0', '\u2564': '\xd1', '\u2565': '\xd2', '\u2559': '\xd3',
2094 '\u2558': '\xd4', '\u2552': '\xd5', '\u2553': '\xd6', '\u256b': '\xd7',
2095 '\u256a': '\xd8', '\u2518': '\xd9', '\u250c': '\xda', '\u2588': '\xdb',
2096 '\u2584': '\xdc', '\u258c': '\xdd', '\u2590': '\xde', '\u2580': '\xdf',
2097
2098 '\u03b1': '\xe0', '\u00df': '\xe1', '\u0393': '\xe2', '\u03c0': '\xe3',
2099 '\u03a3': '\xe4', '\u03c3': '\xe5', '\u00b5': '\xe6', '\u03c4': '\xe7',
2100 '\u03a6': '\xe8', '\u0398': '\xe9', '\u03a9': '\xea', '\u03b4': '\xeb',
2101 '\u221e': '\xec', '\u03c6': '\xed', '\u03b5': '\xee', '\u2229': '\xef',
2102
2103 '\u2261': '\xf0', '\u00b1': '\xf1', '\u2265': '\xf2', '\u2264': '\xf3',
2104 '\u2320': '\xf4', '\u2321': '\xf5', '\u00f7': '\xf6', '\u2248': '\xf7',
2105 '\u00b0': '\xf8', '\u2219': '\xf9', '\u00b7': '\xfa', '\u221a': '\xfb',
2106 '\u207f': '\xfc', '\u00b2': '\xfd', '\u25a0': '\xfe', '\u00a0': '\xff'
2107 ];
2108 }
2109
2110 ubyte[] utf8_to_cp437(char[] s)
2111 {
2112 foreach( i,dchar c ; s )
2113 {
2114 if( !((32 <= c && c <= 126) || c == 0) )
2115 {
2116 /* We got a character not in CP 437: we need to create a buffer to
2117 * hold the new string. Since UTF-8 is *always* larger than CP
2118 * 437, we need, at most, an array of the same number of elements.
2119 */
2120 auto r = new ubyte[s.length];
2121 r[0..i] = cast(ubyte[]) s[0..i];
2122 size_t k=i;
2123
2124 foreach( dchar d ; s[i..$] )
2125 {
2126 if( 32 <= d && d <= 126 || d == 0 )
2127 r[k++] = d;
2128
2129 else if( d == '\u2302' )
2130 r[k++] = '\x7f';
2131
2132 else if( auto e_ptr = d in utf8_to_cp437_map )
2133 r[k++] = *e_ptr;
2134
2135 else
2136 {
2137 throw new Exception("cannot encode character \""
2138 ~ Integer.toString(cast(uint)d)
2139 ~ "\" in codepage 437.");
2140 }
2141 }
2142
2143 return r[0..k];
2144 }
2145 }
2146
2147 // If we got here, then the entire string is printable ASCII, which just
2148 // happens to *also* be valid CP 437! Huzzah!
2149 return cast(ubyte[]) s;
2150 }
2151
2152 debug( UnitTest )
2153 {
2154 unittest
2155 {
2156 alias cp437_to_utf8 x;
2157 alias utf8_to_cp437 y;
2158
2159 ubyte[256] s;
2160 foreach( i,ref c ; s )
2161 c = i;
2162
2163 auto a = x(s);
2164 auto b = y(a);
2165 if(!( b == s ))
2166 {
2167 // Display list of characters that failed to convert as expected,
2168 // and what value we got.
2169 auto hex = "0123456789abcdef";
2170 auto msg = "".dup;
2171 foreach( i,ch ; b )
2172 {
2173 if( ch != i )
2174 {
2175 msg ~= hex[i>>4];
2176 msg ~= hex[i&15];
2177 msg ~= " (";
2178 msg ~= hex[ch>>4];
2179 msg ~= hex[ch&15];
2180 msg ~= "), ";
2181 }
2182 }
2183 msg ~= "failed.";
2184
2185 assert( false, msg );
2186 }
2187 }
2188 }
2189
2190 /*
2191 * This is here to simplify the code elsewhere.
2192 */
2193 char[] utf8_to_utf8(ubyte[] s) { return cast(char[]) s; }
2194 ubyte[] utf8_to_utf8(char[] s) { return cast(ubyte[]) s; }
2195
2196 //////////////////////////////////////////////////////////////////////////////
2197 //////////////////////////////////////////////////////////////////////////////
2198 //
2199 // Date/time stuff
2200
2201 void dosToTime(ushort dostime, ushort dosdate, out Time time)
2202 {
2203 uint sec, min, hour, day, mon, year;
2204 sec = (dostime & 0b00000_000000_11111) * 2;
2205 min = (dostime & 0b00000_111111_00000) >> 5;
2206 hour= (dostime & 0b11111_000000_00000) >> 11;
2207 day = (dosdate & 0b0000000_0000_11111);
2208 mon = (dosdate & 0b0000000_1111_00000) >> 5;
2209 year=((dosdate & 0b1111111_0000_00000) >> 9) + 1980;
2210
2211 // This code sucks.
2212 scope cal = new Gregorian;
2213 time = Time.epoch
2214 + TimeSpan.days(cal.getDaysInYear(year, 0))
2215 + TimeSpan.days(cal.getDaysInMonth(year, mon, 0))
2216 + TimeSpan.days(day)
2217 + TimeSpan.hours(hour)
2218 + TimeSpan.minutes(min)
2219 + TimeSpan.seconds(sec);
2220 }
2221
2222 void timeToDos(Time time, out ushort dostime, out ushort dosdate)
2223 {
2224 // Treat Time.min specially
2225 if( time == Time.min )
2226 time = WallClock.now;
2227
2228 // *muttering angrily*
2229 scope cal = new Gregorian;
2230
2231 if( cal.getYear(time) < 1980 )
2232 ZipException.tooold;
2233
2234 auto span = time.span;
2235 dostime =
2236 (span.seconds / 2)
2237 | (span.minutes << 5)
2238 | (span.hours << 11);
2239
2240 dosdate =
2241 (cal.getDayOfMonth(time))
2242 | (cal.getMonth(time) << 5)
2243 |((cal.getYear(time) - 1980) << 9);
2244 }
2245
2246 // ************************************************************************** //
2247 // ************************************************************************** //
2248 // ************************************************************************** //
2249
2250 // Dependencies
2251 private:
2252
2253 import tango.io.Conduit : Conduit;
2254
2255 /*******************************************************************************
2256
2257 copyright: Copyright © 2007 Daniel Keep. All rights reserved.
2258
2259 license: BSD style: $(LICENSE)
2260
2261 version: Prerelease
2262
2263 author: Daniel Keep
2264
2265 *******************************************************************************/
2266
2267 //module tangox.io.stream.CounterStream;
2268
2269 //import tango.io.Conduit : Conduit;
2270 //import tango.io.model.IConduit : IConduit, InputStream, OutputStream;
2271
2272 /**
2273 * The counter stream classes are used to keep track of how many bytes flow
2274 * through a stream.
2275 *
2276 * To use them, simply wrap it around an existing stream. The number of bytes
2277 * that have flowed through the wrapped stream may be accessed using the
2278 * count member.
2279 */
2280 class CounterInput : InputStream
2281 {
2282 ///
2283 this(InputStream input)
2284 in
2285 {
2286 assert( input !is null );
2287 }
2288 body
2289 {
2290 this.input = input;
2291 }
2292
2293 override IConduit conduit()
2294 {
2295 return input.conduit;
2296 }
2297
2298 override void close()
2299 {
2300 input.close();
2301 input = null;
2302 }
2303
2304 override uint read(void[] dst)
2305 {
2306 auto read = input.read(dst);
2307 if( read != IConduit.Eof )
2308 _count += read;
2309 return read;
2310 }
2311
2312 override InputStream clear()
2313 {
2314 input.clear();
2315 return this;
2316 }
2317
2318 ///
2319 long count() { return _count; }
2320
2321 private:
2322 InputStream input;
2323 long _count;
2324 }
2325
2326 /// ditto
2327 class CounterOutput : OutputStream
2328 {
2329 ///
2330 this(OutputStream output)
2331 in
2332 {
2333 assert( output !is null );
2334 }
2335 body
2336 {
2337 this.output = output;
2338 }
2339
2340 override IConduit conduit()
2341 {
2342 return output.conduit;
2343 }
2344
2345 override void close()
2346 {
2347 output.close();
2348 output = null;
2349 }
2350
2351 override uint write(void[] dst)
2352 {
2353 auto wrote = output.write(dst);
2354 if( wrote != IConduit.Eof )
2355 _count += wrote;
2356 return wrote;
2357 }
2358
2359 override OutputStream copy(InputStream src)
2360 {
2361 return Conduit.transfer(src, this);
2362 }
2363
2364 override OutputStream flush()
2365 {
2366 output.flush();
2367 return this;
2368 }
2369
2370 ///
2371 long count() { return _count; }
2372
2373 private:
2374 OutputStream output;
2375 long _count;
2376 }
2377
2378 /*******************************************************************************
2379
2380 copyright: Copyright © 2007 Daniel Keep. All rights reserved.
2381
2382 license: BSD style: $(LICENSE)
2383
2384 version: Prerelease
2385
2386 author: Daniel Keep
2387
2388 *******************************************************************************/
2389
2390 //module tangox.io.stream.SliceStream;
2391
2392 //import tango.io.Conduit : Conduit;
2393 //import tango.io.model.IConduit : IConduit, InputStream, OutputStream;
2394
2395 /**
2396 * This stream can be used to provide stream-based access to a subset of
2397 * another stream. It is akin to slicing an array.
2398 *
2399 * This stream fully supports seeking, and as such requires that the
2400 * underlying stream also support seeking.
2401 */
2402 class SliceSeekInputStream : InputStream, IConduit.Seek
2403 {
2404 alias IConduit.Seek.Anchor Anchor;
2405
2406 /**
2407 * Create a new slice stream from the given source, covering the content
2408 * starting at position begin, for length bytes.
2409 */
2410 this(InputStream source, long begin, long length)
2411 in
2412 {
2413 assert( source !is null );
2414 assert( (cast(IConduit.Seek) source) !is null );
2415 assert( begin >= 0 );
2416 assert( length >= 0 );
2417 }
2418 body
2419 {
2420 this.source = source;
2421 this.seeker = cast(IConduit.Seek) source;
2422 this.begin = begin;
2423 this.length = length;
2424 }
2425
2426 override IConduit conduit()
2427 {
2428 return source.conduit;
2429 }
2430
2431 override void close()
2432 {
2433 source = null;
2434 seeker = null;
2435 }
2436
2437 override uint read(void[] dst)
2438 {
2439 // If we're at the end of the slice, return eof
2440 if( _position >= length )
2441 return IConduit.Eof;
2442
2443 // Otherwise, make sure we don't try to read past the end of the slice
2444 if( _position+dst.length > length )
2445 dst.length = length-_position;
2446
2447 // Seek source stream to the appropriate location.
2448 if( seeker.seek(0, Anchor.Current) != begin+_position )
2449 seeker.seek(begin+_position, Anchor.Begin);
2450
2451 // Do the read
2452 auto read = source.read(dst);
2453 if( read == IConduit.Eof )
2454 // If we got an Eof, we'll consider that a bug for the moment.
2455 // TODO: proper exception
2456 throw new Exception("unexpected end-of-stream");
2457
2458 _position += read;
2459 return read;
2460 }
2461
2462 override InputStream clear()
2463 {
2464 source.clear();
2465 return this;
2466 }
2467
2468 override long seek(long offset, Anchor anchor = cast(Anchor)0)
2469 {
2470 switch( anchor )
2471 {
2472 case Anchor.Begin:
2473 _position = offset;
2474 break;
2475
2476 case Anchor.Current:
2477 _position += offset;
2478 if( _position < 0 ) _position = 0;
2479 break;
2480
2481 case Anchor.End:
2482 _position = length+offset;
2483 if( _position < 0 ) _position = 0;
2484 break;
2485 }
2486
2487 return _position;
2488 }
2489
2490 private:
2491 InputStream source;
2492 IConduit.Seek seeker;
2493
2494 long _position, begin, length;
2495
2496 invariant
2497 {
2498 assert( cast(Object) source is cast(Object) seeker );
2499 assert( begin >= 0 );
2500 assert( length >= 0 );
2501 assert( _position >= 0 );
2502 }
2503 }
2504
2505 /**
2506 * This stream can be used to provide stream-based access to a subset of
2507 * another stream. It is akin to slicing an array.
2508 */
2509 class SliceInputStream : InputStream
2510 {
2511 /**
2512 * Create a new slice stream from the given source, covering the content
2513 * starting at the current seek position for length bytes.
2514 */
2515 this(InputStream source, long length)
2516 in
2517 {
2518 assert( source !is null );
2519 assert( length >= 0 );
2520 }
2521 body
2522 {
2523 this.source = source;
2524 this._length = length;
2525 }
2526
2527 override IConduit conduit()
2528 {
2529 return source.conduit;
2530 }
2531
2532 override void close()
2533 {
2534 source = null;
2535 }
2536
2537 override uint read(void[] dst)
2538 {
2539 // If we're at the end of the slice, return eof
2540 if( _length <= 0 )
2541 return IConduit.Eof;
2542
2543 // Otherwise, make sure we don't try to read past the end of the slice
2544 if( dst.length > _length )
2545 dst.length = _length;
2546
2547 // Do the read
2548 auto read = source.read(dst);
2549 if( read == IConduit.Eof )
2550 // If we got an Eof, we'll consider that a bug for the moment.
2551 // TODO: proper exception
2552 throw new Exception("unexpected end-of-stream");
2553
2554 _length -= read;
2555 return read;
2556 }
2557
2558 override InputStream clear()
2559 {
2560 source.clear();
2561 return this;
2562 }
2563
2564 private:
2565 InputStream source;
2566 long _length;
2567
2568 invariant
2569 {
2570 if( _length > 0 ) assert( source !is null );
2571 }
2572 }
2573
2574 /**
2575 * This stream can be used to provide stream-based access to a subset of
2576 * another stream. It is akin to slicing an array.
2577 *
2578 * This stream fully supports seeking, and as such requires that the
2579 * underlying stream also support seeking.
2580 */
2581 class SliceSeekOutputStream : OutputStream, IConduit.Seek
2582 {
2583 alias IConduit.Seek.Anchor Anchor;
2584
2585 /**
2586 * Create a new slice stream from the given source, covering the content
2587 * starting at position begin, for length bytes.
2588 */
2589 this(OutputStream source, long begin, long length)
2590 in
2591 {
2592 assert( (cast(IConduit.Seek) source) !is null );
2593 assert( begin >= 0 );
2594 assert( length >= 0 );
2595 }
2596 body
2597 {
2598 this.source = source;
2599 this.seeker = cast(IConduit.Seek) source;
2600 this.begin = begin;
2601 this.length = length;
2602 }
2603
2604 override IConduit conduit()
2605 {
2606 return source.conduit;
2607 }
2608
2609 override void close()
2610 {
2611 source = null;
2612 seeker = null;
2613 }
2614
2615 uint write(void[] src)
2616 {
2617 // If we're at the end of the slice, return eof
2618 if( _position >= length )
2619 return IConduit.Eof;
2620
2621 // Otherwise, make sure we don't try to write past the end of the
2622 // slice
2623 if( _position+src.length > length )
2624 src.length = length-_position;
2625
2626 // Seek source stream to the appropriate location.
2627 if( seeker.seek(0, Anchor.Current) != begin+_position )
2628 seeker.seek(begin+_position, Anchor.Begin);
2629
2630 // Do the write
2631 auto wrote = source.write(src);
2632 if( wrote == IConduit.Eof )
2633 // If we got an Eof, we'll consider that a bug for the moment.
2634 // TODO: proper exception
2635 throw new Exception("unexpected end-of-stream");
2636
2637 _position += wrote;
2638 return wrote;
2639 }
2640
2641 override OutputStream copy(InputStream src)
2642 {
2643 return Conduit.transfer(src, this);
2644 }
2645
2646 override OutputStream flush()
2647 {
2648 source.flush();
2649 return this;
2650 }
2651
2652 override long seek(long offset, Anchor anchor = cast(Anchor)0)
2653 {
2654 switch( anchor )
2655 {
2656 case Anchor.Begin:
2657 _position = offset;
2658 break;
2659
2660 case Anchor.Current:
2661 _position += offset;
2662 if( _position < 0 ) _position = 0;
2663 break;
2664
2665 case Anchor.End:
2666 _position = length+offset;
2667 if( _position < 0 ) _position = 0;
2668 break;
2669 }
2670
2671 return _position;
2672 }
2673
2674 private:
2675 OutputStream source;
2676 IConduit.Seek seeker;
2677
2678 long _position, begin, length;
2679
2680 invariant
2681 {
2682 assert( cast(Object) source is cast(Object) seeker );
2683 assert( begin >= 0 );
2684 assert( length >= 0 );
2685 assert( _position >= 0 );
2686 }
2687 }
2688
2689 /*******************************************************************************
2690
2691 copyright: Copyright © 2007 Daniel Keep. All rights reserved.
2692
2693 license: BSD style: $(LICENSE)
2694
2695 version: Prerelease
2696
2697 author: Daniel Keep
2698
2699 *******************************************************************************/
2700
2701 //module tangox.io.stream.WrapStream;
2702
2703 //import tango.io.Conduit : Conduit;
2704 //import tango.io.model.IConduit : IConduit, InputStream, OutputStream;
2705
2706 /**
2707 * This stream can be used to provide access to another stream.
2708 * Its distinguishing feature is that users cannot close the underlying
2709 * stream.
2710 *
2711 * This stream fully supports seeking, and as such requires that the
2712 * underlying stream also support seeking.
2713 */
2714 class WrapSeekInputStream : InputStream, IConduit.Seek
2715 {
2716 alias IConduit.Seek.Anchor Anchor;
2717
2718 /**
2719 * Create a new wrap stream from the given source.
2720 */
2721 this(InputStream source)
2722 in
2723 {
2724 assert( source !is null );
2725 assert( (cast(IConduit.Seek) source) !is null );
2726 }
2727 body
2728 {
2729 this.source = source;
2730 this.seeker = cast(IConduit.Seek) source;
2731 this._position = seeker.seek(0, Anchor.Current);
2732 }
2733
2734 /// ditto
2735 this(InputStream source, long position)
2736 in
2737 {
2738 assert( position >= 0 );
2739 }
2740 body
2741 {
2742 this(source);
2743 this._position = position;
2744 }
2745
2746 override IConduit conduit()
2747 {
2748 return source.conduit;
2749 }
2750
2751 override void close()
2752 {
2753 source = null;
2754 seeker = null;
2755 }
2756
2757 override uint read(void[] dst)
2758 {
2759 if( seeker.seek(0, Anchor.Current) != _position )
2760 seeker.seek(_position, Anchor.Begin);
2761
2762 auto read = source.read(dst);
2763 if( read != IConduit.Eof )
2764 _position += read;
2765
2766 return read;
2767 }
2768
2769 override InputStream clear()
2770 {
2771 source.clear();
2772 return this;
2773 }
2774
2775 override long seek(long offset, Anchor anchor = cast(Anchor)0)
2776 {
2777 seeker.seek(_position, Anchor.Begin);
2778 return (_position = seeker.seek(offset, anchor));
2779 }
2780
2781 private:
2782 InputStream source;
2783 IConduit.Seek seeker;
2784 long _position;
2785
2786 invariant
2787 {
2788 assert( cast(Object) source is cast(Object) seeker );
2789 assert( _position >= 0 );
2790 }
2791 }
2792
2793 /**
2794 * This stream can be used to provide access to another stream.
2795 * Its distinguishing feature is that the users cannot close the underlying
2796 * stream.
2797 *
2798 * This stream fully supports seeking, and as such requires that the
2799 * underlying stream also support seeking.
2800 */
2801 class WrapSeekOutputStream : OutputStream, IConduit.Seek
2802 {
2803 alias IConduit.Seek.Anchor Anchor;
2804
2805 /**
2806 * Create a new wrap stream from the given source.
2807 */
2808 this(OutputStream source)
2809 in
2810 {
2811 assert( (cast(IConduit.Seek) source) !is null );
2812 }
2813 body
2814 {
2815 this.source = source;
2816 this.seeker = cast(IConduit.Seek) source;
2817 this._position = seeker.seek(0, Anchor.Current);
2818 }
2819
2820 /// ditto
2821 this(OutputStream source, long position)
2822 in
2823 {
2824 assert( position >= 0 );
2825 }
2826 body
2827 {
2828 this(source);
2829 this._position = position;
2830 }
2831
2832 override IConduit conduit()
2833 {
2834 return source.conduit;
2835 }
2836
2837 override void close()
2838 {
2839 source = null;
2840 seeker = null;
2841 }
2842
2843 uint write(void[] src)
2844 {
2845 if( seeker.seek(0, Anchor.Current) != _position )
2846 seeker.seek(_position, Anchor.Begin);
2847
2848 auto wrote = source.write(src);
2849 if( wrote != IConduit.Eof )
2850 _position += wrote;
2851 return wrote;
2852 }
2853
2854 override OutputStream copy(InputStream src)
2855 {
2856 return Conduit.transfer(src, this);
2857 }
2858
2859 override OutputStream flush()
2860 {
2861 source.flush();
2862 return this;
2863 }
2864
2865 override long seek(long offset, Anchor anchor = cast(Anchor)0)
2866 {
2867 seeker.seek(_position, Anchor.Begin);
2868 return (_position = seeker.seek(offset, anchor));
2869 }
2870
2871 private:
2872 OutputStream source;
2873 IConduit.Seek seeker;
2874 long _position;
2875
2876 invariant
2877 {
2878 assert( cast(Object) source is cast(Object) seeker );
2879 assert( _position >= 0 );
2880 }
2881 }
2882