Esempio n. 1
1
  /**
   * Gets an array of PIM items from an encoded input stream and list.
   *
   * @param is data input stream
   * @param enc character encoding of stream data
   * @param list populate from list
   * @return array of PIM items
   * @throws PIMException if any error reading the PIM data
   * @throws UnsupportedEncodingException if encoding is not supported
   */
  private PIMItem[] fromSerialFormat(InputStream is, String enc, PIMList list)
      throws PIMException, UnsupportedEncodingException {

    if (enc == null) {
      enc = "UTF-8" /* NO I18N */;
    }
    InputStream in = new MarkableInputStream(is);
    in.mark(Integer.MAX_VALUE);
    try {
      for (int i = 0; i < formats.length; i++) {
        try {
          PIMItem[] items = formats[i].decode(in, enc, list);
          if (items == null) {
            throw new PIMException("Empty stream or insufficient data");
          }
          return items;
        } catch (UnsupportedPIMFormatException e) {
          in.reset();
          in.mark(Integer.MAX_VALUE);
        }
      }
      throw new PIMException("Format is not recognized");
    } catch (UnsupportedEncodingException e) {
      throw e;
    } catch (IOException e) {
      throw new PIMException(e.getMessage());
    }
  }
 @Override
 public int getNextEncoded(InputStream is) throws IOException {
   is.mark(4);
   byte[] bytes = new byte[4];
   int count = 0;
   while (count < 4) {
     int nextByte = is.read();
     if (nextByte == -1) {
       return -1;
     }
     bytes[count++] = (byte) nextByte;
     if (checkRange(bytes, count)) {
       return toInt(bytes, 0, count);
     }
   }
   is.reset();
   // invalid code, try to determine number of bytes to consume
   bytes = new byte[4];
   count = 0;
   while (count < 4) {
     is.mark(1);
     int nextByte = is.read();
     if (nextByte == -1) {
       return -1;
     }
     bytes[count++] = (byte) nextByte;
     if (!checkPrefix(bytes, count)) {
       // todo 1 this is not correct - must pad to next range size
       is.reset();
       count--;
       return toInt(bytes, 0, count);
     }
   }
   return -1;
 }
  public Object engineRead() throws StreamParsingException {
    try {
      if (sData != null) {
        if (sDataObjectCount != sData.size()) {
          return getCertificate();
        } else {
          sData = null;
          sDataObjectCount = 0;
          return null;
        }
      }

      currentStream.mark(10);
      int tag = currentStream.read();

      if (tag == -1) {
        return null;
      }

      if (tag != 0x30) // assume ascii PEM encoded.
      {
        currentStream.reset();
        return readPEMCertificate(currentStream);
      } else {
        currentStream.reset();
        return readDERCertificate(currentStream);
      }
    } catch (Exception e) {
      throw new StreamParsingException(e.toString(), e);
    }
  }
