1 /*
2 * Copyright (c) 1996, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.util.zip;
27
28 import java.io.OutputStream;
29 import java.io.IOException;
30 import java.nio.charset.Charset;
31 import java.nio.charset.StandardCharsets;
32 import java.util.Vector;
33 import java.util.HashSet;
34 import static java.util.zip.ZipConstants64.*;
35 import static java.util.zip.ZipUtils.*;
36
37 /**
38 * This class implements an output stream filter for writing files in the
39 * ZIP file format. Includes support for both compressed and uncompressed
40 * entries.
41 *
42 * @author David Connelly
43 */
44 public
45 class ZipOutputStream extends DeflaterOutputStream implements ZipConstants {
46
47 /**
48 * Whether to use ZIP64 for zip files with more than 64k entries.
49 * Until ZIP64 support in zip implementations is ubiquitous, this
50 * system property allows the creation of zip files which can be
51 * read by legacy zip implementations which tolerate "incorrect"
52 * total entry count fields, such as the ones in jdk6, and even
53 * some in jdk7.
54 */
55 private static final boolean inhibitZip64 =
56 Boolean.parseBoolean(
57 java.security.AccessController.doPrivileged(
58 new sun.security.action.GetPropertyAction(
59 "jdk.util.zip.inhibitZip64", "false")));
60
61 private static class XEntry {
62 final ZipEntry entry;
63 final long offset;
64 public XEntry(ZipEntry entry, long offset) {
65 this.entry = entry;
66 this.offset = offset;
67 }
68 }
69
70 private XEntry current;
71 private Vector<XEntry> xentries = new Vector<>();
72 private HashSet<String> names = new HashSet<>();
73 private CRC32 crc = new CRC32();
74 private long written = 0;
75 private long locoff = 0;
76 private byte[] comment;
77 private int method = DEFLATED;
78 private boolean finished;
79
80 private boolean closed = false;
81
82 private final ZipCoder zc;
83
84 private ZipCryption zipCryption;
85
86 private int version(ZipEntry e) throws ZipException {
87 int result;
88
89 switch (e.method) {
90 case DEFLATED:
91 result = 20;
92 break;
93
94 case STORED:
95 result = 10;
96 break;
97
98 default:
99 throw new ZipException("unsupported compression method");
100 }
101
102 /*
103 * Zip Crypto is defined version 2.0 or later.
104 * 4.4.3.2 Current minimum feature versions
105 * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
106 */
107 if (zipCryption != null) {
108 result = 20;
109 }
110
111 return result;
112 }
113
114 /**
115 * Checks to make sure that this stream has not been closed.
116 */
117 private void ensureOpen() throws IOException {
118 if (closed) {
119 throw new IOException("Stream closed");
120 }
121 }
122 /**
123 * Compression method for uncompressed (STORED) entries.
124 */
125 public static final int STORED = ZipEntry.STORED;
126
127 /**
128 * Compression method for compressed (DEFLATED) entries.
129 */
130 public static final int DEFLATED = ZipEntry.DEFLATED;
131
132 /**
133 * Creates a new ZIP output stream.
134 *
135 * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used
136 * to encode the entry names and comments.
137 *
138 * @param out the actual output stream
139 */
140 public ZipOutputStream(OutputStream out) {
141 this(out, StandardCharsets.UTF_8, null);
142 }
143
144 /**
145 * Creates a new ZIP output stream.
146 *
147 * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used
148 * to encode the entry names and comments.
149 *
150 * @param out the actual output stream
151 * @param zipCryption ZIP encrypt/decrypt engine
152 */
153 public ZipOutputStream(OutputStream out, ZipCryption zipCryption) {
154 this(out, StandardCharsets.UTF_8, zipCryption);
155 }
156
157 /**
158 * Creates a new ZIP output stream.
159 *
160 * @param out the actual output stream
161 *
162 * @param charset the {@linkplain java.nio.charset.Charset charset}
163 * to be used to encode the entry names and comments
164 *
165 * @since 1.7
166 */
167 public ZipOutputStream(OutputStream out, Charset charset) {
168 this(out, charset, null);
169 }
170
171 /**
172 * Creates a new ZIP output stream.
173 *
174 * @param out the actual output stream
175 *
176 * @param charset the {@linkplain java.nio.charset.Charset charset}
177 * to be used to encode the entry names and comments
178 *
179 * @param zipCryption ZIP encrypt/decrypt engine
180 */
181 public ZipOutputStream(OutputStream out,
182 Charset charset, ZipCryption zipCryption) {
183 super(out, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
184 if (charset == null)
185 throw new NullPointerException("charset is null");
186 this.zc = ZipCoder.get(charset);
187 usesDefaultDeflater = true;
188 this.zipCryption = zipCryption;
189 super.setZipCryption(zipCryption);
190 }
191
192 /**
193 * Sets the ZIP file comment.
194 * @param comment the comment string
195 * @exception IllegalArgumentException if the length of the specified
196 * ZIP file comment is greater than 0xFFFF bytes
197 */
198 public void setComment(String comment) {
199 if (comment != null) {
200 this.comment = zc.getBytes(comment);
201 if (this.comment.length > 0xffff)
202 throw new IllegalArgumentException("ZIP file comment too long.");
203 }
204 }
205
206 /**
207 * Sets the default compression method for subsequent entries. This
208 * default will be used whenever the compression method is not specified
209 * for an individual ZIP file entry, and is initially set to DEFLATED.
210 * @param method the default compression method
211 * @exception IllegalArgumentException if the specified compression method
212 * is invalid
213 */
214 public void setMethod(int method) {
215 if (method != DEFLATED && method != STORED) {
216 throw new IllegalArgumentException("invalid compression method");
217 }
218 this.method = method;
219 }
220
221 /**
222 * Sets the compression level for subsequent entries which are DEFLATED.
223 * The default setting is DEFAULT_COMPRESSION.
224 * @param level the compression level (0-9)
225 * @exception IllegalArgumentException if the compression level is invalid
226 */
227 public void setLevel(int level) {
228 def.setLevel(level);
229 }
230
231 /**
232 * Begins writing a new ZIP file entry and positions the stream to the
233 * start of the entry data. Closes the current entry if still active.
234 * The default compression method will be used if no compression method
235 * was specified for the entry, and the current time will be used if
236 * the entry has no set modification time.
237 * @param e the ZIP entry to be written
238 * @exception ZipException if a ZIP format error has occurred
239 * @exception IOException if an I/O error has occurred
240 */
241 public void putNextEntry(ZipEntry e) throws IOException {
242 ensureOpen();
243 if (current != null) {
244 closeEntry(); // close previous entry
245 }
246 if (zipCryption != null) {
247 zipCryption.reset();
248 }
249 if (e.xdostime == -1) {
250 // by default, do NOT use extended timestamps in extra
251 // data, for now.
252 e.setTime(System.currentTimeMillis());
253 }
254 if (e.method == -1) {
255 e.method = method; // use default method
256 }
257 // store size, compressed size, and crc-32 in LOC header
258 e.flag = 0;
259 switch (e.method) {
260 case DEFLATED:
261 // store size, compressed size, and crc-32 in data descriptor
262 // immediately following the compressed entry data
263 if (e.size == -1 || e.csize == -1 || e.crc == -1)
264 e.flag = 8;
265
266 break;
267 case STORED:
268 // compressed size, uncompressed size, and crc-32 must all be
269 // set for entries using STORED compression method
270 if (e.size == -1) {
271 e.size = e.csize;
272 } else if (e.csize == -1) {
273 e.csize = e.size;
274 } else if (e.size != e.csize) {
275 throw new ZipException(
276 "STORED entry where compressed != uncompressed size");
277 }
278 if (e.size == -1 || e.crc == -1) {
279 throw new ZipException(
280 "STORED entry missing size, compressed size, or crc-32");
281 }
282 if (zipCryption != null) {
283 e.csize += zipCryption.getEncryptionHeaderSize();
284 }
285 break;
286 default:
287 throw new ZipException("unsupported compression method");
288 }
289 if (! names.add(e.name)) {
290 throw new ZipException("duplicate entry: " + e.name);
291 }
292 if (zc.isUTF8())
293 e.flag |= EFS;
294 if (zipCryption != null)
295 e.flag |= 1; // Bit 0: If set, indicates that the file is encrypted.
296 current = new XEntry(e, written);
297 xentries.add(current);
298 writeLOC(current);
299
300 if (zipCryption != null) {
301 byte[] encryptionHeader = zipCryption.getEncryptionHeader(e);
302 writeBytes(encryptionHeader, 0, encryptionHeader.length);
303 locoff += encryptionHeader.length;
304 }
305 }
306
307 /**
308 * Closes the current ZIP entry and positions the stream for writing
309 * the next entry.
310 * @exception ZipException if a ZIP format error has occurred
311 * @exception IOException if an I/O error has occurred
312 */
313 public void closeEntry() throws IOException {
314 ensureOpen();
315 if (current != null) {
316 ZipEntry e = current.entry;
317 switch (e.method) {
318 case DEFLATED:
319 def.finish();
320 while (!def.finished()) {
321 deflate();
322 }
323 if ((e.flag & 8) == 0) {
324 // verify size, compressed size, and crc-32 settings
325 if (e.size != def.getBytesRead()) {
326 throw new ZipException(
327 "invalid entry size (expected " + e.size +
328 " but got " + def.getBytesRead() + " bytes)");
329 }
330 if (e.csize != def.getBytesWritten()) {
331 throw new ZipException(
332 "invalid entry compressed size (expected " +
333 e.csize + " but got " + def.getBytesWritten() + " bytes)");
334 }
335 if (e.crc != crc.getValue()) {
336 throw new ZipException(
337 "invalid entry CRC-32 (expected 0x" +
338 Long.toHexString(e.crc) + " but got 0x" +
339 Long.toHexString(crc.getValue()) + ")");
340 }
341 } else {
342 e.size = def.getBytesRead();
343 e.csize = def.getBytesWritten();
344 e.crc = crc.getValue();
345 writeEXT(e);
346 }
347 def.reset();
348 written += e.csize;
349
350 if (zipCryption != null) {
351 /* Substruct sizeof encryption header.
352 * This value adds in writeBytes() when encryption header
353 * is written.
354 */
355 written -= zipCryption.getEncryptionHeaderSize();
356 }
357
358 break;
359 case STORED:
360 // we already know that both e.size and e.csize are the same
361 if (e.size != written - locoff) {
362 throw new ZipException(
363 "invalid entry size (expected " + e.size +
364 " but got " + (written - locoff) + " bytes)");
365 }
366 if (e.crc != crc.getValue()) {
367 throw new ZipException(
368 "invalid entry crc-32 (expected 0x" +
369 Long.toHexString(e.crc) + " but got 0x" +
370 Long.toHexString(crc.getValue()) + ")");
371 }
372 break;
373 default:
374 throw new ZipException("invalid compression method");
375 }
376 crc.reset();
377 current = null;
378 }
379 }
380
381 /**
382 * Writes an array of bytes to the current ZIP entry data. This method
383 * will block until all the bytes are written.
384 * @param b the data to be written
385 * @param off the start offset in the data
386 * @param len the number of bytes that are written
387 * @exception ZipException if a ZIP file error has occurred
388 * @exception IOException if an I/O error has occurred
389 */
390 public synchronized void write(byte[] b, int off, int len)
391 throws IOException
392 {
393 ensureOpen();
394 if (off < 0 || len < 0 || off > b.length - len) {
395 throw new IndexOutOfBoundsException();
396 } else if (len == 0) {
397 return;
398 }
399
400 if (current == null) {
401 throw new ZipException("no current ZIP entry");
402 }
403 ZipEntry entry = current.entry;
404 switch (entry.method) {
405 case DEFLATED:
406 super.write(b, off, len);
407 crc.update(b, off, len);
408 break;
409 case STORED:
410 written += len;
411 if (written - locoff > entry.size) {
412 throw new ZipException(
413 "attempt to write past end of STORED entry");
414 }
415
416 crc.update(b, off, len);
417
418 if (zipCryption != null) {
419 zipCryption.encryptBytes(b, off, len);
420 }
421
422 out.write(b, off, len);
423 break;
424 default:
425 throw new ZipException("invalid compression method");
426 }
427 }
428
429 /**
430 * Finishes writing the contents of the ZIP output stream without closing
431 * the underlying stream. Use this method when applying multiple filters
432 * in succession to the same output stream.
433 * @exception ZipException if a ZIP file error has occurred
434 * @exception IOException if an I/O exception has occurred
435 */
436 public void finish() throws IOException {
437 ensureOpen();
438 if (finished) {
439 return;
440 }
441 if (current != null) {
442 closeEntry();
443 }
444 // write central directory
445 long off = written;
446 for (XEntry xentry : xentries)
447 writeCEN(xentry);
448 writeEND(off, written - off);
449 finished = true;
450 }
451
452 /**
453 * Closes the ZIP output stream as well as the stream being filtered.
454 * @exception ZipException if a ZIP file error has occurred
455 * @exception IOException if an I/O error has occurred
456 */
457 public void close() throws IOException {
458 if (!closed) {
459 super.close();
460 closed = true;
461 }
462 }
463
464 /*
465 * Writes local file (LOC) header for specified entry.
466 */
467 private void writeLOC(XEntry xentry) throws IOException {
468 ZipEntry e = xentry.entry;
469 int flag = e.flag;
470 boolean hasZip64 = false;
471 int elen = getExtraLen(e.extra);
472
473 writeInt(LOCSIG); // LOC header signature
474 if ((flag & 8) == 8) {
475 writeShort(version(e)); // version needed to extract
476 writeShort(flag); // general purpose bit flag
477 writeShort(e.method); // compression method
478 writeInt(e.xdostime); // last modification time
479 // store size, uncompressed size, and crc-32 in data descriptor
480 // immediately following compressed entry data
481 writeInt(0);
482 writeInt(0);
483 writeInt(0);
484 } else {
485 if (e.csize >= ZIP64_MAGICVAL || e.size >= ZIP64_MAGICVAL) {
486 hasZip64 = true;
487 writeShort(45); // ver 4.5 for zip64
488 } else {
489 writeShort(version(e)); // version needed to extract
490 }
491 writeShort(flag); // general purpose bit flag
492 writeShort(e.method); // compression method
493 writeInt(e.xdostime); // last modification time
494 writeInt(e.crc); // crc-32
495 if (hasZip64) {
496 writeInt(ZIP64_MAGICVAL);
497 writeInt(ZIP64_MAGICVAL);
498 elen += 20; //headid(2) + size(2) + size(8) + csize(8)
499 } else {
500 writeInt(e.csize); // compressed size
501 writeInt(e.size); // uncompressed size
502 }
503 }
504 byte[] nameBytes = zc.getBytes(e.name);
505 writeShort(nameBytes.length);
506
507 int elenEXTT = 0; // info-zip extended timestamp
508 int flagEXTT = 0;
509 if (e.mtime != null) {
510 elenEXTT += 4;
511 flagEXTT |= EXTT_FLAG_LMT;
512 }
513 if (e.atime != null) {
514 elenEXTT += 4;
515 flagEXTT |= EXTT_FLAG_LAT;
516 }
517 if (e.ctime != null) {
518 elenEXTT += 4;
519 flagEXTT |= EXTT_FLAT_CT;
520 }
521 if (flagEXTT != 0)
522 elen += (elenEXTT + 5); // headid(2) + size(2) + flag(1) + data
523 writeShort(elen);
524 writeBytes(nameBytes, 0, nameBytes.length);
525 if (hasZip64) {
526 writeShort(ZIP64_EXTID);
527 writeShort(16);
528 writeLong(e.size);
529 writeLong(e.csize);
530 }
531 if (flagEXTT != 0) {
532 writeShort(EXTID_EXTT);
533 writeShort(elenEXTT + 1); // flag + data
534 writeByte(flagEXTT);
535 if (e.mtime != null)
536 writeInt(fileTimeToUnixTime(e.mtime));
537 if (e.atime != null)
538 writeInt(fileTimeToUnixTime(e.atime));
539 if (e.ctime != null)
540 writeInt(fileTimeToUnixTime(e.ctime));
541 }
542 writeExtra(e.extra);
543 locoff = written;
544 }
545
546 /*
547 * Writes extra data descriptor (EXT) for specified entry.
548 */
549 private void writeEXT(ZipEntry e) throws IOException {
550 writeInt(EXTSIG); // EXT header signature
551 writeInt(e.crc); // crc-32
552
553 if (zipCryption != null) {
554 e.csize += zipCryption.getEncryptionHeaderSize();
555 }
556
557 if (e.csize >= ZIP64_MAGICVAL || e.size >= ZIP64_MAGICVAL) {
558 writeLong(e.csize);
559 writeLong(e.size);
560 } else {
561 writeInt(e.csize); // compressed size
562 writeInt(e.size); // uncompressed size
563 }
564 }
565
566 /*
567 * Write central directory (CEN) header for specified entry.
568 * REMIND: add support for file attributes
569 */
570 private void writeCEN(XEntry xentry) throws IOException {
571 ZipEntry e = xentry.entry;
572 int flag = e.flag;
573 int version = version(e);
574 long csize = e.csize;
575 long size = e.size;
576 long offset = xentry.offset;
577 int elenZIP64 = 0;
578 boolean hasZip64 = false;
579
580 if (e.csize >= ZIP64_MAGICVAL) {
581 csize = ZIP64_MAGICVAL;
582 elenZIP64 += 8; // csize(8)
583 hasZip64 = true;
584 }
585 if (e.size >= ZIP64_MAGICVAL) {
586 size = ZIP64_MAGICVAL; // size(8)
587 elenZIP64 += 8;
588 hasZip64 = true;
589 }
590 if (xentry.offset >= ZIP64_MAGICVAL) {
591 offset = ZIP64_MAGICVAL;
592 elenZIP64 += 8; // offset(8)
593 hasZip64 = true;
594 }
595 writeInt(CENSIG); // CEN header signature
596 if (hasZip64) {
597 writeShort(45); // ver 4.5 for zip64
598 writeShort(45);
599 } else {
600 writeShort(version); // version made by
601 writeShort(version); // version needed to extract
602 }
603 writeShort(flag); // general purpose bit flag
604 writeShort(e.method); // compression method
605 writeInt(e.xdostime); // last modification time
606 writeInt(e.crc); // crc-32
607 writeInt(csize); // compressed size
608 writeInt(size); // uncompressed size
609 byte[] nameBytes = zc.getBytes(e.name);
610 writeShort(nameBytes.length);
611
612 int elen = getExtraLen(e.extra);
613 if (hasZip64) {
614 elen += (elenZIP64 + 4);// + headid(2) + datasize(2)
615 }
616 // cen info-zip extended timestamp only outputs mtime
617 // but set the flag for a/ctime, if present in loc
618 int flagEXTT = 0;
619 if (e.mtime != null) {
620 elen += 4; // + mtime(4)
621 flagEXTT |= EXTT_FLAG_LMT;
622 }
623 if (e.atime != null) {
624 flagEXTT |= EXTT_FLAG_LAT;
625 }
626 if (e.ctime != null) {
627 flagEXTT |= EXTT_FLAT_CT;
628 }
629 if (flagEXTT != 0) {
630 elen += 5; // headid + sz + flag
631 }
632 writeShort(elen);
633 byte[] commentBytes;
634 if (e.comment != null) {
635 commentBytes = zc.getBytes(e.comment);
636 writeShort(Math.min(commentBytes.length, 0xffff));
637 } else {
638 commentBytes = null;
639 writeShort(0);
640 }
641 writeShort(0); // starting disk number
642 writeShort(0); // internal file attributes (unused)
643 writeInt(0); // external file attributes (unused)
644 writeInt(offset); // relative offset of local header
645 writeBytes(nameBytes, 0, nameBytes.length);
646
647 // take care of EXTID_ZIP64 and EXTID_EXTT
648 if (hasZip64) {
649 writeShort(ZIP64_EXTID);// Zip64 extra
650 writeShort(elenZIP64);
651 if (size == ZIP64_MAGICVAL)
652 writeLong(e.size);
653 if (csize == ZIP64_MAGICVAL)
654 writeLong(e.csize);
655 if (offset == ZIP64_MAGICVAL)
656 writeLong(xentry.offset);
657 }
658 if (flagEXTT != 0) {
659 writeShort(EXTID_EXTT);
660 if (e.mtime != null) {
661 writeShort(5); // flag + mtime
662 writeByte(flagEXTT);
663 writeInt(fileTimeToUnixTime(e.mtime));
664 } else {
665 writeShort(1); // flag only
666 writeByte(flagEXTT);
667 }
668 }
669 writeExtra(e.extra);
670 if (commentBytes != null) {
671 writeBytes(commentBytes, 0, Math.min(commentBytes.length, 0xffff));
672 }
673 }
674
675 /*
676 * Writes end of central directory (END) header.
677 */
678 private void writeEND(long off, long len) throws IOException {
679 boolean hasZip64 = false;
680 long xlen = len;
681 long xoff = off;
682 if (xlen >= ZIP64_MAGICVAL) {
683 xlen = ZIP64_MAGICVAL;
684 hasZip64 = true;
685 }
686 if (xoff >= ZIP64_MAGICVAL) {
687 xoff = ZIP64_MAGICVAL;
688 hasZip64 = true;
689 }
690 int count = xentries.size();
691 if (count >= ZIP64_MAGICCOUNT) {
692 hasZip64 |= !inhibitZip64;
693 if (hasZip64) {
694 count = ZIP64_MAGICCOUNT;
695 }
696 }
697 if (hasZip64) {
698 long off64 = written;
699 //zip64 end of central directory record
700 writeInt(ZIP64_ENDSIG); // zip64 END record signature
701 writeLong(ZIP64_ENDHDR - 12); // size of zip64 end
702 writeShort(45); // version made by
703 writeShort(45); // version needed to extract
704 writeInt(0); // number of this disk
705 writeInt(0); // central directory start disk
706 writeLong(xentries.size()); // number of directory entires on disk
707 writeLong(xentries.size()); // number of directory entires
708 writeLong(len); // length of central directory
709 writeLong(off); // offset of central directory
710
711 //zip64 end of central directory locator
712 writeInt(ZIP64_LOCSIG); // zip64 END locator signature
713 writeInt(0); // zip64 END start disk
714 writeLong(off64); // offset of zip64 END
715 writeInt(1); // total number of disks (?)
716 }
717 writeInt(ENDSIG); // END record signature
718 writeShort(0); // number of this disk
719 writeShort(0); // central directory start disk
720 writeShort(count); // number of directory entries on disk
721 writeShort(count); // total number of directory entries
722 writeInt(xlen); // length of central directory
723 writeInt(xoff); // offset of central directory
724 if (comment != null) { // zip file comment
725 writeShort(comment.length);
726 writeBytes(comment, 0, comment.length);
727 } else {
728 writeShort(0);
729 }
730 }
731
732 /*
733 * Returns the length of extra data without EXTT and ZIP64.
734 */
735 private int getExtraLen(byte[] extra) {
736 if (extra == null)
737 return 0;
738 int skipped = 0;
739 int len = extra.length;
740 int off = 0;
741 while (off + 4 <= len) {
742 int tag = get16(extra, off);
743 int sz = get16(extra, off + 2);
744 if (sz < 0 || (off + 4 + sz) > len) {
745 break;
746 }
747 if (tag == EXTID_EXTT || tag == EXTID_ZIP64) {
748 skipped += (sz + 4);
749 }
750 off += (sz + 4);
751 }
752 return len - skipped;
753 }
754
755 /*
756 * Writes extra data without EXTT and ZIP64.
757 *
758 * Extra timestamp and ZIP64 data is handled/output separately
759 * in writeLOC and writeCEN.
760 */
761 private void writeExtra(byte[] extra) throws IOException {
762 if (extra != null) {
763 int len = extra.length;
764 int off = 0;
765 while (off + 4 <= len) {
766 int tag = get16(extra, off);
767 int sz = get16(extra, off + 2);
768 if (sz < 0 || (off + 4 + sz) > len) {
769 writeBytes(extra, off, len - off);
770 return;
771 }
772 if (tag != EXTID_EXTT && tag != EXTID_ZIP64) {
773 writeBytes(extra, off, sz + 4);
774 }
775 off += (sz + 4);
776 }
777 if (off < len) {
778 writeBytes(extra, off, len - off);
779 }
780 }
781 }
782
783 /*
784 * Writes a 8-bit byte to the output stream.
785 */
786 private void writeByte(int v) throws IOException {
787 OutputStream out = this.out;
788 out.write(v & 0xff);
789 written += 1;
790 }
791
792 /*
793 * Writes a 16-bit short to the output stream in little-endian byte order.
794 */
795 private void writeShort(int v) throws IOException {
796 OutputStream out = this.out;
797 out.write((v >>> 0) & 0xff);
798 out.write((v >>> 8) & 0xff);
799 written += 2;
800 }
801
802 /*
803 * Writes a 32-bit int to the output stream in little-endian byte order.
804 */
805 private void writeInt(long v) throws IOException {
806 OutputStream out = this.out;
807 out.write((int)((v >>> 0) & 0xff));
808 out.write((int)((v >>> 8) & 0xff));
809 out.write((int)((v >>> 16) & 0xff));
810 out.write((int)((v >>> 24) & 0xff));
811 written += 4;
812 }
813
814 /*
815 * Writes a 64-bit int to the output stream in little-endian byte order.
816 */
817 private void writeLong(long v) throws IOException {
818 OutputStream out = this.out;
819 out.write((int)((v >>> 0) & 0xff));
820 out.write((int)((v >>> 8) & 0xff));
821 out.write((int)((v >>> 16) & 0xff));
822 out.write((int)((v >>> 24) & 0xff));
823 out.write((int)((v >>> 32) & 0xff));
824 out.write((int)((v >>> 40) & 0xff));
825 out.write((int)((v >>> 48) & 0xff));
826 out.write((int)((v >>> 56) & 0xff));
827 written += 8;
828 }
829
830 /*
831 * Writes an array of bytes to the output stream.
832 */
833 private void writeBytes(byte[] b, int off, int len) throws IOException {
834 super.out.write(b, off, len);
835 written += len;
836 }
837 }