Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / ZipTools.java
1 /* $RCSfile$
2  * $Author$
3  * $Date$
4  * $Revision$
5  *
6  * Some portions of this file have been modified by Robert Hanson hansonr.at.stolaf.edu 2012-2017
7  * for use in SwingJS via transpilation into JavaScript using Java2Script.
8  *
9  * Copyright (C) 2006  The Jmol Development Team
10  *
11  * Contact: jmol-developers@lists.sf.net
12  *
13  *  This library is free software; you can redistribute it and/or
14  *  modify it under the terms of the GNU Lesser General Public
15  *  License as published by the Free Software Foundation; either
16  *  version 2.1 of the License, or (at your option) any later version.
17  *
18  *  This library is distributed in the hope that it will be useful,
19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21  *  Lesser General Public License for more details.
22  *
23  *  You should have received a copy of the GNU Lesser General Public
24  *  License along with this library; if not, write to the Free Software
25  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
26  *  02110-1301, USA.
27  */
28
29 package javajs.util;
30
31 import java.io.BufferedInputStream;
32 import java.io.IOException;
33 import java.io.InputStream;
34 import java.io.OutputStream;
35 import java.util.Map;
36 import java.util.zip.CRC32;
37 import java.util.zip.GZIPInputStream;
38 import java.util.zip.ZipEntry;
39 import java.util.zip.ZipInputStream;
40 import java.util.zip.ZipOutputStream;
41
42 import javajs.api.GenericZipInputStream;
43 import javajs.api.GenericZipTools;
44 import javajs.api.Interface;
45 import javajs.api.ZInputStream;
46
47 import org.apache.tools.bzip2.CBZip2InputStreamFactory;
48
49
50 /**
51  * Note the JSmol/HTML5 must use its own version of java.util.zip.ZipOutputStream.
52  * 
53  */
54 public class ZipTools implements GenericZipTools {
55
56   public ZipTools() {
57     // for reflection
58   }
59   
60   @Override
61   public ZInputStream newZipInputStream(InputStream is) {
62     return newZIS(is);
63   }
64
65   @SuppressWarnings("resource")
66   private static ZInputStream newZIS(InputStream is) {
67     return (is instanceof ZInputStream ? (ZInputStream) is
68         : is instanceof BufferedInputStream ? new GenericZipInputStream(is)
69             : new GenericZipInputStream(new BufferedInputStream(is)));
70   }
71
72   /**
73    * reads a ZIP file and saves all data in a Hashtable so that the files may be
74    * organized later in a different order. Also adds a #Directory_Listing entry.
75    * 
76    * Files are bracketed by BEGIN Directory Entry and END Directory Entry lines,
77    * similar to CompoundDocument.getAllData.
78    * 
79    * @param is
80    * @param subfileList
81    * @param name0
82    *        prefix for entry listing
83    * @param binaryFileList
84    *        |-separated list of files that should be saved as xx xx xx hex byte
85    *        strings. The directory listing is appended with ":asBinaryString"
86    * @param fileData
87    */
88   @Override
89   public void getAllZipData(InputStream is, String[] subfileList,
90                                           String name0, String binaryFileList, String exclude,
91                                           Map<String, String> fileData) {
92     ZipInputStream zis = (ZipInputStream) newZIS(is);
93     ZipEntry ze;
94     SB listing = new SB();
95     binaryFileList = "|" + binaryFileList + "|";
96     String prefix = PT.join(subfileList, '/', 1);
97     String prefixd = null;
98     if (prefix != null) {
99       prefixd = prefix.substring(0, prefix.indexOf("/") + 1);
100       if (prefixd.length() == 0)
101         prefixd = null;
102     }
103     try {
104       while ((ze = zis.getNextEntry()) != null) {
105         String name = ze.getName();
106         if (prefix != null && prefixd != null
107             && !(name.equals(prefix) || name.startsWith(prefixd))
108             || exclude != null && name.contains(exclude))
109           continue;
110         //System.out.println("ziputil: " + name);
111         listing.append(name).appendC('\n');
112         String sname = "|" + name.substring(name.lastIndexOf("/") + 1) + "|";
113         boolean asBinaryString = (binaryFileList.indexOf(sname) >= 0);
114         byte[] bytes = Rdr.getLimitedStreamBytes(zis, ze.getSize());
115         String str;
116         if (asBinaryString) {
117           str = getBinaryStringForBytes(bytes);
118           name += ":asBinaryString";
119         } else {
120           str = Rdr.fixUTF(bytes);
121         }
122         str = "BEGIN Directory Entry " + name + "\n" + str
123             + "\nEND Directory Entry " + name + "\n";
124         String key = name0 + "|" + name;
125         fileData.put(key, str);
126       }
127     } catch (Exception e) {
128     }
129     fileData.put("#Directory_Listing", listing.toString());
130   }
131
132   private String getBinaryStringForBytes(byte[] bytes) {
133     SB ret = new SB();
134     for (int i = 0; i < bytes.length; i++)
135       ret.append(Integer.toHexString(bytes[i] & 0xFF)).appendC(' ');
136     return ret.toString();
137   }
138
139   /**
140    * iteratively drills into zip files of zip files to extract file content or
141    * zip file directory. Also works with JAR files.
142    * 
143    * Does not return "__MACOS" paths
144    * 
145    * @param bis
146    * @param list
147    * @param listPtr
148    * @param asBufferedInputStream
149    *        for Pmesh
150    * @return directory listing or subfile contents
151    */
152   @Override
153   public Object getZipFileDirectory(BufferedInputStream bis, String[] list,
154                                     int listPtr, boolean asBufferedInputStream) {
155     SB ret;
156     if (list == null || listPtr >= list.length)
157       return getZipDirectoryAsStringAndClose(bis);
158     bis = Rdr.getPngZipStream(bis, true);
159     String fileName = list[listPtr];
160     ZipInputStream zis = new ZipInputStream(bis);
161     ZipEntry ze;
162     //System.out.println("fname=" + fileName);
163     try {
164       boolean isAll = (fileName.equals("."));
165       if (isAll || fileName.lastIndexOf("/") == fileName.length() - 1) {
166         ret = new SB();
167         while ((ze = zis.getNextEntry()) != null) {
168           String name = ze.getName();
169           if (isAll || name.startsWith(fileName))
170             ret.append(name).appendC('\n');
171         }
172         String str = ret.toString();
173         return (asBufferedInputStream ? Rdr.getBIS(str.getBytes()) : str);
174       }
175       int pt = fileName.indexOf(":asBinaryString");
176       boolean asBinaryString = (pt > 0);
177       if (asBinaryString)
178         fileName = fileName.substring(0, pt);
179       fileName = fileName.replace('\\', '/');
180       while ((ze = zis.getNextEntry()) != null
181           && !fileName.equals(ze.getName())) {
182       }
183       byte[] bytes = (ze == null ? null : Rdr.getLimitedStreamBytes(zis,
184           ze.getSize()));
185       ze = null;
186       zis.close();
187       if (bytes == null)
188         return "";
189       if (Rdr.isZipB(bytes) || Rdr.isPngZipB(bytes))
190         return getZipFileDirectory(Rdr.getBIS(bytes), list, ++listPtr,
191             asBufferedInputStream);
192       if (asBufferedInputStream)
193         return Rdr.getBIS(bytes);
194       if (asBinaryString) {
195         ret = new SB();
196         for (int i = 0; i < bytes.length; i++)
197           ret.append(Integer.toHexString(bytes[i] & 0xFF)).appendC(' ');
198         return ret.toString();
199       }
200       if (Rdr.isGzipB(bytes))
201         bytes = Rdr.getLimitedStreamBytes(getUnGzippedInputStream(bytes), -1);
202       return Rdr.fixUTF(bytes);
203     } catch (Exception e) {
204       return "";
205     }
206   }
207
208   @Override
209   public byte[] getZipFileContentsAsBytes(BufferedInputStream bis,
210                                           String[] list, int listPtr) {
211     byte[] ret = new byte[0];
212     String fileName = list[listPtr];
213     if (fileName.lastIndexOf("/") == fileName.length() - 1)
214       return ret;
215     try {
216       bis = Rdr.getPngZipStream(bis, true);
217       ZipInputStream zis = new ZipInputStream(bis);
218       ZipEntry ze;
219       while ((ze = zis.getNextEntry()) != null) {
220         if (!fileName.equals(ze.getName()))
221           continue;
222         byte[] bytes = Rdr.getLimitedStreamBytes(zis, ze.getSize());
223         return ((Rdr.isZipB(bytes) || Rdr.isPngZipB(bytes)) && ++listPtr < list.length ? getZipFileContentsAsBytes(
224             Rdr.getBIS(bytes), list, listPtr) : bytes);
225       }
226     } catch (Exception e) {
227     }
228     return ret;
229   }
230   
231   @Override
232   public String getZipDirectoryAsStringAndClose(BufferedInputStream bis) {
233     SB sb = new SB();
234     String[] s = new String[0];
235     try {
236       s = getZipDirectoryOrErrorAndClose(bis, null);
237       bis.close();
238     } catch (Exception e) {
239       System.out.println(e.toString());
240     }
241     for (int i = 0; i < s.length; i++)
242       sb.append(s[i]).appendC('\n');
243     return sb.toString();
244   }
245
246   @Override
247   public String[] getZipDirectoryAndClose(BufferedInputStream bis,
248                                                  String manifestID) {
249     String[] s = new String[0];
250     try {
251       s = getZipDirectoryOrErrorAndClose(bis, manifestID);
252       bis.close();
253     } catch (Exception e) {
254       System.out.println(e.toString());
255     }
256     return s;
257   }
258
259   private String[] getZipDirectoryOrErrorAndClose(BufferedInputStream bis,
260                                                   String manifestID)
261       throws IOException {
262     bis = Rdr.getPngZipStream(bis, true);
263     Lst<String> v = new Lst<String>();
264     ZipInputStream zis = new ZipInputStream(bis);
265     ZipEntry ze;
266     String manifest = null;
267     while ((ze = zis.getNextEntry()) != null) {
268       String fileName = ze.getName();
269       if (manifestID != null && fileName.startsWith(manifestID))
270         manifest = getStreamAsString(zis);
271       else if (!fileName.startsWith("__MACOS")) // resource fork not nec.
272         v.addLast(fileName);
273     }
274     zis.close();
275     if (manifestID != null)
276       v.add(0, manifest == null ? "" : manifest + "\n############\n");
277     return v.toArray(new String[v.size()]);
278   }
279
280   public static String getStreamAsString(InputStream is) throws IOException {
281     return Rdr.fixUTF(Rdr.getLimitedStreamBytes(is, -1));
282   }
283
284   @Override
285   public InputStream newGZIPInputStream(InputStream is) throws IOException {
286     return new BufferedInputStream(new GZIPInputStream(is, 512));
287   }
288
289   @Override
290   public InputStream newBZip2InputStream(InputStream is) throws IOException {
291     return new BufferedInputStream(((CBZip2InputStreamFactory) Interface.getInterface("org.apache.tools.bzip2.CBZip2InputStreamFactory")).getStream(is));
292   }
293
294   @Override
295   public BufferedInputStream getUnGzippedInputStream(byte[] bytes) {
296     try {
297       return Rdr.getUnzippedInputStream(this, Rdr.getBIS(bytes));
298     } catch (Exception e) {
299       return null;
300     }
301   }
302
303   @Override
304   public void addZipEntry(Object zos, String fileName) throws IOException {
305     ((ZipOutputStream) zos).putNextEntry(new ZipEntry(fileName));
306   }
307
308   @Override
309   public void closeZipEntry(Object zos) throws IOException {
310     ((ZipOutputStream) zos).closeEntry();
311   }
312
313   @Override
314   public Object getZipOutputStream(Object bos) {
315 //    /**
316 //     * xxxxj2sNative
317 //     * 
318 //     *            return javajs.api.Interface.getInterface(
319 //     *            "java.util.zip.ZipOutputStream").setZOS(bos);
320 //     * 
321 //     */
322 //    {
323       return new ZipOutputStream((OutputStream) bos);
324 //    }
325   }
326
327   @Override
328   public int getCrcValue(byte[] bytes) {
329     CRC32 crc = new CRC32();
330     crc.update(bytes, 0, bytes.length);
331     return (int) crc.getValue();
332   }
333
334   @Override
335   public void readFileAsMap(BufferedInputStream bis, Map<String, Object> bdata, String name) {
336         readFileAsMapStatic(bis, bdata, name);
337   }
338
339   public static void readFileAsMapStatic(BufferedInputStream bis,
340                         Map<String, Object> bdata, String name) {
341     int pt = (name == null ? -1 : name.indexOf("|"));
342     name = (pt >= 0 ? name.substring(pt + 1) : null);
343     try {
344       if (Rdr.isPngZipStream(bis)) {
345         boolean isImage = "_IMAGE_".equals(name);
346         if (name == null || isImage)
347           bdata.put((isImage ? "_DATA_" : "_IMAGE_"), new BArray(getPngImageBytes(bis)));
348         if (!isImage)
349           cacheZipContentsStatic(bis, name, bdata, true);
350       } else if (Rdr.isZipS(bis)) {
351         cacheZipContentsStatic(bis, name, bdata, true);
352       } else if (name == null){
353         bdata.put("_DATA_", new BArray(Rdr.getLimitedStreamBytes(bis, -1)));
354       } else {
355         throw new IOException("ZIP file " + name + " not found");
356       }
357       bdata.put("$_BINARY_$", Boolean.TRUE);
358     } catch (IOException e) {
359       bdata.clear();
360       bdata.put("_ERROR_", e.getMessage());
361     }
362   }
363
364   @Override
365   public String cacheZipContents(BufferedInputStream bis,
366                                         String fileName,
367                                         Map<String, Object> cache, 
368                                         boolean asByteArray) {
369                 return cacheZipContentsStatic(bis, fileName, cache, asByteArray);
370   }
371
372         /**
373          * 
374          * @param bis
375          * @param fileName may end with "/" for a prefix or contain "|xxxx.xxx" for a specific file or be null
376          * @param cache
377          * @param asByteArray
378          * @return
379          */
380   public static String cacheZipContentsStatic(BufferedInputStream bis,
381                         String fileName, Map<String, Object> cache, boolean asByteArray) {
382     ZipInputStream zis = (ZipInputStream) newZIS(bis);
383     ZipEntry ze;
384     SB listing = new SB();
385     long n = 0;
386     boolean isPath = (fileName != null && fileName.endsWith("/"));
387     boolean oneFile = (asByteArray && !isPath && fileName != null);
388     int pt = (oneFile ? fileName.indexOf("|") : -1);
389     String file0 = (pt >= 0 ? fileName : null);
390     if (pt >= 0)
391       fileName = fileName.substring(0,  pt);
392     String prefix = (fileName == null ? "" : isPath ? fileName : fileName + "|");
393     try {
394       while ((ze = zis.getNextEntry()) != null) {
395         String name = ze.getName();
396         if (fileName != null) {
397           if (oneFile) {
398             if (!name.equalsIgnoreCase(fileName))
399               continue;
400           } else {
401             listing.append(name).appendC('\n');
402           }
403         }
404         long nBytes = ze.getSize();
405         byte[] bytes = Rdr.getLimitedStreamBytes(zis, nBytes);
406         if (file0 != null) {
407           readFileAsMapStatic(Rdr.getBIS(bytes), cache, file0);
408           return null;
409         }
410         n += bytes.length;
411         Object o = (asByteArray ? new BArray(bytes) : bytes);        
412         cache.put((oneFile ? "_DATA_" : prefix + name), o);
413         if (oneFile)
414           break;
415       }
416       zis.close();
417     } catch (Exception e) {
418       try {
419         zis.close();
420       } catch (IOException e1) {
421       }
422       return null;
423     }
424     if (n == 0 || fileName == null)
425       return null;
426     System.out.println("ZipTools cached " + n + " bytes from " + fileName);
427     return listing.toString();
428   }
429
430   private static byte[] getPngImageBytes(BufferedInputStream bis) {
431     try {
432       if (Rdr.isPngZipStream(bis)) {
433         int pt_count[] = new int[2];
434         Rdr.getPngZipPointAndCount(bis, pt_count);
435         if (pt_count[1] != 0)
436           return deActivatePngZipB(Rdr.getLimitedStreamBytes(bis, pt_count[0]));
437       }
438       return Rdr.getLimitedStreamBytes(bis, -1);
439     } catch (IOException e) {
440       return null;
441     }
442   }
443
444   /**
445    * Once a PNGJ image has been extracted, we want to red-line its
446    * iTXt "Jmol Type PNGJ" tag, since it is no longer associated with
447    * ZIP data.
448    *  
449    * @param bytes
450    * @return disfigured bytes
451    * 
452    */
453   private static byte[] deActivatePngZipB(byte[] bytes) {
454     // \0PNGJ starting at byte 50 changed to \0 NGJ
455     if (Rdr.isPngZipB(bytes))
456       bytes[51] = 32;
457     return bytes;
458   }
459
460
461
462 }