private static void addParts(
      final XMLSignatureFactory fac,
      final ContentTypeManager contentTypeManager,
      final List<Reference> references,
      final byte[] ooXmlDocument,
      final String[] applications,
      final DigestMethod digestMethod)
      throws IOException {
    final ZipInputStream zipInputStream =
        new ZipInputStream(new ByteArrayInputStream(ooXmlDocument));

    ZipEntry zipEntry;
    while (null != (zipEntry = zipInputStream.getNextEntry())) {
      if (!startsWithAnyOfThose(zipEntry.getName(), applications)) {
        continue;
      }

      final String contentType = contentTypeManager.getContentType(zipEntry.getName());

      // Solo se anade la referencia si existe contentType
      if (contentType != null) {
        final Reference reference =
            fac.newReference(
                "/" + zipEntry.getName() + "?ContentType=" + contentType,
                digestMethod); //$NON-NLS-1$ //$NON-NLS-2$
        references.add(reference);
      }
    }
  }
Beispiel #2
0
  /* @see loci.formats.FormatReader#initFile(String) */
  protected void initFile(String id) throws FormatException, IOException {
    super.initFile(id);
    reader = new ImageReader();

    reader.setMetadataOptions(getMetadataOptions());
    reader.setMetadataFiltered(isMetadataFiltered());
    reader.setOriginalMetadataPopulated(isOriginalMetadataPopulated());
    reader.setNormalized(isNormalized());
    reader.setMetadataStore(getMetadataStore());

    // NB: We need a raw handle on the ZIP data itself, not a ZipHandle.
    IRandomAccess rawHandle = Location.getHandle(id, false, false);
    in = new RandomAccessInputStream(rawHandle, id);

    ZipInputStream zip = new ZipInputStream(in);
    while (true) {
      ZipEntry ze = zip.getNextEntry();
      if (ze == null) break;
      ZipHandle handle = new ZipHandle(id, ze);
      Location.mapFile(ze.getName(), handle);
      mappedFiles.add(ze.getName());
    }

    ZipHandle base = new ZipHandle(id);
    reader.setId(base.getEntryName());

    metadataStore = reader.getMetadataStore();
    core = reader.getCoreMetadata();
    metadata = reader.getGlobalMetadata();

    base.close();
  }
  private void removePreviousModVersion(String modName, String installedVersion) {
    try {
      // Mod has been previously installed uninstall previous version
      File previousModZip = new File(cacheDir, modName + "-" + installedVersion + ".zip");
      ZipFile zf = new ZipFile(previousModZip);
      Enumeration<? extends ZipEntry> entries = zf.entries();
      // Go through zipfile of previous version and delete all file from
      // Modpack that exist in the zip
      while (entries.hasMoreElements()) {
        ZipEntry entry = entries.nextElement();
        if (entry.isDirectory()) {
          continue;
        }
        File file = new File(GameUpdater.modpackDir, entry.getName());
        Util.log("Deleting '%s'", entry.getName());
        if (file.exists()) {
          // File from mod exists.. delete it
          file.delete();
        }
      }

      InstalledModsYML.removeMod(modName);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Beispiel #4
0
  @Test
  public void shouldSetTimestampOfEntries() throws IOException {
    Calendar cal = Calendar.getInstance();
    cal.set(1999, SEPTEMBER, 10);
    long old = getTimeRoundedToSeconds(cal.getTime());

    long now = getTimeRoundedToSeconds(new Date());

    try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output)) {
      ZipEntry oldAndValid = new ZipEntry("oldAndValid");
      oldAndValid.setTime(old);
      out.putNextEntry(oldAndValid);

      ZipEntry current = new ZipEntry("current");
      current.setTime(now);
      out.putNextEntry(current);
    }

    try (ZipInputStream in = new ZipInputStream(Files.newInputStream(output))) {
      ZipEntry entry = in.getNextEntry();
      assertEquals("oldAndValid", entry.getName());
      assertEquals(old, entry.getTime());

      entry = in.getNextEntry();
      assertEquals("current", entry.getName());
      assertEquals(now, entry.getTime());
    }
  }
  /**
   * @return a mutable list
   * @throws IOException
   */
  public static List<JSSourceFile> getDefaultExterns() throws IOException {
    InputStream input = CommandLineRunner.class.getResourceAsStream("/externs.zip");
    ZipInputStream zip = new ZipInputStream(input);
    Map<String, JSSourceFile> externsMap = Maps.newHashMap();
    for (ZipEntry entry = null; (entry = zip.getNextEntry()) != null; ) {
      LimitInputStream entryStream = new LimitInputStream(zip, entry.getSize());
      externsMap.put(
          entry.getName(),
          JSSourceFile.fromInputStream(
              // Give the files an odd prefix, so that they do not conflict
              // with the user's files.
              "externs.zip//" + entry.getName(), entryStream));
    }

    Preconditions.checkState(
        externsMap.keySet().equals(Sets.newHashSet(DEFAULT_EXTERNS_NAMES)),
        "Externs zip must match our hard-coded list of externs.");

    // Order matters, so the resources must be added to the result list
    // in the expected order.
    List<JSSourceFile> externs = Lists.newArrayList();
    for (String key : DEFAULT_EXTERNS_NAMES) {
      externs.add(externsMap.get(key));
    }

    return externs;
  }
 private static void unZipFile(InputStream source, FileObject projectRoot) throws IOException {
   try {
     ZipInputStream str = new ZipInputStream(source);
     ZipEntry entry;
     while ((entry = str.getNextEntry()) != null) {
       if (entry.isDirectory()) {
         FileUtil.createFolder(projectRoot, entry.getName());
       } else {
         FileObject fo = FileUtil.createData(projectRoot, entry.getName());
         FileLock lock = fo.lock();
         try {
           OutputStream out = fo.getOutputStream(lock);
           try {
             FileUtil.copy(str, out);
           } finally {
             out.close();
           }
         } finally {
           lock.releaseLock();
         }
       }
     }
   } finally {
     source.close();
   }
 }
  public static boolean unpackFileFromZip(Path zipfile, String filename, Path destDirectory)
      throws IOException {
    boolean ret = true;

    byte[] bytebuffer = new byte[BUFFERSIZE];
    ZipInputStream zipinputstream = new ZipInputStream(new FileInputStream(zipfile.toFile()));

    ZipEntry zipentry;
    while ((zipentry = zipinputstream.getNextEntry()) != null) {
      if (zipentry.getName().equals(filename)) {
        Path newFile = destDirectory.resolve(zipentry.getName());
        FileOutputStream fileoutputstream = new FileOutputStream(newFile.toFile());

        int bytes;
        while ((bytes = zipinputstream.read(bytebuffer)) > -1) {
          fileoutputstream.write(bytebuffer, 0, bytes);
        }

        fileoutputstream.close();
        zipinputstream.closeEntry();
        zipinputstream.close();

        return ret;
      }

      zipinputstream.closeEntry();
    }

    zipinputstream.close();

    return ret;
  }
  public void unzip(File from, String to) throws FITTESTException {
    try {
      FileInputStream fis = new FileInputStream(from);
      ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis, BUFFER));
      ZipEntry entry = zis.getNextEntry();
      while (entry != null) {
        int count;
        byte data[] = new byte[BUFFER];

        File outFile = null;
        if (entry.isDirectory()) {
          outFile = new File(to, entry.getName());
          outFile.mkdirs();
        } else {
          outFile = new File(to, entry.getName());

          FileOutputStream fos = new FileOutputStream(outFile);
          BufferedOutputStream bos = new BufferedOutputStream(fos, BUFFER);
          while ((count = zis.read(data, 0, BUFFER)) != -1) {
            bos.write(data, 0, count);
          }
          bos.flush();
          bos.close();
        }
        zis.closeEntry();

        entry = zis.getNextEntry();
      }
      zis.close();
    } catch (Exception e) {
      throw new FITTESTException(e.getMessage());
    }
  }
 /* shamelessly copied from PlugInManager */
 private static Class toClass(ZipEntry entry, ClassLoader classLoader) {
   if (entry.isDirectory()) {
     return null;
   }
   if (!entry.getName().endsWith(".class")) {
     return null;
   }
   if (entry.getName().indexOf("$") != -1) {
     // I assume it's not necessary to load inner classes explicitly.
     // [Jon Aquino]
     return null;
   }
   String className = entry.getName();
   className = className.substring(0, className.length() - ".class".length());
   className = StringUtil.replaceAll(className, "/", ".");
   Class candidate;
   try {
     candidate = classLoader.loadClass(className);
   } catch (ClassNotFoundException e) {
     Assert.shouldNeverReachHere(
         "Class not found: " + className + ". Refine class name algorithm.");
     return null;
   } catch (Throwable t) {
     LOG.error("Throwable encountered loading " + className + ":");
     // e.g. java.lang.VerifyError: class
     // org.apache.xml.serialize.XML11Serializer
     // overrides final method [Jon Aquino]
     t.printStackTrace(System.out);
     return null;
   }
   return candidate;
 }
