コード例 #1
0
  /**
   * @param uri The URI of the file to identify
   * @param request The Identification Request
   * @throws CommandExecutionException When an exception happens during execution
   * @throws CommandExecutionException When an exception happens during archive file input/output
   */
  public final void identify(final URI uri, final IdentificationRequest request)
      throws CommandExecutionException {

    final String newPath = makeContainerURI("gzip", request.getFileName());
    setSlash1("");
    final URI newUri = URI.create(GzipUtils.getUncompressedFilename(uri.toString()));

    final RequestIdentifier identifier = new RequestIdentifier(newUri);
    final RequestMetaData metaData = new RequestMetaData(SIZE, TIME, uri.getPath());
    final GZipIdentificationRequest gzRequest =
        new GZipIdentificationRequest(metaData, identifier, getTmpDir());

    GzipCompressorInputStream gzin = null;
    try {
      gzin = new GzipCompressorInputStream(new FileInputStream(request.getSourceFile()), true);

      expandContainer(gzRequest, gzin, newPath);

    } catch (IOException ioe) {
      System.err.println(ioe + " (" + newPath + ")"); // continue after corrupt archive
    } finally {
      if (gzin != null) {
        try {
          gzin.close();
        } catch (IOException ioe) {
          throw new CommandExecutionException(ioe.getMessage(), ioe);
        }
      }
    }
  }
コード例 #2
0
 private IdentificationResultCollection handleContainer(
     IdentificationRequest request, IdentificationResultCollection results) throws IOException {
   // process a container format (ole2, odf, ooxml etc)
   String containerFormat = getContainerFormat(results);
   try {
     if (containerFormatResolver != null && containerFormat != null) {
       ContainerIdentifier containerIdentifier =
           containerIdentifierFactory.getIdentifier(containerFormat);
       containerIdentifier.setMaxBytesToScan(maxBytesToScan);
       IdentificationResultCollection containerResults = containerIdentifier.submit(request);
       droidCore.removeLowerPriorityHits(containerResults);
       droidCore.checkForExtensionsMismatches(containerResults, request.getExtension());
       containerResults.setFileLength(request.size());
       containerResults.setRequestMetaData(request.getRequestMetaData());
       return containerResults.getResults().isEmpty() ? null : containerResults;
     }
     // CHECKSTYLE:OFF - rules say don't catch this, but other code keeps on throwing them.
     // Don't prejudice any results so far because other code isn't following 'the rules'.
   } catch (Exception e) {
     // CHECKSTYLE:ON
     String causeMessage = "";
     if (e.getCause() != null) {
       causeMessage = e.getCause().getMessage();
     }
     final String message =
         String.format(
             CONTAINER_ERROR,
             containerFormat,
             request.getIdentifier().getUri().toString(),
             e.getMessage(),
             causeMessage);
     log.warn(message);
   }
   return null;
 }
コード例 #3
0
 private void closeRequest() {
   requests.remove(request);
   try {
     request.close();
   } catch (IOException e) {
     log.error(String.format("Error closing request [%s]", request.getIdentifier().getUri()), e);
   }
 }
コード例 #4
0
  /**
   * @param request The archive request to handle.
   * @param results The previous identification results for the archive format.
   * @return
   */
  private boolean handleArchive(
      IdentificationRequest request, IdentificationResultCollection results) {

    boolean jobCountDecremented = false;

    String archiveFormat = getArchiveFormat(results);
    if (archiveFormat != null) {
      results.setArchive(true);
      ResourceId id = resultHandler.handle(results);
      jobCounter.incrementPostProcess();
      RequestIdentifier identifier = request.getIdentifier();
      identifier.setResourceId(id);
      if (identifier.getAncestorId() == null) {
        identifier.setAncestorId(id.getId());
      }
      submissionQueue.add(request.getIdentifier());
      jobCounter.decrement();
      jobCountDecremented = true;
      try {
        // BNO: Does this always return the same archive handler for any given container format?
        // And will it end up using the same submission gateway, or a new one with a different
        // thread pool?
        ArchiveHandler handler = archiveHandlerFactory.getHandler(archiveFormat);
        handler.handle(request);
        // CHECKSTYLE:OFF
      } catch (Exception e) {
        // CHECKSTYLE:ON
        String causeMessage = "";
        if (e.getCause() != null) {
          causeMessage = e.getCause().getMessage();
        }
        final String message =
            String.format(
                ARCHIVE_ERROR,
                archiveFormat,
                request.getIdentifier().getUri().toString(),
                e.getMessage(),
                causeMessage);
        log.warn(message);
        resultHandler.handleError(
            new IdentificationException(request, IdentificationErrorType.OTHER, e));
      } finally {
        submissionQueue.remove(request.getIdentifier());
        jobCounter.decrementPostProcess();
      }
    } else {
      ResourceId id = resultHandler.handle(results);
      request.getIdentifier().setNodeId(id.getId());
    }
    return jobCountDecremented;
  }