Esempio n. 4
1
  /**
   * Reads a signature if it applies. Currently BIRT can recognize the following signatures:
   *
   * <ul>
   *   <li>SIGNATURE_UTF_8
   *   <li>SIGNATURE_UNICODE_BIG
   *   <li>SIGNATURE_UNICODE_LITTLE
   *   <li>SIGNATURE_UCS4_BIG_8
   *   <li>SIGNATURE_UCS4_LITTLE
   * </ul>
   *
   * @param inputStream the input stream of the unicode file
   * @return the encoding signature from the unicode file.
   * @throws IOException if errors occur when reading bytes from the input stream
   */
  public static String checkUTFSignature(InputStream inputStream) throws IOException {

    inputStream.mark(1024);

    int byte1 = inputStream.read();
    int byte2 = inputStream.read();
    if (byte1 == 0xFE && byte2 == 0xFF) {
      return SIGNATURE_UNICODE_BIG;
    } else if (byte1 == 0xFF && byte2 == 0xFE) {

      return SIGNATURE_UNICODE_LITTLE;
    }

    int byte3 = inputStream.read();

    // check for UTF-8 byte order mark

    if (byte1 == 0xEF && byte2 == 0xBB && byte3 == 0xBF) {
      return SIGNATURE_UTF_8;
    }

    int byte4 = inputStream.read();
    if (byte1 == 0x00 && byte2 == 0x00 && byte3 == 0xFE && byte4 == 0xFF) {
      return SIGNATURE_UCS4_BIG;
    } else if (byte1 == 0x00 && byte2 == 0x00 && byte3 == 0xFF && byte4 == 0xFE) {
      return SIGNATURE_UCS4_LITTLE;
    }

    inputStream.reset();
    return null;
  }
  @SmallTest
  public void testRun() throws Exception {
    MemoryFile file = new MemoryFile("MemoryFileTest", 1000000);

    byte[] buffer = new byte[testString.length];

    // check low level accessors
    file.writeBytes(testString, 0, 2000, testString.length);
    file.readBytes(buffer, 2000, 0, testString.length);
    compareBuffers(testString, buffer, testString.length);

    // check streams
    buffer = new byte[testString.length];

    OutputStream os = file.getOutputStream();
    os.write(testString);

    InputStream is = file.getInputStream();
    is.mark(testString.length);
    is.read(buffer);
    compareBuffers(testString, buffer, testString.length);

    // test mark/reset
    buffer = new byte[testString.length];
    is.reset();
    is.read(buffer);
    compareBuffers(testString, buffer, testString.length);

    file.close();
  }
Esempio n. 6
1
  /**
   * Method to verify if receieved stream has content or its empty
   *
   * @param stream Stream to check
   * @return verified stream
   * @throws IOException
   */
  private InputStream verifyContentReceieved(InputStream stream) throws IOException {

    if (stream == null) { // Check if its null
      logger.debug("Request stream received as null");
      return null;
    } else if (stream.markSupported()) { // Check stream supports mark/reset
      // mark() and read the first byte just to check
      stream.mark(1);
      final int bytesRead = stream.read(new byte[1]);
      if (bytesRead != -1) {
        // stream not empty
        stream.reset(); // reset the stream as if untouched
        return stream;
      } else {
        // stream empty
        logger.debug("Request received with empty body");
        return null;
      }
    } else {
      // Panic! this stream does not support mark/reset, try with PushbackInputStream as a last
      // resort
      int bytesRead;
      PushbackInputStream pbs = new PushbackInputStream(stream);
      if ((bytesRead = pbs.read()) != -1) {
        // Contents detected, unread and return
        pbs.unread(bytesRead);
        return pbs;
      } else {
        // Empty stream detected
        logger.debug("Request received with empty body!");
        return null;
      }
    }
  }
Esempio n. 7
1
  /**
   * Finds a suitable analyzer class for the data in this stream
   *
   * @param in The stream containing the data to analyze
   * @return the analyzer factory to use
   * @throws java.io.IOException if an error occurs while reading data from the stream
   */
  public static FileAnalyzerFactory find(InputStream in) throws IOException {
    in.mark(8);
    byte[] content = new byte[8];
    int len = in.read(content);
    in.reset();

    if (len < 8) {
      /*
       * Need at least 4 bytes to perform magic string matching.
       */
      if (len < 4) {
        return null;
      }
      content = Arrays.copyOf(content, len);
    }

    FileAnalyzerFactory factory = find(content);
    if (factory != null) {
      return factory;
    }

    for (FileAnalyzerFactory.Matcher matcher : matchers) {
      FileAnalyzerFactory fac = matcher.isMagic(content, in);
      if (fac != null) {
        return fac;
      }
    }

    return null;
  }
 private void loadProps(Properties props, File file) throws IOException {
   InputStream fin = null;
   try {
     fin = new BufferedInputStream(new FileInputStream(file), 1);
     fin.mark(1);
     int c = fin.read();
     fin.reset();
     if (c == '#') {
       // uncompressed
       if (_log.shouldLog(Log.INFO))
         _log.info("Loading uncompressed profile data from " + file.getName());
       DataHelper.loadProps(props, fin);
     } else {
       // compressed (or corrupt...)
       if (_log.shouldLog(Log.INFO))
         _log.info("Loading compressed profile data from " + file.getName());
       DataHelper.loadProps(props, new GZIPInputStream(fin));
     }
   } finally {
     try {
       if (fin != null) fin.close();
     } catch (IOException e) {
     }
   }
 }