Beispiel #10
0
  private void unzip() throws IOException {
    int BUFFER = 2048;
    BufferedOutputStream dest = null;
    BufferedInputStream is = null;
    ZipEntry entry;
    ZipFile zipfile = new ZipFile("update.zip");
    Enumeration e = zipfile.entries();
    (new File(root)).mkdir();
    while (e.hasMoreElements()) {
      entry = (ZipEntry) e.nextElement();
      output.setText(output.getText() + "\nExtracting: " + entry);
      if (entry.isDirectory()) {
        (new File(root + entry.getName())).mkdir();
      } else {
        (new File(root + entry.getName())).createNewFile();
        is = new BufferedInputStream(zipfile.getInputStream(entry));
        int count;
        byte[] data = new byte[BUFFER];
        FileOutputStream fos = new FileOutputStream(root + entry.getName());
        dest = new BufferedOutputStream(fos, BUFFER);
        while ((count = is.read(data, 0, BUFFER)) != -1) {
          dest.write(data, 0, count);
        }

        dest.flush();
        dest.close();
        is.close();
      }
    }
  }
 /**
  * Helper for unzipping downloaded zips
  *
  * @param environment
  * @throws IOException
  */
 private void unzip(Environment environment, ZipFile zipFile, File targetFile, String targetPath)
     throws IOException {
   String baseDirSuffix = null;
   try {
     Enumeration<? extends ZipEntry> zipEntries = zipFile.entries();
     if (!zipEntries.hasMoreElements()) {
       logger.error("the zip archive has no entries");
     }
     ZipEntry firstEntry = zipEntries.nextElement();
     if (firstEntry.isDirectory()) {
       baseDirSuffix = firstEntry.getName();
     } else {
       zipEntries = zipFile.entries();
     }
     while (zipEntries.hasMoreElements()) {
       ZipEntry zipEntry = zipEntries.nextElement();
       if (zipEntry.isDirectory()) {
         continue;
       }
       String zipEntryName = zipEntry.getName();
       zipEntryName = zipEntryName.replace('\\', '/');
       if (baseDirSuffix != null && zipEntryName.startsWith(baseDirSuffix)) {
         zipEntryName = zipEntryName.substring(baseDirSuffix.length());
       }
       File target = new File(targetFile, zipEntryName);
       FileSystemUtils.mkdirs(target.getParentFile());
       Streams.copy(zipFile.getInputStream(zipEntry), new FileOutputStream(target));
     }
   } catch (IOException e) {
     logger.error(
         "failed to extract zip ["
             + zipFile.getName()
             + "]: "
             + ExceptionsHelper.detailedMessage(e));
     return;
   } finally {
     try {
       zipFile.close();
     } catch (IOException e) {
       // ignore
     }
   }
   File binFile = new File(targetFile, "bin");
   if (binFile.exists() && binFile.isDirectory()) {
     File toLocation = new File(new File(environment.homeFile(), "bin"), targetPath);
     logger.info("found bin, moving to " + toLocation.getAbsolutePath());
     FileSystemUtils.deleteRecursively(toLocation);
     binFile.renameTo(toLocation);
   }
   if (!new File(targetFile, "_site").exists()) {
     if (!FileSystemUtils.hasExtensions(targetFile, ".class", ".jar")) {
       logger.info("identified as a _site plugin, moving to _site structure ...");
       File site = new File(targetFile, "_site");
       File tmpLocation = new File(environment.pluginsFile(), targetPath + ".tmp");
       targetFile.renameTo(tmpLocation);
       FileSystemUtils.mkdirs(targetFile);
       tmpLocation.renameTo(site);
     }
   }
 }
 public static void unzip(InputStream is, File destDir) throws IOException {
   final int BUFFER = 2048;
   ZipInputStream zis = new ZipInputStream(new BufferedInputStream(is));
   try {
     ZipEntry entry;
     while ((entry = zis.getNextEntry()) != null) {
       if (entry.isDirectory()) {
         File dir = new File(destDir, entry.getName());
         if (!dir.mkdir()) {
           throw new IOException("Failed to create directory " + dir);
         }
       } else {
         int count;
         byte contents[] = new byte[BUFFER];
         // write the files to the disk
         FileOutputStream fos = new FileOutputStream(new File(destDir, entry.getName()));
         try {
           BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
           try {
             while ((count = zis.read(contents, 0, BUFFER)) != -1) {
               dest.write(contents, 0, count);
             }
           } finally {
             dest.close();
           }
         } finally {
           fos.close();
         }
       }
     }
   } finally {
     zis.close();
   }
 }
