1 /*
   2  * Copyright (c) 1996, 2010, 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.StandardCharset;
  32 import java.util.Vector;
  33 import java.util.HashSet;
  34 import static java.util.zip.ZipConstants64.*;
  35 
  36 /**
  37  * This class implements an output stream filter for writing files in the
  38  * ZIP file format. Includes support for both compressed and uncompressed
  39  * entries.
  40  *
  41  * @author      David Connelly
  42  */
  43 public
  44 class ZipOutputStream extends DeflaterOutputStream implements ZipConstants {
  45 
  46     private static class XEntry {
  47         public final ZipEntry entry;
  48         public final long offset;
  49         public XEntry(ZipEntry entry, long offset) {
  50             this.entry = entry;
  51             this.offset = offset;
  52         }
  53     }
  54 
  55     private XEntry current;
  56     private Vector<XEntry> xentries = new Vector<>();
  57     private HashSet<String> names = new HashSet<>();
  58     private CRC32 crc = new CRC32();
  59     private long written = 0;
  60     private long locoff = 0;
  61     private byte[] comment;
  62     private int method = DEFLATED;
  63     private boolean finished;
  64 
  65     private boolean closed = false;
  66 
  67     private final ZipCoder zc;
  68 
  69     private static int version(ZipEntry e) throws ZipException {
  70         switch (e.method) {
  71         case DEFLATED: return 20;
  72         case STORED:   return 10;
  73         default: throw new ZipException("unsupported compression method");
  74         }
  75     }
  76 
  77     /**
  78      * Checks to make sure that this stream has not been closed.
  79      */
  80     private void ensureOpen() throws IOException {
  81         if (closed) {
  82             throw new IOException("Stream closed");
  83         }
  84     }
  85     /**
  86      * Compression method for uncompressed (STORED) entries.
  87      */
  88     public static final int STORED = ZipEntry.STORED;
  89 
  90     /**
  91      * Compression method for compressed (DEFLATED) entries.
  92      */
  93     public static final int DEFLATED = ZipEntry.DEFLATED;
  94 
  95     /**
  96      * Creates a new ZIP output stream.
  97      *
  98      * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used
  99      * to encode the entry names and comments.
 100      *
 101      * @param out the actual output stream
 102      */
 103     public ZipOutputStream(OutputStream out) {
 104         this(out, StandardCharset.UTF_8);
 105     }
 106 
 107     /**
 108      * Creates a new ZIP output stream.
 109      *
 110      * @param out the actual output stream
 111      *
 112      * @param charset the {@linkplain java.nio.charset.Charset charset}
 113      *                to be used to encode the entry names and comments
 114      *
 115      * @since 1.7
 116      */
 117     public ZipOutputStream(OutputStream out, Charset charset) {
 118         super(out, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
 119         if (charset == null)
 120             throw new NullPointerException("charset is null");
 121         this.zc = ZipCoder.get(charset);
 122         usesDefaultDeflater = true;
 123     }
 124 
 125     /**
 126      * Sets the ZIP file comment.
 127      * @param comment the comment string
 128      * @exception IllegalArgumentException if the length of the specified
 129      *            ZIP file comment is greater than 0xFFFF bytes
 130      */
 131     public void setComment(String comment) {
 132         if (comment != null) {
 133             this.comment = zc.getBytes(comment);
 134             if (this.comment.length > 0xffff)
 135                 throw new IllegalArgumentException("ZIP file comment too long.");
 136         }
 137     }
 138 
 139     /**
 140      * Sets the default compression method for subsequent entries. This
 141      * default will be used whenever the compression method is not specified
 142      * for an individual ZIP file entry, and is initially set to DEFLATED.
 143      * @param method the default compression method
 144      * @exception IllegalArgumentException if the specified compression method
 145      *            is invalid
 146      */
 147     public void setMethod(int method) {
 148         if (method != DEFLATED && method != STORED) {
 149             throw new IllegalArgumentException("invalid compression method");
 150         }
 151         this.method = method;
 152     }
 153 
 154     /**
 155      * Sets the compression level for subsequent entries which are DEFLATED.
 156      * The default setting is DEFAULT_COMPRESSION.
 157      * @param level the compression level (0-9)
 158      * @exception IllegalArgumentException if the compression level is invalid
 159      */
 160     public void setLevel(int level) {
 161         def.setLevel(level);
 162     }
 163 
 164     /**
 165      * Begins writing a new ZIP file entry and positions the stream to the
 166      * start of the entry data. Closes the current entry if still active.
 167      * The default compression method will be used if no compression method
 168      * was specified for the entry, and the current time will be used if
 169      * the entry has no set modification time.
 170      * @param e the ZIP entry to be written
 171      * @exception ZipException if a ZIP format error has occurred
 172      * @exception IOException if an I/O error has occurred
 173      */
 174     public void putNextEntry(ZipEntry e) throws IOException {
 175         ensureOpen();
 176         if (current != null) {
 177             closeEntry();       // close previous entry
 178         }
 179         if (e.time == -1) {
 180             e.setTime(System.currentTimeMillis());
 181         }
 182         if (e.method == -1) {
 183             e.method = method;  // use default method
 184         }
 185         // store size, compressed size, and crc-32 in LOC header
 186         e.flag = 0;
 187         switch (e.method) {
 188         case DEFLATED:
 189             // store size, compressed size, and crc-32 in data descriptor
 190             // immediately following the compressed entry data
 191             if (e.size  == -1 || e.csize == -1 || e.crc   == -1)
 192                 e.flag = 8;
 193 
 194             break;
 195         case STORED:
 196             // compressed size, uncompressed size, and crc-32 must all be
 197             // set for entries using STORED compression method
 198             if (e.size == -1) {
 199                 e.size = e.csize;
 200             } else if (e.csize == -1) {
 201                 e.csize = e.size;
 202             } else if (e.size != e.csize) {
 203                 throw new ZipException(
 204                     "STORED entry where compressed != uncompressed size");
 205             }
 206             if (e.size == -1 || e.crc == -1) {
 207                 throw new ZipException(
 208                     "STORED entry missing size, compressed size, or crc-32");
 209             }
 210             break;
 211         default:
 212             throw new ZipException("unsupported compression method");
 213         }
 214         if (! names.add(e.name)) {
 215             throw new ZipException("duplicate entry: " + e.name);
 216         }
 217         if (zc.isUTF8())
 218             e.flag |= EFS;
 219         current = new XEntry(e, written);
 220         xentries.add(current);
 221         writeLOC(current);
 222     }
 223 
 224     /**
 225      * Closes the current ZIP entry and positions the stream for writing
 226      * the next entry.
 227      * @exception ZipException if a ZIP format error has occurred
 228      * @exception IOException if an I/O error has occurred
 229      */
 230     public void closeEntry() throws IOException {
 231         ensureOpen();
 232         if (current != null) {
 233             ZipEntry e = current.entry;
 234             switch (e.method) {
 235             case DEFLATED:
 236                 def.finish();
 237                 while (!def.finished()) {
 238                     deflate();
 239                 }
 240                 if ((e.flag & 8) == 0) {
 241                     // verify size, compressed size, and crc-32 settings
 242                     if (e.size != def.getBytesRead()) {
 243                         throw new ZipException(
 244                             "invalid entry size (expected " + e.size +
 245                             " but got " + def.getBytesRead() + " bytes)");
 246                     }
 247                     if (e.csize != def.getBytesWritten()) {
 248                         throw new ZipException(
 249                             "invalid entry compressed size (expected " +
 250                             e.csize + " but got " + def.getBytesWritten() + " bytes)");
 251                     }
 252                     if (e.crc != crc.getValue()) {
 253                         throw new ZipException(
 254                             "invalid entry CRC-32 (expected 0x" +
 255                             Long.toHexString(e.crc) + " but got 0x" +
 256                             Long.toHexString(crc.getValue()) + ")");
 257                     }
 258                 } else {
 259                     e.size  = def.getBytesRead();
 260                     e.csize = def.getBytesWritten();
 261                     e.crc = crc.getValue();
 262                     writeEXT(e);
 263                 }
 264                 def.reset();
 265                 written += e.csize;
 266                 break;
 267             case STORED:
 268                 // we already know that both e.size and e.csize are the same
 269                 if (e.size != written - locoff) {
 270                     throw new ZipException(
 271                         "invalid entry size (expected " + e.size +
 272                         " but got " + (written - locoff) + " bytes)");
 273                 }
 274                 if (e.crc != crc.getValue()) {
 275                     throw new ZipException(
 276                          "invalid entry crc-32 (expected 0x" +
 277                          Long.toHexString(e.crc) + " but got 0x" +
 278                          Long.toHexString(crc.getValue()) + ")");
 279                 }
 280                 break;
 281             default:
 282                 throw new ZipException("invalid compression method");
 283             }
 284             crc.reset();
 285             current = null;
 286         }
 287     }
 288 
 289     /**
 290      * Writes an array of bytes to the current ZIP entry data. This method
 291      * will block until all the bytes are written.
 292      * @param b the data to be written
 293      * @param off the start offset in the data
 294      * @param len the number of bytes that are written
 295      * @exception ZipException if a ZIP file error has occurred
 296      * @exception IOException if an I/O error has occurred
 297      */
 298     public synchronized void write(byte[] b, int off, int len)
 299         throws IOException
 300     {
 301         ensureOpen();
 302         if (off < 0 || len < 0 || off > b.length - len) {
 303             throw new IndexOutOfBoundsException();
 304         } else if (len == 0) {
 305             return;
 306         }
 307 
 308         if (current == null) {
 309             throw new ZipException("no current ZIP entry");
 310         }
 311         ZipEntry entry = current.entry;
 312         switch (entry.method) {
 313         case DEFLATED:
 314             super.write(b, off, len);
 315             break;
 316         case STORED:
 317             written += len;
 318             if (written - locoff > entry.size) {
 319                 throw new ZipException(
 320                     "attempt to write past end of STORED entry");
 321             }
 322             out.write(b, off, len);
 323             break;
 324         default:
 325             throw new ZipException("invalid compression method");
 326         }
 327         crc.update(b, off, len);
 328     }
 329 
 330     /**
 331      * Finishes writing the contents of the ZIP output stream without closing
 332      * the underlying stream. Use this method when applying multiple filters
 333      * in succession to the same output stream.
 334      * @exception ZipException if a ZIP file error has occurred
 335      * @exception IOException if an I/O exception has occurred
 336      */
 337     public void finish() throws IOException {
 338         ensureOpen();
 339         if (finished) {
 340             return;
 341         }
 342         if (current != null) {
 343             closeEntry();
 344         }
 345         // write central directory
 346         long off = written;
 347         for (XEntry xentry : xentries)
 348             writeCEN(xentry);
 349         writeEND(off, written - off);
 350         finished = true;
 351     }
 352 
 353     /**
 354      * Closes the ZIP output stream as well as the stream being filtered.
 355      * @exception ZipException if a ZIP file error has occurred
 356      * @exception IOException if an I/O error has occurred
 357      */
 358     public void close() throws IOException {
 359         if (!closed) {
 360             super.close();
 361             closed = true;
 362         }
 363     }
 364 
 365     /*
 366      * Writes local file (LOC) header for specified entry.
 367      */
 368     private void writeLOC(XEntry xentry) throws IOException {
 369         ZipEntry e = xentry.entry;
 370         int flag = e.flag;
 371         int elen = (e.extra != null) ? e.extra.length : 0;
 372         boolean hasZip64 = false;
 373 
 374         writeInt(LOCSIG);               // LOC header signature
 375 
 376         if ((flag & 8) == 8) {
 377             writeShort(version(e));     // version needed to extract
 378             writeShort(flag);           // general purpose bit flag
 379             writeShort(e.method);       // compression method
 380             writeInt(e.time);           // last modification time
 381 
 382             // store size, uncompressed size, and crc-32 in data descriptor
 383             // immediately following compressed entry data
 384             writeInt(0);
 385             writeInt(0);
 386             writeInt(0);
 387         } else {
 388             if (e.csize >= ZIP64_MAGICVAL || e.size >= ZIP64_MAGICVAL) {
 389                 hasZip64 = true;
 390                 writeShort(45);         // ver 4.5 for zip64
 391             } else {
 392                 writeShort(version(e)); // version needed to extract
 393             }
 394             writeShort(flag);           // general purpose bit flag
 395             writeShort(e.method);       // compression method
 396             writeInt(e.time);           // last modification time
 397             writeInt(e.crc);            // crc-32
 398             if (hasZip64) {
 399                 writeInt(ZIP64_MAGICVAL);
 400                 writeInt(ZIP64_MAGICVAL);
 401                 elen += 20;        //headid(2) + size(2) + size(8) + csize(8)
 402             } else {
 403                 writeInt(e.csize);  // compressed size
 404                 writeInt(e.size);   // uncompressed size
 405             }
 406         }
 407         byte[] nameBytes = zc.getBytes(e.name);
 408         writeShort(nameBytes.length);
 409         writeShort(elen);
 410         writeBytes(nameBytes, 0, nameBytes.length);
 411         if (hasZip64) {
 412             writeShort(ZIP64_EXTID);
 413             writeShort(16);
 414             writeLong(e.size);
 415             writeLong(e.csize);
 416         }
 417         if (e.extra != null) {
 418             writeBytes(e.extra, 0, e.extra.length);
 419         }
 420         locoff = written;
 421     }
 422 
 423     /*
 424      * Writes extra data descriptor (EXT) for specified entry.
 425      */
 426     private void writeEXT(ZipEntry e) throws IOException {
 427         writeInt(EXTSIG);           // EXT header signature
 428         writeInt(e.crc);            // crc-32
 429         if (e.csize >= ZIP64_MAGICVAL || e.size >= ZIP64_MAGICVAL) {
 430             writeLong(e.csize);
 431             writeLong(e.size);
 432         } else {
 433             writeInt(e.csize);          // compressed size
 434             writeInt(e.size);           // uncompressed size
 435         }
 436     }
 437 
 438     /*
 439      * Write central directory (CEN) header for specified entry.
 440      * REMIND: add support for file attributes
 441      */
 442     private void writeCEN(XEntry xentry) throws IOException {
 443         ZipEntry e  = xentry.entry;
 444         int flag = e.flag;
 445         int version = version(e);
 446 
 447         long csize = e.csize;
 448         long size = e.size;
 449         long offset = xentry.offset;
 450         int e64len = 0;
 451         boolean hasZip64 = false;
 452         if (e.csize >= ZIP64_MAGICVAL) {
 453             csize = ZIP64_MAGICVAL;
 454             e64len += 8;              // csize(8)
 455             hasZip64 = true;
 456         }
 457         if (e.size >= ZIP64_MAGICVAL) {
 458             size = ZIP64_MAGICVAL;    // size(8)
 459             e64len += 8;
 460             hasZip64 = true;
 461         }
 462         if (xentry.offset >= ZIP64_MAGICVAL) {
 463             offset = ZIP64_MAGICVAL;
 464             e64len += 8;              // offset(8)
 465             hasZip64 = true;
 466         }
 467         writeInt(CENSIG);           // CEN header signature
 468         if (hasZip64) {
 469             writeShort(45);         // ver 4.5 for zip64
 470             writeShort(45);
 471         } else {
 472             writeShort(version);    // version made by
 473             writeShort(version);    // version needed to extract
 474         }
 475         writeShort(flag);           // general purpose bit flag
 476         writeShort(e.method);       // compression method
 477         writeInt(e.time);           // last modification time
 478         writeInt(e.crc);            // crc-32
 479         writeInt(csize);            // compressed size
 480         writeInt(size);             // uncompressed size
 481         byte[] nameBytes = zc.getBytes(e.name);
 482         writeShort(nameBytes.length);
 483         if (hasZip64) {
 484             // + headid(2) + datasize(2)
 485             writeShort(e64len + 4 + (e.extra != null ? e.extra.length : 0));
 486         } else {
 487             writeShort(e.extra != null ? e.extra.length : 0);
 488         }
 489         byte[] commentBytes;
 490         if (e.comment != null) {
 491             commentBytes = zc.getBytes(e.comment);
 492             writeShort(Math.min(commentBytes.length, 0xffff));
 493         } else {
 494             commentBytes = null;
 495             writeShort(0);
 496         }
 497         writeShort(0);              // starting disk number
 498         writeShort(0);              // internal file attributes (unused)
 499         writeInt(0);                // external file attributes (unused)
 500         writeInt(offset);           // relative offset of local header
 501         writeBytes(nameBytes, 0, nameBytes.length);
 502         if (hasZip64) {
 503             writeShort(ZIP64_EXTID);// Zip64 extra
 504             writeShort(e64len);
 505             if (size == ZIP64_MAGICVAL)
 506                 writeLong(e.size);
 507             if (csize == ZIP64_MAGICVAL)
 508                 writeLong(e.csize);
 509             if (offset == ZIP64_MAGICVAL)
 510                 writeLong(xentry.offset);
 511         }
 512         if (e.extra != null) {
 513             writeBytes(e.extra, 0, e.extra.length);
 514         }
 515         if (commentBytes != null) {
 516             writeBytes(commentBytes, 0, Math.min(commentBytes.length, 0xffff));
 517         }
 518     }
 519 
 520     /*
 521      * Writes end of central directory (END) header.
 522      */
 523     private void writeEND(long off, long len) throws IOException {
 524         boolean hasZip64 = false;
 525         long xlen = len;
 526         long xoff = off;
 527         if (xlen >= ZIP64_MAGICVAL) {
 528             xlen = ZIP64_MAGICVAL;
 529             hasZip64 = true;
 530         }
 531         if (xoff >= ZIP64_MAGICVAL) {
 532             xoff = ZIP64_MAGICVAL;
 533             hasZip64 = true;
 534         }
 535         int count = xentries.size();
 536         if (count >= ZIP64_MAGICCOUNT) {
 537             count = ZIP64_MAGICCOUNT;
 538             hasZip64 = true;
 539         }
 540         if (hasZip64) {
 541             long off64 = written;
 542             //zip64 end of central directory record
 543             writeInt(ZIP64_ENDSIG);        // zip64 END record signature
 544             writeLong(ZIP64_ENDHDR - 12);  // size of zip64 end
 545             writeShort(45);                // version made by
 546             writeShort(45);                // version needed to extract
 547             writeInt(0);                   // number of this disk
 548             writeInt(0);                   // central directory start disk
 549             writeLong(xentries.size());    // number of directory entires on disk
 550             writeLong(xentries.size());    // number of directory entires
 551             writeLong(len);                // length of central directory
 552             writeLong(off);                // offset of central directory
 553 
 554             //zip64 end of central directory locator
 555             writeInt(ZIP64_LOCSIG);        // zip64 END locator signature
 556             writeInt(0);                   // zip64 END start disk
 557             writeLong(off64);              // offset of zip64 END
 558             writeInt(1);                   // total number of disks (?)
 559         }
 560         writeInt(ENDSIG);                 // END record signature
 561         writeShort(0);                    // number of this disk
 562         writeShort(0);                    // central directory start disk
 563         writeShort(count);                // number of directory entries on disk
 564         writeShort(count);                // total number of directory entries
 565         writeInt(xlen);                   // length of central directory
 566         writeInt(xoff);                   // offset of central directory
 567         if (comment != null) {            // zip file comment
 568             writeShort(comment.length);
 569             writeBytes(comment, 0, comment.length);
 570         } else {
 571             writeShort(0);
 572         }
 573     }
 574 
 575     /*
 576      * Writes a 16-bit short to the output stream in little-endian byte order.
 577      */
 578     private void writeShort(int v) throws IOException {
 579         OutputStream out = this.out;
 580         out.write((v >>> 0) & 0xff);
 581         out.write((v >>> 8) & 0xff);
 582         written += 2;
 583     }
 584 
 585     /*
 586      * Writes a 32-bit int to the output stream in little-endian byte order.
 587      */
 588     private void writeInt(long v) throws IOException {
 589         OutputStream out = this.out;
 590         out.write((int)((v >>>  0) & 0xff));
 591         out.write((int)((v >>>  8) & 0xff));
 592         out.write((int)((v >>> 16) & 0xff));
 593         out.write((int)((v >>> 24) & 0xff));
 594         written += 4;
 595     }
 596 
 597     /*
 598      * Writes a 64-bit int to the output stream in little-endian byte order.
 599      */
 600     private void writeLong(long v) throws IOException {
 601         OutputStream out = this.out;
 602         out.write((int)((v >>>  0) & 0xff));
 603         out.write((int)((v >>>  8) & 0xff));
 604         out.write((int)((v >>> 16) & 0xff));
 605         out.write((int)((v >>> 24) & 0xff));
 606         out.write((int)((v >>> 32) & 0xff));
 607         out.write((int)((v >>> 40) & 0xff));
 608         out.write((int)((v >>> 48) & 0xff));
 609         out.write((int)((v >>> 56) & 0xff));
 610         written += 8;
 611     }
 612 
 613     /*
 614      * Writes an array of bytes to the output stream.
 615      */
 616     private void writeBytes(byte[] b, int off, int len) throws IOException {
 617         super.out.write(b, off, len);
 618         written += len;
 619     }
 620 }