ZipUtilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils.io;

  24. import java.io.ByteArrayInputStream;
  25. import java.io.ByteArrayOutputStream;
  26. import java.io.File;
  27. import java.io.FileOutputStream;
  28. import java.io.InputStream;
  29. import java.io.OutputStream;
  30. import java.util.ArrayList;
  31. import java.util.Collections;
  32. import java.util.Enumeration;
  33. import java.util.HashMap;
  34. import java.util.Iterator;
  35. import java.util.List;
  36. import java.util.Map;
  37. import java.util.zip.ZipEntry;
  38. import java.util.zip.ZipFile;
  39. import java.util.zip.ZipInputStream;
  40. import java.util.zip.ZipOutputStream;

  42. import org.openspcoop2.utils.UtilsException;
  43. import org.openspcoop2.utils.resources.FileSystemUtilities;

  45. /**
  46.  * ZipUtilities
  47.  *
  48.  *
  49.  * @author Poli Andrea (apoli@link.it)
  50.  * @author $Author$
  51.  * @version $Rev$, $Date$
  52.  */
  53. public class ZipUtilities {

  55.     public static byte[] zip(byte[] content,String name) throws UtilsException{
  56.         try {
  57.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  58.             ZipOutputStream zipOut = new ZipOutputStream(bout);
  59.             ByteArrayInputStream bin = new ByteArrayInputStream(content);
  60.             ZipEntry zipEntry = new ZipEntry(name);
  61.             zipOut.putNextEntry(zipEntry);
  62.             zipOut.write(content);
  63.             zipOut.flush();
  64.             zipOut.close();
  65.             bin.close();
  66.             bout.flush();
  67.             bout.close();
  68.             return bout.toByteArray();
  69.         }catch(Exception e){
  70.             throw new UtilsException("Errore durante la scrittura dello zip: "+e.getMessage(),e);
  71.         }
  72.     }
  73.     
  74.     public static byte[] zip(List<Entry> entries) throws UtilsException{
  75.         try {
  76.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  77.             ZipOutputStream zipOut = new ZipOutputStream(bout);
  78.             
  79.             for (Entry entry : entries) {
  80.                 String name = entry.getName();
  81.                 ZipEntry zipEntry = new ZipEntry(name);
  82.                 zipOut.putNextEntry(zipEntry);
  83.                 zipOut.write(entry.getContent());
  84.             }
  85.             
  86.             zipOut.flush();
  87.             zipOut.close();
  88.             bout.flush();
  89.             bout.close();
  90.             return bout.toByteArray();
  91.         }catch(Exception e){
  92.             throw new UtilsException("Errore durante la scrittura dello zip: "+e.getMessage(),e);
  93.         }
  94.     }
  95.     
  96.     public static byte[] unzip(byte[] zipContent) throws UtilsException{
  97.         try {
  98.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  99.             ByteArrayInputStream bin = new ByteArrayInputStream(zipContent);
  100.             ZipInputStream zis = new ZipInputStream(bin);
  101.             int count = 0;
  102.             ZipEntry zipEntry = zis.getNextEntry();
  103.             while(zipEntry != null){
  104.                 count++;
  105.                 if(count>1) {
  106.                     throw new UtilsException("Errore, il metodo supporta solamente archivi zip contenente un file");
  107.                 }
  108.                 int len;
  109.                 byte[] buffer = new byte[1024];
  110.                 while ((len = zis.read(buffer)) > 0) {
  111.                     bout.write(buffer, 0, len);
  112.                 }
  113.                 zipEntry = zis.getNextEntry();
  114.             }
  115.             zis.closeEntry();
  116.             zis.close();
  117.             bout.flush();
  118.             bout.close();
  119.             bin.close();
  120.             return bout.toByteArray();
  121.         }catch(Exception e){
  122.             throw new UtilsException("Errore durante la lettura dello zip: "+e.getMessage(),e);
  123.         }
  124.     }

  126.     public static List<Entry> read(byte[] zipContent) throws UtilsException{
  127.         try {
  128.             List<Entry> list = new ArrayList<>();
  129.             
  130.             ByteArrayInputStream in = new ByteArrayInputStream(zipContent);
  131.             ZipInputStream zipIn = new ZipInputStream(in);
  132.             ZipEntry entry;
  133.             while ((entry = zipIn.getNextEntry()) != null) {
  134.                 String name = entry.getName();
  135.                 //System.out.println(name);
  136.                 
  137.                 if(name!=null && !( name.endsWith("/") || name.endsWith("\\") ) ){
  138.                     Entry zentry = new Entry();
  139.                     zentry.setName(name);
  140.                     
  141.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  142.                     byte contents[] = new byte[4096];
  143.                     int direct;
  144.                     while ((direct = zipIn.read(contents, 0, contents.length)) >= 0) {
  145.                         //System.out.println("Read " + direct + "bytes content.");
  146.                         bout.write(contents, 0, direct);
  147.                     }
  148.                     bout.flush();
  149.                     bout.close();
  150.                     
  151.                     zentry.setContent(bout.toByteArray());
  152.                     list.add(zentry);
  153.                 }
  154.                 
  155.                 zipIn.closeEntry();
  156.             }
  157.             zipIn.close();
  158.             in.close();

  160.             return list;
  161.             
  162.         }catch(Exception e){
  163.             throw new UtilsException("Errore durante la lettura dello zip: "+e.getMessage(),e);
  164.         }
  165.     }

  167.     
  168.     public static String getRootDir(String entry) throws UtilsException{
  169.         try{
  170.             String rootDir = null;
  171.             String dir = entry;
  172.             int indexOf=dir.indexOf(File.separatorChar);
  173.             if(indexOf<=0){
  174.                 throw new UtilsException("Errore durante l'identificazione della directory radice presente all'interno dello zip ("+indexOf+")");
  175.             }
  176.             dir = dir.substring(0,indexOf);
  177.             if(dir==null || "".equals(dir)){
  178.                 throw new UtilsException("Errore durante l'identificazione della directory radice presente all'interno dello zip ("+dir+")");
  179.             }
  180.             rootDir=dir+File.separatorChar;
  181.             return rootDir;
  182.         }catch(UtilsException ex){
  183.             throw ex;
  184.         }catch(Exception e){
  185.             throw new UtilsException("Errore durante l'identificazione della directory radice presente all'interno dello zip: "+e.getMessage(),e);
  186.         }
  187.     }
  188.     
  189.     public static String getBaseName(String file) throws UtilsException{
  190.         try{
  191.             return (new File(file)).getName();
  192.         }catch(Exception e){
  193.             throw new UtilsException("Errore durante l'identificazione del base name per il file ["+file+"]: "+e.getMessage(),e);
  194.         }
  195.     }
  196.     
  197.     public static String operativeSystemConversion(String entryName){

  199.         char separatorCharWindows = '\\';
  200.         char separatorCharLinux = '/';
  201.         boolean isWindows =  (File.separatorChar == separatorCharWindows);
  202.         
  203.         StringBuilder fixed = new StringBuilder(entryName);
  204.         for( int i = 0; i<fixed.length(); i++){
  205.             
  206.             if(isWindows){
  207.                 // se siamo su windows converto tutti i path "linux" in windows mode
  208.                 if(fixed.charAt(i) == separatorCharLinux){ 
  209.                     fixed.setCharAt(i, File.separatorChar);
  210.                 }
  211.             }
  212.             else{
  213.                 // se siamo su linux converto tutti i path "windows" in linux mode
  214.                 if(fixed.charAt(i) == separatorCharWindows){ 
  215.                     fixed.setCharAt(i, File.separatorChar);
  216.                 }
  217.             }
  218.             
  219.         }
  220.         
  221.         //System.out.println("Convertito per Windows: "+isWindows);
  222.         
  223.         return fixed.toString();
  224.     }
  225.     
  226.     public static void unzipFile(String zipFile,String dest) throws UtilsException {
  227.         try{
  228.             File destFile = new File(dest);
  229.             if(destFile.exists()==false){
  230.                 if(destFile.mkdir()==false){
  231.                     throw new Exception("Destinazione ["+dest+"] non esistente e creazione non riuscita");
  232.                 }
  233.             }else{
  234.                 if(destFile.isDirectory()==false){
  235.                     throw new Exception("Destinazione ["+dest+"] non e' una directory");
  236.                 }
  237.                 if(destFile.canWrite()==false){
  238.                     throw new Exception("Destinazione ["+dest+"] non accessibile in scrittura ");
  239.                 }
  240.             }

  242.             OutputStream out = null;
  243.             InputStream iZip = null;
  244.             ZipFile zf = null;
  245.             try{
  246.                 zf = new ZipFile(zipFile);
  247.                 for(Enumeration<?> em = zf.entries(); em.hasMoreElements();){
  248.                     ZipEntry ze = (ZipEntry) em.nextElement();
  249.                     String targetfile = destFile.getAbsolutePath()+File.separatorChar+ze.getName();

  251.                     // Parent
  252.                     FileSystemUtilities.mkdirParentDirectory(targetfile);
  253.                     
  254.                     // File
  255.                     if(ze.getName()!=null && ( ze.getName().endsWith("/") || ze.getName().endsWith("\\") ) ){
  256.                         
  257.                         // Directory
  258.                         File fDir = new File(targetfile);
  259.                         if(fDir.mkdir()==false){
  260.                             try{
  261.                                 throw new Exception("Creazione directory ["+fDir.getAbsolutePath()+"] per entry ["+ze.getName()+"] non riuscita");
  262.                             }finally{
  263.                                 try{
  264.                                     if(zf!=null){
  265.                                         zf.close();
  266.                                     }
  267.                                 }catch(Exception eClose){
  268.                                     // close
  269.                                 }
  270.                             }
  271.                         }
  272.                 
  273.                     }
  274.                     else{

  276.                         // Creo file
  277.                         iZip = zf.getInputStream(ze);           
  278.                         out = new FileOutputStream(targetfile);
  279.                         byte[] buf = new byte[1024];
  280.                         int len;
  281.                         while ((len = iZip.read(buf)) > 0) {
  282.                             out.write(buf, 0, len);
  283.                         }
  284.                         iZip.close();
  285.                         iZip = null;
  286.                         out.flush();
  287.                         out.close();
  288.                         out = null;
  289.                         
  290.                     }
  291.                 }
  292.             }finally{
  293.                 try{
  294.                     if(out!=null){
  295.                         out.close();
  296.                     }
  297.                 }catch(Exception eClose){}
  298.                 try{
  299.                     if(iZip!=null){
  300.                         iZip.close();
  301.                     }
  302.                 }catch(Exception eClose){}
  303.                 try{
  304.                     if(zf!=null){
  305.                         zf.close();
  306.                     }
  307.                 }catch(Exception eClose){
  308.                     // close
  309.                 }
  310.             }

  312.         }catch(Exception e){
  313.             throw new UtilsException("Unzip non riuscito: "+e.getMessage(),e);
  314.         }
  315.     }
  316.     
  317.     public static Iterator<ZipEntry> entries(ZipFile zip,boolean ascOrder){
  318.         
  319.         // L'Enumeration ritornato dal metodo standard java.util.zip.ZipFile.entries() 
  320.         // attraversa le entries presenti nello zip nello stesso ordine in cui sono state salvate.
  321.         
  322.         List<String> entryNames = new ArrayList<>();
  323.         Map<String, ZipEntry> map = new HashMap<String, ZipEntry>();
  324.         Enumeration<?> e = zip.entries();
  325.         while(e.hasMoreElements()) {
  326.             ZipEntry zipEntry = (ZipEntry)e.nextElement();
  327.             String entryName = zipEntry.getName();
  328.             entryNames.add(entryName);
  329.             map.put(entryName, zipEntry);
  330.         }
  331.         
  332.         if(ascOrder){
  333.             java.util.Collections.sort(entryNames);
  334.         }
  335.         else{
  336.             java.util.Collections.sort(entryNames,Collections.reverseOrder());
  337.         }
  338.         
  339.         List<ZipEntry> zipEntries = new ArrayList<ZipEntry>();
  340.         for (String entry : entryNames) {
  341.             zipEntries.add(map.remove(entry));
  342.         }
  343.         return zipEntries.iterator();
  344.     }
  345.     
  346. }
Created with JaCoCo 0.8.8.202204050719