Beispiel #13
0
 public static List<File> unzip(File zip, File toDir) throws IOException {
   ZipFile zf = null;
   List<File> files = null;
   try {
     zf = new ZipFile(zip);
     files = new ArrayList<File>();
     Enumeration<?> entries = zf.entries();
     while (entries.hasMoreElements()) {
       ZipEntry entry = (ZipEntry) entries.nextElement();
       if (entry.isDirectory()) {
         new File(toDir, entry.getName()).mkdirs();
       } else {
         InputStream input = null;
         OutputStream output = null;
         try {
           File f = new File(toDir, entry.getName());
           input = zf.getInputStream(entry);
           output = new FileOutputStream(f);
           copy(input, output);
           files.add(f);
         } finally {
           closeQuietly(output);
           closeQuietly(input);
         }
       }
     }
   } finally {
     if (zf != null) {
       zf.close();
     }
   }
   return files;
 }
Beispiel #14
0
  public void parse(
      InputStream stream, ContentHandler baseHandler, Metadata metadata, ParseContext context)
      throws IOException, SAXException, TikaException {

    // As we don't know which of the metadata or the content
    //  we'll hit first, catch the endDocument call initially
    EndDocumentShieldingContentHandler handler =
        new EndDocumentShieldingContentHandler(baseHandler);

    // Process the file in turn
    ZipInputStream zip = new ZipInputStream(stream);
    ZipEntry entry = zip.getNextEntry();
    while (entry != null) {
      if (entry.getName().equals("mimetype")) {
        String type = IOUtils.toString(zip, "UTF-8");
        metadata.set(Metadata.CONTENT_TYPE, type);
      } else if (entry.getName().equals("meta.xml")) {
        meta.parse(zip, new DefaultHandler(), metadata, context);
      } else if (entry.getName().endsWith("content.xml")) {
        content.parse(zip, handler, metadata, context);
      }
      entry = zip.getNextEntry();
    }

    // Only now call the end document
    if (handler.getEndDocumentWasCalled()) {
      handler.reallyEndDocument();
    }
  }
