1 /*
   2  * Copyright (c) 2003, 2011, 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 
  27 package com.sun.java.util.jar.pack;
  28 
  29 import java.io.BufferedInputStream;
  30 import java.io.File;
  31 import java.io.FileInputStream;
  32 import java.io.IOException;
  33 import java.io.InputStream;
  34 import java.nio.ByteBuffer;
  35 import java.util.jar.JarOutputStream;
  36 import java.util.jar.Pack200;
  37 import java.util.zip.CRC32;
  38 import java.util.zip.Deflater;
  39 import java.util.zip.ZipEntry;
  40 import java.util.zip.ZipOutputStream;
  41 
  42 class NativeUnpack {
  43     // Pointer to the native unpacker obj
  44     private long unpackerPtr;
  45 
  46     // Input stream.
  47     private BufferedInputStream in;
  48 
  49     private static synchronized native void initIDs();
  50 
  51     // Starts processing at the indicated position in the buffer.
  52     // If the buffer is null, the readInputFn callback is used to get bytes.
  53     // Returns (s<<32|f), the number of following segments and files.
  54     private synchronized native long start(ByteBuffer buf, long offset);
  55 
  56     // Returns true if there's another, and fills in the parts.
  57     private synchronized native boolean getNextFile(Object[] parts);
  58 
  59     private synchronized native ByteBuffer getUnusedInput();
  60 
  61     // Resets the engine and frees all resources.
  62     // Returns total number of bytes consumed by the engine.
  63     private synchronized native long finish();
  64 
  65     // Setting state in the unpacker.
  66     protected  synchronized native boolean setOption(String opt, String value);
  67     protected  synchronized native String getOption(String opt);
  68 
  69     private  int _verbose;
  70 
  71     // State for progress bar:
  72     private  long _byteCount;      // bytes read in current segment
  73     private  int  _segCount;       // number of segs scanned
  74     private  int  _fileCount;      // number of files written
  75     private  long _estByteLimit;   // estimate of eventual total
  76     private  int  _estSegLimit;    // ditto
  77     private  int  _estFileLimit;   // ditto
  78     private  int  _prevPercent = -1; // for monotonicity
  79 
  80     private final CRC32   _crc32 = new CRC32();
  81     private       byte[]  _buf   = new byte[1<<14];
  82 
  83     private  UnpackerImpl _p200;
  84     private  PropMap _props;
  85 
  86     static {
  87         // If loading from stand alone build uncomment this.
  88         // System.loadLibrary("unpack");
  89         java.security.AccessController.doPrivileged(
  90                 new sun.security.action.LoadLibraryAction("unpack"));





  91         initIDs();
  92     }
  93 
  94     NativeUnpack(UnpackerImpl p200) {
  95         super();
  96         _p200  = p200;
  97         _props = p200.props;
  98         p200._nunp = this;
  99     }
 100 
 101     // for JNI callbacks
 102     static private Object currentInstance() {
 103         UnpackerImpl p200 = (UnpackerImpl) Utils.getTLGlobals();
 104         return (p200 == null)? null: p200._nunp;
 105     }
 106 
 107     // Callback from the unpacker engine to get more data.
 108     private long readInputFn(ByteBuffer pbuf, long minlen) throws IOException {
 109         if (in == null)  return 0;  // nothing is readable
 110         long maxlen = pbuf.capacity() - pbuf.position();
 111         assert(minlen <= maxlen);  // don't talk nonsense
 112         long numread = 0;
 113         int steps = 0;
 114         while (numread < minlen) {
 115             steps++;
 116             // read available input, up to buf.length or maxlen
 117             int readlen = _buf.length;
 118             if (readlen > (maxlen - numread))
 119                 readlen = (int)(maxlen - numread);
 120             int nr = in.read(_buf, 0, readlen);
 121             if (nr <= 0)  break;
 122             numread += nr;
 123             assert(numread <= maxlen);
 124             // %%% get rid of this extra copy by using nio?
 125             pbuf.put(_buf, 0, nr);
 126         }
 127         if (_verbose > 1)
 128             Utils.log.fine("readInputFn("+minlen+","+maxlen+") => "+numread+" steps="+steps);
 129         if (maxlen > 100) {
 130             _estByteLimit = _byteCount + maxlen;
 131         } else {
 132             _estByteLimit = (_byteCount + numread) * 20;
 133         }
 134         _byteCount += numread;
 135         updateProgress();
 136         return numread;
 137     }
 138 
 139     private void updateProgress() {
 140         // Progress is a combination of segment reading and file writing.
 141         final double READ_WT  = 0.33;
 142         final double WRITE_WT = 0.67;
 143         double readProgress = _segCount;
 144         if (_estByteLimit > 0 && _byteCount > 0)
 145             readProgress += (double)_byteCount / _estByteLimit;
 146         double writeProgress = _fileCount;
 147         double scaledProgress
 148             = READ_WT  * readProgress  / Math.max(_estSegLimit,1)
 149             + WRITE_WT * writeProgress / Math.max(_estFileLimit,1);
 150         int percent = (int) Math.round(100*scaledProgress);
 151         if (percent > 100)  percent = 100;
 152         if (percent > _prevPercent) {
 153             _prevPercent = percent;
 154             _props.setInteger(Pack200.Unpacker.PROGRESS, percent);
 155             if (_verbose > 0)
 156                 Utils.log.info("progress = "+percent);
 157         }
 158     }
 159 
 160     private void copyInOption(String opt) {
 161         String val = _props.getProperty(opt);
 162         if (_verbose > 0)
 163             Utils.log.info("set "+opt+"="+val);
 164         if (val != null) {
 165             boolean set = setOption(opt, val);
 166             if (!set)
 167                 Utils.log.warning("Invalid option "+opt+"="+val);
 168         }
 169     }
 170 
 171     void run(InputStream inRaw, JarOutputStream jstream,
 172              ByteBuffer presetInput) throws IOException {
 173         BufferedInputStream in0 = new BufferedInputStream(inRaw);
 174         this.in = in0;    // for readInputFn to see
 175         _verbose = _props.getInteger(Utils.DEBUG_VERBOSE);
 176         // Fix for BugId: 4902477, -unpack.modification.time = 1059010598000
 177         // TODO eliminate and fix in unpack.cpp
 178 
 179         final int modtime = Pack200.Packer.KEEP.equals(_props.getProperty(Utils.UNPACK_MODIFICATION_TIME, "0")) ?
 180                 Constants.NO_MODTIME : _props.getTime(Utils.UNPACK_MODIFICATION_TIME);
 181 
 182         copyInOption(Utils.DEBUG_VERBOSE);
 183         copyInOption(Pack200.Unpacker.DEFLATE_HINT);
 184         if (modtime == Constants.NO_MODTIME)  // Dont pass KEEP && NOW
 185             copyInOption(Utils.UNPACK_MODIFICATION_TIME);
 186         updateProgress();  // reset progress bar
 187         for (;;) {
 188             // Read the packed bits.
 189             long counts = start(presetInput, 0);
 190             _byteCount = _estByteLimit = 0;  // reset partial scan counts
 191             ++_segCount;  // just finished scanning a whole segment...
 192             int nextSeg  = (int)( counts >>> 32 );
 193             int nextFile = (int)( counts >>>  0 );
 194 
 195             // Estimate eventual total number of segments and files.
 196             _estSegLimit = _segCount + nextSeg;
 197             double filesAfterThisSeg = _fileCount + nextFile;
 198             _estFileLimit = (int)( (filesAfterThisSeg *
 199                                     _estSegLimit) / _segCount );
 200 
 201             // Write the files.
 202             int[] intParts = { 0,0, 0, 0 };
 203             //    intParts = {size.hi/lo, mod, defl}
 204             Object[] parts = { intParts, null, null, null };
 205             //       parts = { {intParts}, name, data0/1 }
 206             while (getNextFile(parts)) {
 207                 //BandStructure.printArrayTo(System.out, intParts, 0, parts.length);
 208                 String name = (String) parts[1];
 209                 long   size = ( (long)intParts[0] << 32)
 210                             + (((long)intParts[1] << 32) >>> 32);
 211 
 212                 long   mtime = (modtime != Constants.NO_MODTIME ) ?
 213                                 modtime : intParts[2] ;
 214                 boolean deflateHint = (intParts[3] != 0);
 215                 ByteBuffer data0 = (ByteBuffer) parts[2];
 216                 ByteBuffer data1 = (ByteBuffer) parts[3];
 217                 writeEntry(jstream, name, mtime, size, deflateHint,
 218                            data0, data1);
 219                 ++_fileCount;
 220                 updateProgress();
 221             }
 222             presetInput = getUnusedInput();
 223             long consumed = finish();
 224             if (_verbose > 0)
 225                 Utils.log.info("bytes consumed = "+consumed);
 226             if (presetInput == null &&
 227                 !Utils.isPackMagic(Utils.readMagic(in0))) {
 228                 break;
 229             }
 230             if (_verbose > 0 ) {
 231                 if (presetInput != null)
 232                     Utils.log.info("unused input = "+presetInput);
 233             }
 234         }
 235     }
 236 
 237     void run(InputStream in, JarOutputStream jstream) throws IOException {
 238         run(in, jstream, null);
 239     }
 240 
 241     void run(File inFile, JarOutputStream jstream) throws IOException {
 242         // %%% maybe memory-map the file, and pass it straight into unpacker
 243         ByteBuffer mappedFile = null;
 244         try (FileInputStream fis = new FileInputStream(inFile)) {
 245             run(fis, jstream, mappedFile);
 246         }
 247         // Note:  caller is responsible to finish with jstream.
 248     }
 249 
 250     private void writeEntry(JarOutputStream j, String name,
 251                             long mtime, long lsize, boolean deflateHint,
 252                             ByteBuffer data0, ByteBuffer data1) throws IOException {
 253         int size = (int)lsize;
 254         if (size != lsize)
 255             throw new IOException("file too large: "+lsize);
 256 
 257         CRC32 crc32 = _crc32;
 258 
 259         if (_verbose > 1)
 260             Utils.log.fine("Writing entry: "+name+" size="+size
 261                              +(deflateHint?" deflated":""));
 262 
 263         if (_buf.length < size) {
 264             int newSize = size;
 265             while (newSize < _buf.length) {
 266                 newSize <<= 1;
 267                 if (newSize <= 0) {
 268                     newSize = size;
 269                     break;
 270                 }
 271             }
 272             _buf = new byte[newSize];
 273         }
 274         assert(_buf.length >= size);
 275 
 276         int fillp = 0;
 277         if (data0 != null) {
 278             int size0 = data0.capacity();
 279             data0.get(_buf, fillp, size0);
 280             fillp += size0;
 281         }
 282         if (data1 != null) {
 283             int size1 = data1.capacity();
 284             data1.get(_buf, fillp, size1);
 285             fillp += size1;
 286         }
 287         while (fillp < size) {
 288             // Fill in rest of data from the stream itself.
 289             int nr = in.read(_buf, fillp, size - fillp);
 290             if (nr <= 0)  throw new IOException("EOF at end of archive");
 291             fillp += nr;
 292         }
 293 
 294         ZipEntry z = new ZipEntry(name);
 295         z.setTime(mtime * 1000);
 296 
 297         if (size == 0) {
 298             z.setMethod(ZipOutputStream.STORED);
 299             z.setSize(0);
 300             z.setCrc(0);
 301             z.setCompressedSize(0);
 302         } else if (!deflateHint) {
 303             z.setMethod(ZipOutputStream.STORED);
 304             z.setSize(size);
 305             z.setCompressedSize(size);
 306             crc32.reset();
 307             crc32.update(_buf, 0, size);
 308             z.setCrc(crc32.getValue());
 309         } else {
 310             z.setMethod(Deflater.DEFLATED);
 311             z.setSize(size);
 312         }
 313 
 314         j.putNextEntry(z);
 315 
 316         if (size > 0)
 317             j.write(_buf, 0, size);
 318 
 319         j.closeEntry();
 320         if (_verbose > 0) Utils.log.info("Writing " + Utils.zeString(z));
 321     }
 322 }
--- EOF ---