1 /*
   2  * Copyright (c) 2005, 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.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @bug 4770745 6234507 6303183 8048990
  26  * @summary test a variety of zip file entries
  27  * @author Martin Buchholz
  28  * @key randomness
  29  */
  30 
  31 import java.util.*;
  32 import java.util.zip.*;
  33 import java.util.jar.*;
  34 import java.io.*;
  35 
  36 public class Assortment {
  37     static int passed = 0, failed = 0;
  38 
  39     static void fail(String msg) {
  40         failed++;
  41         new Exception(msg).printStackTrace();
  42     }
  43 
  44     static void unexpected(Throwable t) {
  45         failed++;
  46         t.printStackTrace();
  47     }
  48 
  49     static void check(boolean condition, String msg) {
  50         if (! condition)
  51             fail(msg);
  52     }
  53 
  54     static void check(boolean condition) {
  55         check(condition, "Something's wrong");
  56     }
  57 
  58     static final int get16(byte b[], int off) {
  59         return Byte.toUnsignedInt(b[off]) | (Byte.toUnsignedInt(b[off+1]) << 8);
  60     }
  61 
  62     // check if all "expected" extra fields equal to their
  63     // corresponding fields in "extra". The "extra" might have
  64     // timestamp fields added by ZOS.
  65     static boolean equalsExtraData(byte[] expected, byte[] extra) {
  66         if (expected == null)
  67             return true;
  68         int off = 0;
  69         int len = expected.length;
  70         while (off + 4 < len) {
  71             int tag = get16(expected, off);
  72             int sz = get16(expected, off + 2);
  73             int off0 = 0;
  74             int len0 = extra.length;
  75             boolean matched = false;
  76             while (off0 + 4 < len0) {
  77                 int tag0 = get16(extra, off0);
  78                 int sz0 = get16(extra, off0 + 2);
  79                 if (tag == tag0 && sz == sz0) {
  80                     matched = true;
  81                     for (int i = 0; i < sz; i++) {
  82                         if (expected[off + i] != extra[off0 +i])
  83                             matched = false;
  84                     }
  85                     break;
  86                 }
  87                 off0 += (4 + sz0);
  88             }
  89             if (!matched)
  90                 return false;
  91             off += (4 + sz);
  92         }
  93         return true;
  94     }
  95 
  96     private static class Entry {
  97         private String name;
  98         private int    method;
  99         private byte[] data;
 100         private byte[] extra;
 101         private String comment;
 102 
 103         Entry(String name,
 104               int    method,
 105               byte[] data,
 106               byte[] extra,
 107               String comment) {
 108             this.name    = name;
 109             this.method  = method;
 110             this.data    = data;
 111             this.extra   = extra;
 112             this.comment = comment;
 113         }
 114 
 115         void write(ZipOutputStream s) throws Exception {
 116             ZipEntry e = new ZipEntry(name);
 117             CRC32 crc32 = new CRC32();
 118             e.setMethod(method);
 119             if (method == ZipEntry.STORED) {
 120                 e.setSize(data == null ? 0 : data.length);
 121                 crc32.reset();
 122                 if (data != null) crc32.update(data);
 123                 e.setCrc(crc32.getValue());
 124             } else {
 125                 e.setSize(0);
 126                 e.setCrc(0);
 127             }
 128             if (comment != null) e.setComment(comment);
 129             if (extra   != null) e.setExtra(extra);
 130             s.putNextEntry(e);
 131             if (data != null) s.write(data);
 132         }
 133 
 134         byte[] getData(ZipFile f, ZipEntry e) throws Exception {
 135             byte[] fdata = new byte[(int)e.getSize()];
 136             InputStream is = f.getInputStream(e);
 137             is.read(fdata);
 138             return fdata;
 139         }
 140 
 141         void verify(ZipFile f, ZipEntry e) throws Exception {
 142             verify(e, getData(f, e));
 143         }
 144 
 145         void verify(ZipEntry e, byte[] eData) throws Exception {
 146             byte[] data  = (this.data == null) ? new byte[]{} : this.data;
 147             byte[] extra = (this.extra != null && this.extra.length == 0) ?
 148                 null : this.extra;
 149             check(name.equals(e.getName()));
 150             check(method == e.getMethod());
 151             check((((comment == null) || comment.equals(""))
 152                    && (e.getComment() == null))
 153                   || comment.equals(e.getComment()));
 154             check(equalsExtraData(extra, e.getExtra()));
 155             check(Arrays.equals(data, eData));
 156             check(e.getSize() == data.length);
 157             check((method == ZipEntry.DEFLATED) ||
 158                   (e.getCompressedSize() == data.length));
 159         }
 160 
 161         void verify(ZipFile f) throws Exception {
 162             ZipEntry e = f.getEntry(name);
 163             verify(e, getData(f, e));
 164         }
 165 
 166         void verifyZipInputStream(ZipInputStream s) throws Exception {
 167             ZipEntry e = s.getNextEntry();
 168 
 169             byte[] data = (this.data == null) ? new byte[]{} : this.data;
 170             byte[] otherData = new byte[data.length];
 171             s.read(otherData);
 172             check(Arrays.equals(data, otherData));
 173 
 174             byte[] extra = (this.extra != null && this.extra.length == 0) ?
 175                 null : this.extra;
 176             check(equalsExtraData(extra, e.getExtra()));
 177             check(name.equals(e.getName()));
 178             check(method == e.getMethod());
 179             check(e.getSize() == -1 || e.getSize() == data.length);
 180             check((method == ZipEntry.DEFLATED) ||
 181                   (e.getCompressedSize() == data.length));
 182         }
 183 
 184         void verifyJarInputStream(JarInputStream s) throws Exception {
 185             // JarInputStream "automatically" reads the manifest
 186             if (name.equals("meta-iNf/ManIfEst.Mf"))
 187                 return;
 188 
 189             verifyZipInputStream(s);
 190         }
 191     }
 192 
 193     private static int uniquifier = 86;
 194     private static String uniquify(String name) {
 195         return name + (uniquifier++);
 196     }
 197 
 198     private static byte[] toBytes(String s) throws Exception {
 199         return s.getBytes("UTF-8");
 200     }
 201 
 202     private static byte[] toExtra(byte[] bytes) throws Exception {
 203         if (bytes == null) return null;
 204         // Construct a fake extra field with valid header length
 205         byte[] v = new byte[bytes.length + 4];
 206         v[0] = (byte) 0x47;
 207         v[1] = (byte) 0xff;
 208         v[2] = (byte) bytes.length;
 209         v[3] = (byte) (bytes.length << 8);
 210         System.arraycopy(bytes, 0, v, 4, bytes.length);
 211         return v;
 212     }
 213 
 214     private static Random random = new Random();
 215 
 216     private static String makeName(int length) {
 217         StringBuilder sb = new StringBuilder(length);
 218         for (int i = 0; i < length; i++)
 219             sb.append((char)(random.nextInt(10000)+1));
 220         return sb.toString();
 221     }
 222 
 223     public static void main(String[] args) throws Exception {
 224         File zipName = new File("x.zip");
 225         int[]    methods  = {ZipEntry.STORED, ZipEntry.DEFLATED};
 226         String[] names    = {makeName(1), makeName(160), makeName(9000)};
 227         byte[][] datas    = {null, new byte[]{}, new byte[]{'d'}};
 228         byte[][] extras   = {null, new byte[]{}, new byte[]{'e'}};
 229         String[] comments = {null, "", "c"};
 230 
 231         List<Entry> entries = new ArrayList<Entry>();
 232 
 233         // Highly unusual manifest
 234         entries.add(new Entry("meta-iNf/ManIfEst.Mf",
 235                               ZipEntry.STORED,
 236                               toBytes("maNiFest-VeRsIon: 1.0\n"),
 237                               toExtra(toBytes("Can manifests have extra??")),
 238                               "Can manifests have comments??"));
 239 
 240         // The emptiest possible entry
 241         entries.add(new Entry("", ZipEntry.STORED, null, null, ""));
 242 
 243         for (String name : names)
 244             for (int method : methods)
 245                 for (byte[] data : datas) // datae??
 246                     for (byte[] extra : extras)
 247                         for (String comment : comments)
 248                             entries.add(new Entry(uniquify(name), method, data,
 249                                                   toExtra(extra), comment));
 250 
 251         //----------------------------------------------------------------
 252         // Write zip file using ZipOutputStream
 253         //----------------------------------------------------------------
 254         try (FileOutputStream fos = new FileOutputStream(zipName);
 255              ZipOutputStream zos = new ZipOutputStream(fos))
 256         {
 257             for (Entry e : entries)
 258                 e.write(zos);
 259         }
 260 
 261         //----------------------------------------------------------------
 262         // Verify zip file contents using ZipFile.getEntry()
 263         //----------------------------------------------------------------
 264         try (ZipFile f = new ZipFile(zipName)) {
 265             for (Entry e : entries)
 266                 e.verify(f);
 267         }
 268 
 269         //----------------------------------------------------------------
 270         // Verify zip file contents using JarFile.getEntry()
 271         //----------------------------------------------------------------
 272         try (JarFile f = new JarFile(zipName)) {
 273             check(f.getManifest() != null);
 274             for (Entry e : entries)
 275                 e.verify(f);
 276         }
 277 
 278         //----------------------------------------------------------------
 279         // Verify zip file contents using ZipFile.entries()
 280         //----------------------------------------------------------------
 281         try (ZipFile f = new ZipFile(zipName)) {
 282             Enumeration<? extends ZipEntry> en = f.entries();
 283             for (Entry e : entries)
 284                 e.verify(f, en.nextElement());
 285 
 286             check(!en.hasMoreElements());
 287         }
 288 
 289         //----------------------------------------------------------------
 290         // Verify zip file contents using JarFile.entries()
 291         //----------------------------------------------------------------
 292         try (JarFile f = new JarFile(zipName)) {
 293             Enumeration<? extends ZipEntry> en = f.entries();
 294             for (Entry e : entries)
 295                 e.verify(f, en.nextElement());
 296 
 297             check(!en.hasMoreElements());
 298         }
 299 
 300         //----------------------------------------------------------------
 301         // Verify zip file contents using ZipInputStream class
 302         //----------------------------------------------------------------
 303         try (FileInputStream fis = new FileInputStream(zipName);
 304              ZipInputStream s = new ZipInputStream(fis)) {
 305 
 306             for (Entry e : entries)
 307                 e.verifyZipInputStream(s);
 308         }
 309 
 310         //----------------------------------------------------------------
 311         // Verify zip file contents using JarInputStream class
 312         //----------------------------------------------------------------
 313         try (FileInputStream fis = new FileInputStream(zipName);
 314              JarInputStream s = new JarInputStream(fis)) {
 315 
 316             // JarInputStream "automatically" reads the manifest
 317             check(s.getManifest() != null);
 318 
 319             for (Entry e : entries)
 320                 e.verifyJarInputStream(s);
 321         }
 322 
 323 //      String cmd = "unzip -t " + zipName.getPath() + " >/dev/tty";
 324 //      new ProcessBuilder(new String[]{"/bin/sh", "-c", cmd}).start().waitFor();
 325 
 326         zipName.deleteOnExit();
 327 
 328         System.out.printf("passed = %d, failed = %d%n", passed, failed);
 329         if (failed > 0) throw new Exception("Some tests failed");
 330     }
 331 }
--- EOF ---