rev 50498 : 8199871: Deprecate pack200 and unpack200 tools
Reviewed-by:

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