コード例 #5
0
 private IdentificationResultCollection handleExtensions(
     IdentificationRequest request, IdentificationResultCollection results) {
   IdentificationResultCollection extensionResults = results;
   try {
     List<IdentificationResult> resultList = results.getResults();
     if (resultList != null && resultList.isEmpty()) {
       // If we call matchExtensions with "true", it will match
       // ALL files formats which have a given extension.
       // If "false", it will only match file formats for which
       // there is no other signature defined.
       IdentificationResultCollection checkExtensionResults =
           droidCore.matchExtensions(request, matchAllExtensions);
       if (checkExtensionResults != null) {
         extensionResults = checkExtensionResults;
       }
     } else {
       droidCore.checkForExtensionsMismatches(extensionResults, request.getExtension());
     }
     // CHECKSTYLE:OFF - do not allow any errors in other code to
     //    prevent results so far from being recorded.
   } catch (Exception e) {
     log.error(e);
   }
   // CHECKSTYLE:ON
   return extensionResults;
 }
コード例 #6
0
 private void generateHash(IdentificationRequest request) throws IOException {
   if (generateHash) {
     try {
       InputStream in = request.getSourceInputStream();
       try {
         String hash = hashGenerator.hash(in);
         request.getRequestMetaData().setHash(hash);
       } finally {
         if (in != null) {
           in.close();
         }
       }
       // CHECKSTYLE:OFF - generating a hash can't prejudice any other results
     } catch (Exception e) {
       log.error(e);
     }
     // CHECKSTYLE:ON
   }
 }
コード例 #7
0
    @Override
    protected void done() {
      boolean jobCountDecremented = false;
      try {
        generateHash(request);
        IdentificationResultCollection results = get();
        IdentificationResultCollection containerResults = handleContainer(request, results);
        if (containerResults == null) {
          // no container results - process the normal results.
          droidCore.removeLowerPriorityHits(results);
          results = handleExtensions(request, results);

          // Are we processing archive formats?
          if ((processArchives || processWebArchives) && archiveFormatResolver != null) {
            jobCountDecremented = handleArchive(request, results);
          } else { // just process the results so far:
            results.setArchive(getArchiveFormat(results) != null);
            ResourceId id = resultHandler.handle(results);
            request.getIdentifier().setResourceId(id);
          }
        } else { // we have possible container formats:
          droidCore.removeLowerPriorityHits(containerResults);
          containerResults = handleExtensions(request, containerResults);
          ResourceId id = resultHandler.handle(containerResults);
          request.getIdentifier().setResourceId(id);
        }
      } catch (ExecutionException e) {
        final Throwable cause = e.getCause();
        log.error(cause.getStackTrace(), cause);
        resultHandler.handleError(
            new IdentificationException(request, IdentificationErrorType.OTHER, cause));
      } catch (InterruptedException e) {
        log.debug(e);
      } catch (IOException e) {
        resultHandler.handleError(
            new IdentificationException(request, IdentificationErrorType.OTHER, e));
      } finally {
        closeRequest();
        if (!jobCountDecremented) {
          jobCounter.decrement();
        }
      }
    }