Beispiel #15
0
  public static final boolean unzip(File file, File target) throws MojoExecutionException {
    Enumeration entries;
    ZipFile zipFile;

    display(" --- Extracting ---");

    try {

      zipFile = new ZipFile(file);

      entries = zipFile.entries();

      while (entries.hasMoreElements()) {
        ZipEntry entry = (ZipEntry) entries.nextElement();

        if (entry.isDirectory()) {
          display("       + " + entry.getName());
          File newFolder = new File(target + "/" + entry.getName());
          newFolder.mkdir();
          continue;
        }

        display("         " + entry.getName());
        copyInputStream(
            zipFile.getInputStream(entry),
            new BufferedOutputStream(new FileOutputStream(target + "/" + entry.getName())));
      }

      zipFile.close();
      return true;

    } catch (IOException ioe) {
      throw new MojoExecutionException("Unzip Error", ioe);
    }
  }
Beispiel #16
0
 /**
  * Unzip the zip file and put all the files in the zip file to the path.
  *
  * <p><strong>WARN:</strong> If the file list can not pass the checker's validation, delete all
  * the contents in the {@code path}, and the {@code path} itself.
  *
  * @param zipFile zipFile object
  * @param path target path
  * @param checker checker to validate ZIP files.
  * @throws AppException if exception occurred, convert them into {@code AppException} object.
  */
 public static void unzipFile(ZipFile zipFile, String path, Checker<File> checker)
     throws AppException {
   try {
     Enumeration<?> enumeration = zipFile.entries();
     while (enumeration.hasMoreElements()) {
       ZipEntry zipEntry = (ZipEntry) enumeration.nextElement();
       if (zipEntry.isDirectory()) {
         if (!new File(path + "/" + zipEntry.getName()).mkdirs()) throw new Exception();
         continue;
       }
       File file = new File(path + "/" + zipEntry.getName());
       File parent = file.getParentFile();
       if (parent != null && !parent.exists()) {
         if (!parent.mkdirs()) throw new AppException();
       }
       FileUtil.saveToFile(zipFile.getInputStream(zipEntry), new FileOutputStream(file));
     }
     zipFile.close();
     File targetFile = new File(path);
     try {
       checker.check(targetFile);
     } catch (AppException e) {
       FileUtil.clearDirectory(targetFile.getAbsolutePath());
       throw e;
     }
   } catch (AppException e) {
     throw e;
   } catch (Exception e) {
     e.printStackTrace();
     throw new AppException("Unzip zip file error.");
   }
 }
  private List<ComponentDeclaration> getDeclaredComponents(File jarFile) throws IOException {
    ZipInputStream zis = new ZipInputStream(new FileInputStream(jarFile));

    List<ComponentDeclaration> componentDeclarations = null;
    List<ComponentDeclaration> componentOverrideDeclarations = null;

    try {
      for (ZipEntry entry = zis.getNextEntry();
          entry != null && (componentDeclarations == null || componentOverrideDeclarations == null);
          entry = zis.getNextEntry()) {
        if (entry.getName().equals(ComponentAnnotationLoader.COMPONENT_LIST)) {
          componentDeclarations = this.jarLoader.getDeclaredComponents(zis);
        } else if (entry.getName().equals(ComponentAnnotationLoader.COMPONENT_OVERRIDE_LIST)) {
          componentOverrideDeclarations = this.jarLoader.getDeclaredComponents(zis);
        }
      }
    } finally {
      zis.close();
    }

    // Merge all overrides found with a priority of 0. This is purely for backward compatibility
    // since the
    // override files is now deprecated.
    if (componentOverrideDeclarations != null) {
      if (componentDeclarations == null) {
        componentDeclarations = new ArrayList<ComponentDeclaration>();
      }
      for (ComponentDeclaration componentOverrideDeclaration : componentOverrideDeclarations) {
        componentDeclarations.add(
            new ComponentDeclaration(componentOverrideDeclaration.getImplementationClassName(), 0));
      }
    }

    return componentDeclarations;
  }
  protected void load(ZipFile zipfile) throws IOException {
    Enumeration entries = zipfile.entries();
    while (entries.hasMoreElements()) {
      ZipEntry entry = (ZipEntry) entries.nextElement();

      fireBeginFile(entry.getName());

      Logger.getLogger(getClass())
          .debug("Starting file " + entry.getName() + " (" + entry.getSize() + " bytes)");

      byte[] bytes = null;
      InputStream in = null;
      try {
        in = zipfile.getInputStream(entry);
        bytes = readBytes(in);
      } finally {
        if (in != null) {
          try {
            in.close();
          } catch (IOException ex) {
            // Ignore
          }
        }
      }

      Logger.getLogger(getClass())
          .debug("Passing up file " + entry.getName() + " (" + bytes.length + " bytes)");
      getLoader().load(entry.getName(), new ByteArrayInputStream(bytes));

      fireEndFile(entry.getName());
    }
  }
  /**
   * Unzip an archive
   *
   * @param zipname the archive name, stored in the temp directory
   * @return boolean state indicating the unzip success
   */
  private boolean UnzipLangArchive(String zipname) {
    ZipFile zipFile;

    // reset the statuses, thus we will be able to get the progress[%] status
    m_lMaxDownloadSz = GetZipSize(zipname);
    m_lCurrentDownloadSz = 0;

    try {
      zipFile = new ZipFile(zipname);

      Enumeration entries = zipFile.entries();
      while (entries.hasMoreElements()) {
        ZipEntry entry = (ZipEntry) entries.nextElement();

        String filename = entry.getName();
        Log.v(TAG, "Extracting file: " + filename);

        if (!CopyInputStream(zipFile.getInputStream(entry), entry.getSize(), entry.getName()))
          return false;
        m_ParentProgressDialog.setProgress(GetDownloadStatus());
      }

      zipFile.close();
    } catch (IOException ioe) {
      Log.v(TAG, "exception:" + ioe.toString());
      return false;
    }

    return true;
  }