Esempio n. 9
1
  protected static int[] readHeader(InputStream stream, boolean isBinary, boolean close)
      throws IOException {
    if (isBinary) {
      DataInputStream dis = null;
      try {
        dis = new DataInputStream(stream);

        for (int i = 0; i < LocalFeatureList.BINARY_HEADER.length; i++) dis.readByte();

        // read the header
        final int nItems = dis.readInt();
        final int veclen = dis.readInt();

        return new int[] {nItems, veclen, 8 + LocalFeatureList.BINARY_HEADER.length};
      } finally {
        if (close && dis != null)
          try {
            dis.close();
          } catch (final IOException e) {
          }
      }
    } else {
      InputStreamReader fr = null;
      BufferedReader br = null;
      int nlines = 1;
      final boolean isBuffered = stream.markSupported();
      try {
        if (isBuffered) stream.mark(1024);
        fr = new InputStreamReader(stream);
        br = new BufferedReader(fr);

        // read the header line
        final String head = br.readLine().trim();
        if (isBuffered) stream.reset();
        final String[] h = head.split(" ");

        final int nItems = Integer.decode(h[0]);
        int veclen = 0;
        if (h.length > 1) {
          veclen = Integer.decode(h[1]);
        } else {
          veclen = Integer.decode(br.readLine().trim());
          nlines++;
        }

        return new int[] {nItems, veclen, nlines};
      } finally {
        if (close && br != null)
          try {
            br.close();
          } catch (final IOException e) {
          }
        if (close && fr != null)
          try {
            fr.close();
          } catch (final IOException e) {
          }
      }
    }
  }
Esempio n. 10
1
 /**
  * Parses a property list from an InputStream. It can either be in XML or binary format.
  *
  * @param is The InputStream delivering the property list data
  * @return The root object of the property list
  * @throws Exception If an error occurred while parsing.
  */
 public static NSObject parse(InputStream is) throws Exception {
   if (is.markSupported()) {
     is.mark(10);
     byte[] magic = new byte[8];
     is.read(magic);
     is.reset();
     String magic_string = new String(magic);
     if (magic_string.startsWith("bplist00")) {
       return BinaryPropertyListParser.parse(is);
     } else if (magic_string.startsWith("<?xml")) {
       return XMLPropertyListParser.parse(is);
     } else {
       throw new UnsupportedOperationException(
           "The given data is neither a binary nor a XML property list. ASCII property lists are not supported.");
     }
   } else {
     if (is.available() > Runtime.getRuntime().freeMemory()) {
       throw new Exception(
           "To little heap space available! Wanted to read "
               + is.available()
               + " bytes, but only "
               + Runtime.getRuntime().freeMemory()
               + " are available.");
     }
     byte[] buf = new byte[is.available()];
     is.read(buf);
     is.close();
     return parse(buf);
   }
 }
  /**
   * Create an compressor input stream from an input stream, auto-detecting the compressor type from
   * the first few bytes of the stream. The InputStream must support marks, like
   * BufferedInputStream.
   *
   * @param inputStream the input stream
   * @return the compressor input stream
   * @throws CompressorException if the compressor name is not known
   * @throws IllegalArgumentException if the stream is null or does not support mark
   * @since Commons Compress 1.1
   */
  @Override
  public CompressorInputStream createCompressorInputStream(final InputStream inputStream)
      throws CompressorException {
    checkNotNull(inputStream, "inputStream");
    checkArgument(inputStream.markSupported(), "Mark is not supported.");

    final byte[] signature = new byte[SIGNATURE_LENGTH];
    inputStream.mark(signature.length);
    try {
      int signatureLength = inputStream.read(signature);
      inputStream.reset();
      if (BZip2CompressorInputStream.matches(signature, signatureLength)) {
        return createBZip2CompressorInputStream(inputStream);
      } else if (GzipCompressorInputStream.matches(signature, signatureLength)) {
        return createGZipCompressorInputStream(inputStream);
      } else if (XZCompressorInputStream.matches(signature, signatureLength)) {
        return createXZCompressorInputStream(inputStream);
      } else if (Pack200CompressorInputStream.matches(signature, signatureLength)) {
        return createPack200CompressorInputStream(inputStream);
      } else if (transparentSignatureDetection) {
        return createForwardingCompressorInputStream(inputStream);
      }
    } catch (IOException e) {
      throw new CompressorException("Failed to detect Compressor from InputStream.", e);
    }

    throw new CompressorException("No Compressor found for the stream signature.");
  }
  private ConstraintMappingsType getValidationConfig(InputStream in, Unmarshaller unmarshaller) {
    ConstraintMappingsType constraintMappings;
    try {
      // check whether mark is supported, if so we can reset the stream in order to allow reuse of
      // Configuration
      boolean markSupported = in.markSupported();
      if (markSupported) {
        in.mark(Integer.MAX_VALUE);
      }

      StreamSource stream = new StreamSource(new CloseIgnoringInputStream(in));
      JAXBElement<ConstraintMappingsType> root =
          unmarshaller.unmarshal(stream, ConstraintMappingsType.class);
      constraintMappings = root.getValue();

      if (markSupported) {
        try {
          in.reset();
        } catch (IOException e) {
          log.debug("Unable to reset input stream.");
        }
      }
    } catch (JAXBException e) {
      throw log.getErrorParsingMappingFileException(e);
    }
    return constraintMappings;
  }