コード例 #8
0
  /*
   ** Similar to above - except that there is no second occurrence of the final left fragment - and
   ** the sole occurrence of this fragment is beyond the maximum offset for the sequence as a whole
   ** from BOF. N.B. This test passes in the previous version DROID 6.2.1
   */
  @Test
  public void testFinalLeftFragmentBeyondSeqMaxOffset() throws Exception {

    final String sigFile = "left-frag-1200.xml";
    final String fileToScan = "left1200a.ext";
    final String expectedPuid = "dev/1200";

    BinarySignatureIdentifier droid = new BinarySignatureIdentifier();
    droid.setSignatureFile(TESTAREA + sigFile);
    try {
      droid.init();
    } catch (SignatureParseException x) {
      assertEquals("Can't parse signature file", x.getMessage());
    }
    File file = new File(TESTAREA + fileToScan);
    assertTrue(file.exists());
    URI resourceUri = file.toURI();

    RequestMetaData metaData = new RequestMetaData(file.length(), file.lastModified(), fileToScan);
    RequestIdentifier identifier = new RequestIdentifier(resourceUri);
    identifier.setParentId(1L);

    IdentificationRequest<File> request = new FileSystemIdentificationRequest(metaData, identifier);
    request.open(file);

    IdentificationResultCollection resultsCollection = droid.matchBinarySignatures(request);
    List<IdentificationResult> results = resultsCollection.getResults();

    assertEquals(0, results.size());

    Iterator<IdentificationResult> iter = results.iterator();
    while (iter.hasNext()) {
      IdentificationResult result = iter.next();
      assertEquals(expectedPuid, result.getPuid());
    }
  }
コード例 #9
0
 /**
  * Shuts down the executor service and closes any in-flight requests.
  *
  * @throws IOException if temp files could not be deleted.
  */
 public void close() throws IOException {
   executorService.shutdownNow();
   for (IdentificationRequest request : requests) {
     request.close();
   }
 }
コード例 #10
0
    /**
     * Run droid identification on file
     *
     * @param filePath Absolute file path
     * @return Result list
     * @throws FileNotFoundException
     * @throws IOException
     */
    @Override
    public HashMap<String, String> identify(File file) throws FileNotFoundException {
        HashMap<String, String> droidIdRes = new HashMap<String, String>();
        InputStream in = null;
        IdentificationRequest request = null;

        try {
            URI resourceUri = file.toURI();
            in = new FileInputStream(file);
            LOG.debug("Identification of resource: " + resourceUri.toString());
            RequestMetaData metaData = new RequestMetaData(file.length(), file.lastModified(), file.getName());
            LOG.debug("File length: " + file.length());
            LOG.debug("File modified: " + file.lastModified());
            LOG.debug("File name: " + file.getName());
            RequestIdentifier identifier = new RequestIdentifier(resourceUri);
            request = new FileSystemIdentificationRequest(metaData, identifier);
            request.open(in);
            IdentificationResultCollection results = bsi.matchBinarySignatures(request);
            bsi.removeLowerPriorityHits(results);
            if (results == null || results.getResults() == null || results.getResults().isEmpty()) {
                LOG.debug("No identification result");
            } else {
                List<IdentificationResult> result = results.getResults();
                if (result != null && !result.isEmpty()) {
                    for (IdentificationResult ir : result) {
                        String mime = ir.getMimeType();
                        if (mime != null && !mime.isEmpty()) {
                            // take first mime, ignore others
                            if (!droidIdRes.containsKey("mime")) {
                                droidIdRes.put("mime", mime);
                            }
                        }
                        String puid = ir.getPuid();
                        if (puid != null && !puid.isEmpty()) {
                            // take first puid, ignore others
                            if (!droidIdRes.containsKey("puid")) {
                                droidIdRes.put("puid", puid);
                            }
                        }
                    }
                }
            }
            in.close();
            request.close();
        } catch (IOException ex) {
            LOG.error("I/O Exception", ex);
        } finally {
            try {
                in.close();
                request.close();
            } catch (IOException _) {
            }
        }
        if (!droidIdRes.containsKey("mime")) {
            droidIdRes.put("mime", MIME_UNKNOWN);
        }
        if (!droidIdRes.containsKey("puid")) {
            droidIdRes.put("puid", "fmt/0");
        }
        return droidIdRes;
    }