Beispiel #20
0
  private List<String> getClasses() throws IOException {
    if (zipClasses.size() != 0) {
      return zipClasses;
    }
    List<String> classNames = new ArrayList<String>();
    ZipInputStream zip = null;

    try {
      zip = new ZipInputStream(new FileInputStream("plugins/DDCustomPlugin.jar"));
    } catch (FileNotFoundException e) {
      throw new IOException();
    }
    for (ZipEntry entry = zip.getNextEntry(); entry != null; entry = zip.getNextEntry())
      if (entry.getName().endsWith(".class") && !entry.isDirectory()) {
        // This ZipEntry represents a class. Now, what class does it represent?
        StringBuilder className = new StringBuilder();
        for (String part : entry.getName().split("/")) {
          if (className.length() != 0) className.append(".");
          className.append(part);
          if (part.endsWith(".class")) className.setLength(className.length() - ".class".length());
        }
        if (className.toString().indexOf("$") == -1) classNames.add(className.toString());
      }
    zipClasses = classNames;
    return classNames;
  }
  /**
   * extracts class files from jar/zip archive to specified path. See <code>IDecompiler</code>
   * documentation for the format of pareameters.
   */
  public static void extract(
      String archivePath, String packege, String className, boolean inner, String to)
      throws IOException {
    ZipFile archive = new ZipFile(archivePath);
    List entries = findRelevant(archive, packege, className, inner);
    InputStream in = null;
    OutputStream out = null;
    byte[] buffer = new byte[2048];
    ZipEntry entry;
    String outFile;
    int lastSep, amountRead;

    for (int i = 0; i < entries.size(); i++) {
      entry = (ZipEntry) entries.get(i);
      outFile = entry.getName();
      if ((lastSep = outFile.lastIndexOf('/')) != -1) outFile = outFile.substring(lastSep);

      try {
        in = archive.getInputStream(entry);
        if (in == null) throw new IOException("Zip file entry <" + entry.getName() + "> not found");
        out = new FileOutputStream(to + File.separator + outFile);

        while ((amountRead = in.read(buffer)) != -1) out.write(buffer, 0, amountRead);
      } finally {
        if (in != null) in.close();
        if (out != null) out.close();
      }
    }
  }
