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