Esempio n. 13
1
  /**
   * Determine if the input stream is an HTTP response. If it is then the first 7 characters will be
   * 'HTTP/1.' as in HTTP/1.1 or HTTP/1.0.
   *
   * @return true is this is an HTTP response or false otherwise.
   * @throws IOException if an error occurs while reading the stream.
   */
  protected boolean isHTTP() throws IOException {
    int c1;
    int c2;
    int c3;
    int c4;
    int c5;
    int c6;
    int c7;

    is.mark(10);
    c1 = is.read();
    c2 = is.read();
    c3 = is.read();
    c4 = is.read();
    c5 = is.read();
    c6 = is.read();
    c7 = is.read();
    is.reset();

    if ((c1 == 'H') && (c2 == 'T') && (c3 == 'T') && (c4 == 'P') && (c5 == '/') && (c6 == '1')
        && (c7 == '.')) {
      return true;
    } else {
      return false;
    }
  }
Esempio n. 14
1
  /**
   * Convert input stream to a string
   *
   * @param is - input stream to convert
   * @param bRepeatable - should we retrieve the content in such a way that it can be repeated? If
   *     true and the stream doesn't support repeating this operation that the content will not be
   *     touched
   * @return String - string value corresponding to the content of the input stream
   * @throws IOException - an error has occurred
   */
  public static String convertStreamToString(InputStream is, boolean bRepeatable)
      throws IOException {
    String strReturn = "";
    final int iReadLimit = 64 * 1024;

    if (is != null) {
      if ((!bRepeatable) || (is.markSupported())) {
        try {
          if ((bRepeatable) && (is.markSupported())) {
            is.mark(iReadLimit);
          }
          strReturn = new java.util.Scanner(is).useDelimiter("\\A").next();
        } catch (java.util.NoSuchElementException e) {
          strReturn = "";
        } finally {
          if ((bRepeatable) && (is.markSupported())) {
            is.reset();
          }
        }
      } else {
        strReturn = "<Cannot access input stream of the request in repeatable way>";
      }
    }

    return strReturn;
  }
  public Charset detect(InputStream input, Metadata metadata) throws IOException {
    if (input == null) {
      return null;
    }

    input.mark(LOOKAHEAD);
    try {
      UniversalEncodingListener listener = new UniversalEncodingListener(metadata);

      byte[] b = new byte[BUFSIZE];
      int n = 0;
      int m = input.read(b);
      while (m != -1 && n < LOOKAHEAD && !listener.isDone()) {
        n += m;
        listener.handleData(b, 0, m);
        m = input.read(b, 0, Math.min(b.length, LOOKAHEAD - n));
      }

      return listener.dataEnd();
    } catch (LinkageError e) {
      return null; // juniversalchardet is not available
    } finally {
      input.reset();
    }
  }