Beispiel #22
0
  /**
   * 真正的解压方法 会删除解压完的所有Zip文档
   *
   * @param File 一个。zip的 文件
   */
  public static void myzijide(File file) throws IOException {

    ZipInputStream zip = new ZipInputStream(new FileInputStream(file));
    ZipEntry en = null;
    BufferedOutputStream out = null;
    // 循环读取ZIP文件中的内容
    while ((en = zip.getNextEntry()) != null) {
      if (en.isDirectory()) {
        File f = new File(file.getParent() + "\\" + en.getName());
        if (!f.exists()) f.mkdirs();
        continue;
      }
      // 发现好多文件夹存在 Thumbs , 定一个识别将他过滤
      //  文件名中含有Thumbs 将 不 解压
      if (en.getName().contains("Thumbs")) {
        continue;
      }

      // 实际的输出方法
      out = new BufferedOutputStream(new FileOutputStream(file.getParent() + "\\" + en.getName()));

      int i = -1;
      byte[] b = new byte[1024];
      while ((i = zip.read(b)) != -1) {
        out.write(b, 0, i);
      }
      out.close();
    }
    zip.close();

    // 删除文件
    String tishi = file.delete() ? "yes" : "no";
    System.out.println(file.getName() + "解压完成并删除 ?" + tishi);
  }
Beispiel #23
0
 public static LinkedHashMap readJarFileEntries(File jarFile) throws Exception {
   LinkedHashMap entries = new LinkedHashMap();
   JarFile jarFileWrapper = null;
   if (jarFile != null) {
     logger.debug("Reading jar entries from " + jarFile.getAbsolutePath());
     try {
       jarFileWrapper = new JarFile(jarFile);
       Enumeration iter = jarFileWrapper.entries();
       while (iter.hasMoreElements()) {
         ZipEntry zipEntry = (ZipEntry) iter.nextElement();
         InputStream entryStream = jarFileWrapper.getInputStream(zipEntry);
         ByteArrayOutputStream byteArrayStream = new ByteArrayOutputStream();
         try {
           IOUtils.copy(entryStream, byteArrayStream);
           entries.put(zipEntry.getName(), byteArrayStream.toByteArray());
           logger.debug(
               "Read jar entry " + zipEntry.getName() + " from " + jarFile.getAbsolutePath());
         } finally {
           byteArrayStream.close();
         }
       }
     } finally {
       if (jarFileWrapper != null) {
         try {
           jarFileWrapper.close();
         } catch (Exception ignore) {
           logger.debug(ignore);
         }
       }
     }
   }
   return entries;
 }
