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