Esempio n. 16
1
  /**
   * Returns true if the connection is functional. This uses a shameful hack to peek a byte from the
   * socket.
   */
  boolean isStale() throws IOException {
    if (!isEligibleForRecycling()) {
      return true;
    }

    InputStream in = getInputStream();
    if (in.available() > 0) {
      return false;
    }

    Socket socket = getSocket();
    int soTimeout = socket.getSoTimeout();
    try {
      socket.setSoTimeout(1);
      in.mark(1);
      int byteRead = in.read();
      if (byteRead != -1) {
        in.reset();
        return false;
      }
      return true; // the socket is reporting all data read; it's stale
    } catch (SocketTimeoutException e) {
      return false; // the connection is not stale; hooray
    } catch (IOException e) {
      return true; // the connection is stale, the read or soTimeout failed.
    } finally {
      socket.setSoTimeout(soTimeout);
    }
  }
Esempio n. 17
1
  public void unpack(ISOComponent c, InputStream in) throws IOException, ISOException {

    if (!(c instanceof ISOField))
      throw new ISOException(c.getClass().getName() + " is not an ISOField");

    boolean endFound = false;
    if (in.markSupported()) {
      in.mark(getMaxPackedLength());
    }
    ByteBuffer buf = ByteBuffer.allocate(getMaxPackedLength());

    for (int i = 0; i < getMaxPackedLength() && in.available() > 0; i++) {
      byte dataByte = (byte) in.read();
      if (dataByte == terminator) {
        endFound = true;
        break;
      } else {
        buf.put(dataByte);
      }
    }
    if (endFound) {
      byte[] data = byteBufferToBytes(buf);
      c.setValue(data);
    } else {
      if (in.markSupported()) {
        in.reset();
      }
      throw new ISOException("Terminating Backslash does not exist");
    }
  }
  private static String determineEncoding(InputStream in) throws IOException {
    String encoding = "UTF-8";

    in.mark(4);
    byte[] check = new byte[4];
    int size = in.read(check);
    if (size == 2) {
      if (((check[0] & 0xFF) == 0x00 && (check[1] & 0xFF) != 0x00)
          || ((check[0] & 0xFF) == 0xFE && (check[1] & 0xFF) == 0xFF)) {
        encoding = "UTF-16BE";
      } else if (((check[0] & 0xFF) != 0x00 && (check[1] & 0xFF) == 0x00)
          || ((check[0] & 0xFF) == 0xFF && (check[1] & 0xFF) == 0xFE)) {
        encoding = "UTF-16LE";
      }
    } else if (size == 4) {
      if (((check[0] & 0xFF) == 0x00 && (check[1] & 0xFF) == 0x00)) {
        encoding = "UTF-32BE";
      } else if (((check[2] & 0xFF) == 0x00 && (check[3] & 0xFF) == 0x00)) {
        encoding = "UTF-32LE";
      } else if (((check[0] & 0xFF) == 0x00 && (check[1] & 0xFF) != 0x00)
          || ((check[0] & 0xFF) == 0xFE && (check[1] & 0xFF) == 0xFF)) {
        encoding = "UTF-16BE";
      } else if (((check[0] & 0xFF) != 0x00 && (check[1] & 0xFF) == 0x00)
          || ((check[0] & 0xFF) == 0xFF && (check[1] & 0xFF) == 0xFE)) {
        encoding = "UTF-16LE";
      }
    }
    in.reset();

    return encoding;
  }