Beispiel #24
0
 private TreeSet<String> findClasses(String directory, String packageName) throws IOException {
   TreeSet<String> classes = new TreeSet<String>();
   if (directory.startsWith("file:") && directory.contains("!")) {
     String[] split = directory.split("!");
     URL jar = new URL(split[0]);
     ZipInputStream zip = new ZipInputStream(jar.openStream());
     ZipEntry entry = null;
     while ((entry = zip.getNextEntry()) != null) {
       if (entry.getName().startsWith("husacct/validate/domain/validation/ruletype")
           && entry.getName().endsWith(".class")) {
         final String className =
             entry.getName().replaceAll("[$].*", "").replaceAll("[.]class", "").replace('/', '.');
         classes.add(className);
       }
     }
   }
   File dir = new File(URLDecoder.decode(directory, "UTF-8"));
   if (!dir.exists()) {
     return classes;
   }
   File[] files = dir.listFiles();
   for (File file : files) {
     if (file.isDirectory()) {
       assert !file.getName().contains(".");
       classes.addAll(findClasses(file.getAbsolutePath(), packageName + "." + file.getName()));
     } else if (file.getName().endsWith(".class")) {
       classes.add(packageName + '.' + file.getName().substring(0, file.getName().length() - 6));
     }
   }
   return classes;
 }
Beispiel #25
0
  protected void unpackComponents() throws IOException, FileNotFoundException {
    File applicationPackage = new File(getApplication().getPackageResourcePath());
    File componentsDir = new File(sGREDir, "components");
    if (componentsDir.lastModified() == applicationPackage.lastModified()) return;

    componentsDir.mkdir();
    componentsDir.setLastModified(applicationPackage.lastModified());

    GeckoAppShell.killAnyZombies();

    ZipFile zip = new ZipFile(applicationPackage);

    byte[] buf = new byte[32768];
    try {
      if (unpackFile(zip, buf, null, "removed-files")) removeFiles();
    } catch (Exception ex) {
      // This file may not be there, so just log any errors and move on
      Log.w(LOG_FILE_NAME, "error removing files", ex);
    }

    // copy any .xpi file into an extensions/ directory
    Enumeration<? extends ZipEntry> zipEntries = zip.entries();
    while (zipEntries.hasMoreElements()) {
      ZipEntry entry = zipEntries.nextElement();
      if (entry.getName().startsWith("extensions/") && entry.getName().endsWith(".xpi")) {
        Log.i("GeckoAppJava", "installing extension : " + entry.getName());
        unpackFile(zip, buf, entry, entry.getName());
      }
    }
  }