Esempio n. 19
1
  protected ImageContainer doInBackground(Void... params) {
    InputStream inputStreamWrapper = new BufferedInputStream(inputStream);
    try {
      inputStreamWrapper.mark(inputStreamWrapper.available());
      BitmapFactory.Options options = new BitmapFactory.Options();
      options.inJustDecodeBounds = true;
      BitmapFactory.decodeStream(inputStreamWrapper, null, options);

      if (options.outHeight != -1 && options.outWidth != 1) {
        options.inSampleSize = ImageHandler.calculateInSampleSize(options, this.width, this.height);
        inputStreamWrapper.reset();
        options.inJustDecodeBounds = false;
        Bitmap bitmap = BitmapFactory.decodeStream(inputStreamWrapper, null, options);

        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);

        return new ImageContainer(ImageStatusCode.FILE_ENCODED, bitmap, stream.toByteArray());

      } else {
        return new ImageContainer(ImageStatusCode.NOT_AN_IMAGE, null, null);
      }
    } catch (IOException e) {
      e.printStackTrace();
      return new ImageContainer(ImageStatusCode.FILE_NOT_FOUND, null, null);
    }
  }
Esempio n. 20
1
  public static File createTestFile(long largerThanMB) throws IOException {
    File outputFile = new File("target/test/csv/perftest.csv");
    if (outputFile.exists()) {
      return outputFile;
    }
    File toCopy = new File("../parquet-testdata/tpch/customer.csv");
    FileUtils.copyFile(
        new File("../parquet-testdata/tpch/customer.schema"),
        new File("target/test/csv/perftest.schema"));

    OutputStream output = null;
    InputStream input = null;

    try {
      output = new BufferedOutputStream(new FileOutputStream(outputFile, true));
      input = new BufferedInputStream(new FileInputStream(toCopy));
      input.mark(Integer.MAX_VALUE);
      while (outputFile.length() <= largerThanMB * 1024 * 1024) {
        // appendFile(output, toCopy);
        IOUtils.copy(input, output);
        input.reset();
      }
    } finally {
      closeQuietly(input);
      closeQuietly(output);
    }

    return outputFile;
  }
Esempio n. 21
1
 public static boolean isID3v2StartPosition(InputStream input) throws IOException {
   input.mark(3);
   try {
     return input.read() == 'I' && input.read() == 'D' && input.read() == '3';
   } finally {
     input.reset();
   }
 }
Esempio n. 22
0
 @Override
 public void mark(int readlimit) {
   tryEnsureOpen();
   if (is != null) {
     is.mark(readlimit);
   }
 }
  /**
   * Constructs a new repeatable cipher input stream using the specified InputStream as the source
   * data, and the CipherFactory for building Cipher objects.
   *
   * @param input The original, unencrypted data stream. This stream should be markable/resetable in
   *     order for this class to work correctly.
   * @param cipherFactory The factory used for creating identical cipher objects when this stream is
   *     reset and a new CipherInputStream is needed.
   */
  public RepeatableCipherInputStream(InputStream input, CipherFactory cipherFactory) {
    super(createCipherInputStream(input, cipherFactory));
    this.unencryptedDataStream = input;
    this.cipherFactory = cipherFactory;

    // Mark the beginning of the data stream so we can reset back to it
    unencryptedDataStream.mark(-1);
  }
Esempio n. 24
0
  public static boolean isCRAMFile(final InputStream stream) throws IOException {
    stream.mark(4);
    final int buffSize = CramHeader.MAGIC.length;
    final byte[] buffer = new byte[buffSize];
    readBytes(stream, buffer, 0, buffSize);
    stream.reset();

    return Arrays.equals(buffer, CramHeader.MAGIC);
  }
Esempio n. 25
0
 public X509Credential(InputStream certInputStream, InputStream keyInputStream)
     throws CredentialException {
   if (certInputStream.markSupported()) {
     certInputStream.mark(BUFFER_SIZE);
   }
   loadKey(keyInputStream);
   loadCertificate(certInputStream);
   validateCredential();
 }
Esempio n. 26
0
 private String readLine(final byte[] hdrbuf) throws IOException {
   bin.mark(hdrbuf.length);
   final int cnt = bin.read(hdrbuf);
   int lf = 0;
   while (lf < cnt && hdrbuf[lf] != '\n') lf++;
   bin.reset();
   bin.skip(lf);
   if (lf < cnt && hdrbuf[lf] == '\n') bin.skip(1);
   return RawParseUtils.decode(Constants.CHARSET, hdrbuf, 0, lf);
 }
Esempio n. 27
0
 @Override
 public Long get(InputStream is) throws IOException {
   is.mark(this.offset + SIZE);
   is.skip(this.offset);
   byte bytes[] = new byte[SIZE];
   int count = is.read(bytes);
   is.reset();
   if (count != 0) throw new EOFException();
   BigInteger bigInt = new BigInteger(bytes);
   return bigInt.longValue();
 }
 /** Return the AudioFileFormat from the given InputStream. */
 public AudioFileFormat getAudioFileFormat(InputStream inputStream)
     throws UnsupportedAudioFileException, IOException {
   if (TDebug.TraceAudioFileReader) TDebug.out("getAudioFileFormat(InputStream inputStream)");
   try {
     if (!inputStream.markSupported()) inputStream = new BufferedInputStream(inputStream);
     inputStream.mark(MARK_LIMIT);
     return getAudioFileFormat(inputStream, AudioSystem.NOT_SPECIFIED, AudioSystem.NOT_SPECIFIED);
   } finally {
     inputStream.reset();
   }
 }
Esempio n. 29
0
  public MediaType detect(InputStream input, Metadata metadata) throws IOException {
    // Check if we have access to the document
    if (input == null) {
      return MediaType.OCTET_STREAM;
    }

    // If this is a TikaInputStream wrapping an already
    // parsed NPOIFileSystem/DirectoryNode, just get the
    // names from the root:
    TikaInputStream tis = TikaInputStream.cast(input);
    Set<String> names = null;
    if (tis != null) {
      Object container = tis.getOpenContainer();
      if (container instanceof NPOIFSFileSystem) {
        names = getTopLevelNames(((NPOIFSFileSystem) container).getRoot());
      } else if (container instanceof DirectoryNode) {
        names = getTopLevelNames((DirectoryNode) container);
      }
    }

    if (names == null) {
      // Check if the document starts with the OLE header
      input.mark(8);
      try {
        if (input.read() != 0xd0
            || input.read() != 0xcf
            || input.read() != 0x11
            || input.read() != 0xe0
            || input.read() != 0xa1
            || input.read() != 0xb1
            || input.read() != 0x1a
            || input.read() != 0xe1) {
          return MediaType.OCTET_STREAM;
        }
      } finally {
        input.reset();
      }
    }

    // We can only detect the exact type when given a TikaInputStream
    if (names == null && tis != null) {
      // Look for known top level entry names to detect the document type
      names = getTopLevelNames(tis);
    }

    // Detect based on the names (as available)
    if (tis != null
        && tis.getOpenContainer() != null
        && tis.getOpenContainer() instanceof NPOIFSFileSystem) {
      return detect(names, ((NPOIFSFileSystem) tis.getOpenContainer()).getRoot());
    } else {
      return detect(names, null);
    }
  }
Esempio n. 30
0
  @Override
  public void addFile(
      long companyId,
      long repositoryId,
      String fileName,
      boolean validateFileExtension,
      InputStream is)
      throws PortalException {

    if (is instanceof ByteArrayFileInputStream) {
      ByteArrayFileInputStream byteArrayFileInputStream = (ByteArrayFileInputStream) is;

      File file = byteArrayFileInputStream.getFile();

      addFile(companyId, repositoryId, fileName, validateFileExtension, file);

      return;
    }

    validate(fileName, validateFileExtension);

    if (!PropsValues.DL_STORE_ANTIVIRUS_ENABLED || !AntivirusScannerUtil.isActive()) {

      store.addFile(companyId, repositoryId, fileName, is);
    } else {
      File tempFile = null;

      try {
        if (is.markSupported()) {
          is.mark(is.available() + 1);

          AntivirusScannerUtil.scan(is);

          is.reset();

          store.addFile(companyId, repositoryId, fileName, is);
        } else {
          tempFile = FileUtil.createTempFile();

          FileUtil.write(tempFile, is);

          AntivirusScannerUtil.scan(tempFile);

          store.addFile(companyId, repositoryId, fileName, tempFile);
        }
      } catch (IOException ioe) {
        throw new SystemException("Unable to scan file " + fileName, ioe);
      } finally {
        if (tempFile != null) {
          tempFile.delete();
        }
      }
    }
  }