Beispiel #26
0
  protected void unzip(String pathToFile, String outputFolder) {
    System.out.println("Start unzipping: " + pathToFile + " to " + outputFolder);
    String pathToUnzip;
    if (outputFolder.equals(pathManager.getPlatformFolderInAndroidSdk())) {
      pathToUnzip = outputFolder;
    } else {
      pathToUnzip = outputFolder + "/" + FileUtil.getNameWithoutExtension(new File(pathToFile));
    }
    if (new File(pathToUnzip).listFiles() != null) {
      System.out.println("File was already unzipped: " + pathToFile);
      return;
    }
    try {
      byte[] buf = new byte[1024];
      ZipInputStream zipinputstream = null;
      ZipEntry zipentry;
      zipinputstream = new ZipInputStream(new FileInputStream(pathToFile));

      zipentry = zipinputstream.getNextEntry();
      try {
        while (zipentry != null) {
          String entryName = zipentry.getName();
          int n;
          File outputFile = new File(outputFolder + "/" + entryName);

          if (zipentry.isDirectory()) {
            outputFile.mkdirs();
            zipinputstream.closeEntry();
            zipentry = zipinputstream.getNextEntry();
            continue;
          } else {
            File parentFile = outputFile.getParentFile();
            if (parentFile != null && !parentFile.exists()) {
              parentFile.mkdirs();
            }
            outputFile.createNewFile();
          }

          FileOutputStream fileoutputstream = new FileOutputStream(outputFile);
          try {
            while ((n = zipinputstream.read(buf, 0, 1024)) > -1) {
              fileoutputstream.write(buf, 0, n);
            }
          } finally {
            fileoutputstream.close();
          }
          zipinputstream.closeEntry();
          zipentry = zipinputstream.getNextEntry();
        }

        zipinputstream.close();
      } catch (IOException e) {
        System.err.println("Entry name: " + zipentry.getName());
        e.printStackTrace();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("Finish unzipping: " + pathToFile + " to " + outputFolder);
  }
Beispiel #27
0
  protected static File file(final File root, final ZipEntry entry) throws IOException {

    if (root == null) {
      throw new NullPointerException("root");
    }

    if (!root.isDirectory()) {
      throw new IllegalArgumentException("root is not an existing directory");
    }

    if (entry == null) {
      throw new NullPointerException("entry");
    }

    final File file = new File(root, entry.getName());

    File parent = file;
    if (!entry.isDirectory()) {
      final String name = entry.getName();
      final int index = name.lastIndexOf('/');
      if (index != -1) {
        parent = new File(root, name.substring(0, index));
      }
    }
    if (parent != null && !parent.isDirectory() && !parent.mkdirs()) {
      throw new IOException("failed to create a directory: " + parent.getPath());
    }

    return file;
  }
Beispiel #28
0
  /**
   * Add the entries from the supplied {@link ZipInputStream} to this archive instance.
   *
   * @param zipStream The zip stream.
   * @return This archive instance.
   * @throws IOException Error reading zip stream.
   */
  public Archive addEntries(ZipInputStream zipStream) throws IOException {
    AssertArgument.isNotNull(zipStream, "zipStream");

    try {
      ZipEntry zipEntry = zipStream.getNextEntry();
      ByteArrayOutputStream outByteStream = new ByteArrayOutputStream();
      byte[] byteReadBuffer = new byte[512];
      int byteReadCount;

      while (zipEntry != null) {
        if (zipEntry.isDirectory()) {
          addEntry(zipEntry.getName(), (byte[]) null);
        } else {
          while ((byteReadCount = zipStream.read(byteReadBuffer)) != -1) {
            outByteStream.write(byteReadBuffer, 0, byteReadCount);
          }
          addEntry(zipEntry.getName(), outByteStream.toByteArray());
          outByteStream.reset();
        }
        zipEntry = zipStream.getNextEntry();
      }
    } finally {
      try {
        zipStream.close();
      } catch (IOException e) {
        logger.debug("Unexpected error closing EDI Mapping Model Zip stream.", e);
      }
    }

    return this;
  }
Beispiel #29
0
 private void checkLoadedModForPermissionClass(File modFile) {
   try {
     Pattern p = Pattern.compile("permission", Pattern.CASE_INSENSITIVE);
     if (modFile.isDirectory()) {
       for (File file : modFile.listFiles()) {
         checkLoadedModForPermissionClass(file);
       }
     } else if ((modFile.getName().endsWith(".zip")) || (modFile.getName().endsWith(".jar"))) {
       ZipFile zip = new ZipFile(modFile);
       Enumeration entries = zip.entries();
       while (entries.hasMoreElements()) {
         ZipEntry zipentry = (ZipEntry) entries.nextElement();
         if (zipentry != null
             && zipentry.getName().endsWith(".class")
             && p.matcher(zipentry.getName()).find()) {
           checkLoadedClass(zip.getInputStream(zipentry));
         }
       }
       zip.close();
     } else if (modFile.getName().endsWith(".class") && p.matcher(modFile.getName()).find()) {
       checkLoadedClass(new FileInputStream(modFile));
     }
   } catch (IOException e) {
   }
 }
  protected void init() throws IOException {
    for (int i = 0; i < urls.length; i++) {
      Set<String> files = new HashSet<String>(500);

      URLConnection c = urls[i].openConnection();
      ByteArrayOutputStream baos = new ByteArrayOutputStream(20000);

      ZipInputStream zis = new ZipInputStream(c.getInputStream());
      ZipEntry ze = zis.getNextEntry();
      while (ze != null) {
        int start = baos.size();
        startPosition.put(ze.getName(), start);
        RepositoryHelp.streamCopy(zis, baos, false);
        int end = baos.size();
        lengths.put(ze.getName(), end - start);
        files.add(ze.getName());
        ze = zis.getNextEntry();
      }

      zis.close();
      baos.close();

      byte[] theFile = baos.toByteArray();

      for (String name : files) {
        memoryMappedFiles.put(name, theFile);
      }

      log("mapped file: " + urls[i]);
    }
  }