commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From x..@apache.org
Subject [4/7] commons-crypto git commit: CRYPTO-37: Change all the 2 spaces indent to 4 to comply Commons code style
Date Wed, 04 May 2016 03:46:00 GMT
http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java b/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java
index 255e57e..a962215 100644
--- a/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java
+++ b/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java
@@ -40,324 +40,326 @@ import org.apache.commons.crypto.utils.Utils;
 import static org.apache.commons.crypto.cipher.CipherTransformation.AES_CTR_NOPADDING;
 
 /**
- * PositionedCryptoInputStream provides the capability to decrypt the stream starting
- * at random position as well as provides the foundation for positioned read for
- * decrypting. This needs a stream cipher mode such as AES CTR mode.
+ * PositionedCryptoInputStream provides the capability to decrypt the stream
+ * starting at random position as well as provides the foundation for positioned
+ * read for decrypting. This needs a stream cipher mode such as AES CTR mode.
  */
 public class PositionedCryptoInputStream extends CTRCryptoInputStream {
 
-  /**
-   * DirectBuffer pool
-   */
-  private final Queue<ByteBuffer> bufferPool = new
-      ConcurrentLinkedQueue<ByteBuffer>();
-
-  /**
-   * CryptoCipher pool
-   */
-  private final Queue<CipherState> cipherPool = new
-      ConcurrentLinkedQueue<CipherState>();
-
-  /**
-   * Constructs a {@link PositionedCryptoInputStream}.
-   *
-   * @param props The <code>Properties</code> class represents a set of
-   *              properties.
-   * @param in the input data.
-   * @param key crypto key for the cipher.
-   * @param iv Initialization vector for the cipher.
-   * @param streamOffset the start offset in the data.
-   * @throws IOException if an I/O error occurs.
-   */
-  public PositionedCryptoInputStream(Properties props, Input in, byte[] key,
-                                     byte[] iv, long streamOffset) throws IOException {
-    this(in, Utils.getCipherInstance(AES_CTR_NOPADDING, props),
-        Utils.getBufferSize(props), key, iv, streamOffset);
-  }
-
-  /**
-   * Constructs a {@link PositionedCryptoInputStream}.
-   *
-   * @param input the input data.
-   * @param cipher the CryptoCipher instance.
-   * @param bufferSize the bufferSize.
-   * @param key crypto key for the cipher.
-   * @param iv Initialization vector for the cipher.
-   * @param streamOffset the start offset in the data.
-   * @throws IOException if an I/O error occurs.
-   */
-  public PositionedCryptoInputStream(Input input, CryptoCipher cipher, int bufferSize,
-                                     byte[] key, byte[] iv, long streamOffset) throws IOException {
-    super(input, cipher, bufferSize, key, iv, streamOffset);
-  }
-
-  /**
-   * Reads up to the specified number of bytes from a given position
-   * within a stream and return the number of bytes read. This does not
-   * change the current offset of the stream, and is thread-safe.
-   *
-   * @param buffer the buffer into which the data is read.
-   * @param length the maximum number of bytes to read.
-   * @param offset the start offset in the data.
-   * @param position the offset from the start of the stream.
-   * @throws IOException if an I/O error occurs.
-   * @return int the total number of decrypted data bytes read into the buffer.
-   */
-  public int read(long position, byte[] buffer, int offset, int length)
-      throws IOException {
-    checkStream();
-    final int n = input.read(position, buffer, offset, length);
-    if (n > 0) {
-      // This operation does not change the current offset of the file
-      decrypt(position, buffer, offset, n);
+    /**
+     * DirectBuffer pool
+     */
+    private final Queue<ByteBuffer> bufferPool = new ConcurrentLinkedQueue<ByteBuffer>();
+
+    /**
+     * CryptoCipher pool
+     */
+    private final Queue<CipherState> cipherPool = new ConcurrentLinkedQueue<CipherState>();
+
+    /**
+     * Constructs a {@link PositionedCryptoInputStream}.
+     *
+     * @param props The <code>Properties</code> class represents a set of
+     *        properties.
+     * @param in the input data.
+     * @param key crypto key for the cipher.
+     * @param iv Initialization vector for the cipher.
+     * @param streamOffset the start offset in the data.
+     * @throws IOException if an I/O error occurs.
+     */
+    public PositionedCryptoInputStream(Properties props, Input in, byte[] key,
+            byte[] iv, long streamOffset) throws IOException {
+        this(in, Utils.getCipherInstance(AES_CTR_NOPADDING, props), Utils
+                .getBufferSize(props), key, iv, streamOffset);
     }
-    return n;
-  }
-
-  /**
-   * Reads the specified number of bytes from a given position within a stream.
-   * This does not change the current offset of the stream and is thread-safe.
-   *
-   * @param buffer the buffer into which the data is read.
-   * @param length the maximum number of bytes to read.
-   * @param offset the start offset in the data.
-   * @param position the offset from the start of the stream.
-   * @throws IOException if an I/O error occurs.
-   */
-  public void readFully(long position, byte[] buffer, int offset, int length)
-      throws IOException {
-    checkStream();
-    IOUtils.readFully(input, position, buffer, offset, length);
-    if (length > 0) {
-      // This operation does not change the current offset of the file
-      decrypt(position, buffer, offset, length);
+
+    /**
+     * Constructs a {@link PositionedCryptoInputStream}.
+     *
+     * @param input the input data.
+     * @param cipher the CryptoCipher instance.
+     * @param bufferSize the bufferSize.
+     * @param key crypto key for the cipher.
+     * @param iv Initialization vector for the cipher.
+     * @param streamOffset the start offset in the data.
+     * @throws IOException if an I/O error occurs.
+     */
+    public PositionedCryptoInputStream(Input input, CryptoCipher cipher,
+            int bufferSize, byte[] key, byte[] iv, long streamOffset)
+            throws IOException {
+        super(input, cipher, bufferSize, key, iv, streamOffset);
     }
-  }
-
-  /**
-   * Reads the specified number of bytes from a given position within a stream.
-   * This does not change the current offset of the stream and is thread-safe.
-   *
-   * @param position the offset from the start of the stream.
-   * @param buffer the buffer into which the data is read.
-   * @throws IOException if an I/O error occurs.
-   */
-  public void readFully(long position, byte[] buffer) throws IOException {
-    readFully(position, buffer, 0, buffer.length);
-  }
-
-  /**
-   * Decrypts length bytes in buffer starting at offset. Output is also put
-   * into buffer starting at offset. It is thread-safe.
-   *
-   * @param buffer the buffer into which the data is read.
-   * @param offset the start offset in the data.
-   * @param position the offset from the start of the stream.
-   * @param length the maximum number of bytes to read.
-   * @throws IOException if an I/O error occurs.
-   */
-  protected void decrypt(long position, byte[] buffer, int offset, int length)
-      throws IOException {
-    ByteBuffer inBuffer = getBuffer();
-    ByteBuffer outBuffer = getBuffer();
-    CipherState state = null;
-    try {
-      state = getCipherState();
-      byte[] iv = getInitIV().clone();
-      resetCipher(state, position, iv);
-      byte padding = getPadding(position);
-      inBuffer.position(padding); // Set proper position for input data.
-
-      int n = 0;
-      while (n < length) {
-        int toDecrypt = Math.min(length - n, inBuffer.remaining());
-        inBuffer.put(buffer, offset + n, toDecrypt);
-
-        // Do decryption
-        decrypt(state, inBuffer, outBuffer, padding);
-
-        outBuffer.get(buffer, offset + n, toDecrypt);
-        n += toDecrypt;
-        padding = postDecryption(state, inBuffer, position + n, iv);
-      }
-    } finally {
-      returnBuffer(inBuffer);
-      returnBuffer(outBuffer);
-      returnCipherState(state);
+
+    /**
+     * Reads up to the specified number of bytes from a given position within a
+     * stream and return the number of bytes read. This does not change the
+     * current offset of the stream, and is thread-safe.
+     *
+     * @param buffer the buffer into which the data is read.
+     * @param length the maximum number of bytes to read.
+     * @param offset the start offset in the data.
+     * @param position the offset from the start of the stream.
+     * @throws IOException if an I/O error occurs.
+     * @return int the total number of decrypted data bytes read into the
+     *         buffer.
+     */
+    public int read(long position, byte[] buffer, int offset, int length)
+            throws IOException {
+        checkStream();
+        final int n = input.read(position, buffer, offset, length);
+        if (n > 0) {
+            // This operation does not change the current offset of the file
+            decrypt(position, buffer, offset, n);
+        }
+        return n;
     }
-  }
-
-  /**
-   * Does the decryption using inBuffer as input and outBuffer as output.
-   * Upon return, inBuffer is cleared; the decrypted data starts at
-   * outBuffer.position() and ends at outBuffer.limit()
-   */
-  private void decrypt(CipherState state, ByteBuffer inBuffer,
-      ByteBuffer outBuffer, byte padding) throws IOException {
-    Utils.checkState(inBuffer.position() >= padding);
-    if(inBuffer.position() == padding) {
-      // There is no real data in inBuffer.
-      return;
+
+    /**
+     * Reads the specified number of bytes from a given position within a
+     * stream. This does not change the current offset of the stream and is
+     * thread-safe.
+     *
+     * @param buffer the buffer into which the data is read.
+     * @param length the maximum number of bytes to read.
+     * @param offset the start offset in the data.
+     * @param position the offset from the start of the stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    public void readFully(long position, byte[] buffer, int offset, int length)
+            throws IOException {
+        checkStream();
+        IOUtils.readFully(input, position, buffer, offset, length);
+        if (length > 0) {
+            // This operation does not change the current offset of the file
+            decrypt(position, buffer, offset, length);
+        }
     }
-    inBuffer.flip();
-    outBuffer.clear();
-    decryptBuffer(state, inBuffer, outBuffer);
-    inBuffer.clear();
-    outBuffer.flip();
-    if (padding > 0) {
-      /*
-       * The plain text and cipher text have a 1:1 mapping, they start at the
-       * same position.
-       */
-      outBuffer.position(padding);
+
+    /**
+     * Reads the specified number of bytes from a given position within a
+     * stream. This does not change the current offset of the stream and is
+     * thread-safe.
+     *
+     * @param position the offset from the start of the stream.
+     * @param buffer the buffer into which the data is read.
+     * @throws IOException if an I/O error occurs.
+     */
+    public void readFully(long position, byte[] buffer) throws IOException {
+        readFully(position, buffer, 0, buffer.length);
     }
-  }
-
-  private void decryptBuffer(CipherState state, ByteBuffer inBuffer, ByteBuffer outBuffer)
-      throws IOException {
-    int inputSize = inBuffer.remaining();
-    try {
-      int n = state.getCipher().update(inBuffer, outBuffer);
-      if (n < inputSize) {
-        /**
-         * Typically code will not get here. CryptoCipher#update will consume all
-         * input data and put result in outBuffer.
-         * CryptoCipher#doFinal will reset the cipher context.
-         */
-        state.getCipher().doFinal(inBuffer, outBuffer);
-        state.reset(true);
-      }
-    } catch (ShortBufferException e) {
-      throw new IOException(e);
-    } catch (IllegalBlockSizeException e) {
-      throw new IOException(e);
-    } catch (BadPaddingException e) {
-      throw new IOException(e);
+
+    /**
+     * Decrypts length bytes in buffer starting at offset. Output is also put
+     * into buffer starting at offset. It is thread-safe.
+     *
+     * @param buffer the buffer into which the data is read.
+     * @param offset the start offset in the data.
+     * @param position the offset from the start of the stream.
+     * @param length the maximum number of bytes to read.
+     * @throws IOException if an I/O error occurs.
+     */
+    protected void decrypt(long position, byte[] buffer, int offset, int length)
+            throws IOException {
+        ByteBuffer inBuffer = getBuffer();
+        ByteBuffer outBuffer = getBuffer();
+        CipherState state = null;
+        try {
+            state = getCipherState();
+            byte[] iv = getInitIV().clone();
+            resetCipher(state, position, iv);
+            byte padding = getPadding(position);
+            inBuffer.position(padding); // Set proper position for input data.
+
+            int n = 0;
+            while (n < length) {
+                int toDecrypt = Math.min(length - n, inBuffer.remaining());
+                inBuffer.put(buffer, offset + n, toDecrypt);
+
+                // Do decryption
+                decrypt(state, inBuffer, outBuffer, padding);
+
+                outBuffer.get(buffer, offset + n, toDecrypt);
+                n += toDecrypt;
+                padding = postDecryption(state, inBuffer, position + n, iv);
+            }
+        } finally {
+            returnBuffer(inBuffer);
+            returnBuffer(outBuffer);
+            returnCipherState(state);
+        }
     }
-  }
-
-  /**
-   * This method is executed immediately after decryption. Check whether
-   * cipher should be updated and recalculate padding if needed.
-   */
-  private byte postDecryption(CipherState state, ByteBuffer inBuffer,
-      long position, byte[] iv) throws IOException {
-    byte padding = 0;
-    if (state.isReset()) {
-      /*
-       * This code is generally not executed since the cipher usually
-       * maintains cipher context (e.g. the counter) internally. However,
-       * some implementations can't maintain context so a re-init is necessary
-       * after each decryption call.
-       */
-      resetCipher(state, position, iv);
-      padding = getPadding(position);
-      inBuffer.position(padding);
+
+    /**
+     * Does the decryption using inBuffer as input and outBuffer as output. Upon
+     * return, inBuffer is cleared; the decrypted data starts at
+     * outBuffer.position() and ends at outBuffer.limit()
+     */
+    private void decrypt(CipherState state, ByteBuffer inBuffer,
+            ByteBuffer outBuffer, byte padding) throws IOException {
+        Utils.checkState(inBuffer.position() >= padding);
+        if (inBuffer.position() == padding) {
+            // There is no real data in inBuffer.
+            return;
+        }
+        inBuffer.flip();
+        outBuffer.clear();
+        decryptBuffer(state, inBuffer, outBuffer);
+        inBuffer.clear();
+        outBuffer.flip();
+        if (padding > 0) {
+            /*
+             * The plain text and cipher text have a 1:1 mapping, they start at
+             * the same position.
+             */
+            outBuffer.position(padding);
+        }
     }
-    return padding;
-  }
-
-  /** Calculate the counter and iv, reset the cipher. */
-  private void resetCipher(CipherState state, long position, byte[] iv)
-      throws IOException {
-    final long counter = getCounter(position);
-    Utils.calculateIV(getInitIV(), counter, iv);
-    try {
-      state.getCipher().init(CryptoCipher.DECRYPT_MODE, key, new IvParameterSpec(iv));
-    } catch (InvalidKeyException e) {
-      throw new IOException(e);
-    } catch (InvalidAlgorithmParameterException e) {
-      throw new IOException(e);
+
+    private void decryptBuffer(CipherState state, ByteBuffer inBuffer,
+            ByteBuffer outBuffer) throws IOException {
+        int inputSize = inBuffer.remaining();
+        try {
+            int n = state.getCipher().update(inBuffer, outBuffer);
+            if (n < inputSize) {
+                /**
+                 * Typically code will not get here. CryptoCipher#update will
+                 * consume all input data and put result in outBuffer.
+                 * CryptoCipher#doFinal will reset the cipher context.
+                 */
+                state.getCipher().doFinal(inBuffer, outBuffer);
+                state.reset(true);
+            }
+        } catch (ShortBufferException e) {
+            throw new IOException(e);
+        } catch (IllegalBlockSizeException e) {
+            throw new IOException(e);
+        } catch (BadPaddingException e) {
+            throw new IOException(e);
+        }
     }
-    state.reset(false);
-  }
-
-  /** Get CryptoCipher from pool */
-  private CipherState getCipherState() throws IOException {
-    CipherState state = cipherPool.poll();
-    if (state == null) {
-      CryptoCipher cipher;
-      try {
-        cipher = CryptoCipherFactory.getInstance(getCipher().getTransformation(),
-            getCipher().getProperties());
-      } catch (GeneralSecurityException e) {
-        throw new IOException(e);
-      }
-      state = new CipherState(cipher);
+
+    /**
+     * This method is executed immediately after decryption. Check whether
+     * cipher should be updated and recalculate padding if needed.
+     */
+    private byte postDecryption(CipherState state, ByteBuffer inBuffer,
+            long position, byte[] iv) throws IOException {
+        byte padding = 0;
+        if (state.isReset()) {
+            /*
+             * This code is generally not executed since the cipher usually
+             * maintains cipher context (e.g. the counter) internally. However,
+             * some implementations can't maintain context so a re-init is
+             * necessary after each decryption call.
+             */
+            resetCipher(state, position, iv);
+            padding = getPadding(position);
+            inBuffer.position(padding);
+        }
+        return padding;
     }
 
-    return state;
-  }
+    /** Calculate the counter and iv, reset the cipher. */
+    private void resetCipher(CipherState state, long position, byte[] iv)
+            throws IOException {
+        final long counter = getCounter(position);
+        Utils.calculateIV(getInitIV(), counter, iv);
+        try {
+            state.getCipher().init(CryptoCipher.DECRYPT_MODE, key,
+                    new IvParameterSpec(iv));
+        } catch (InvalidKeyException e) {
+            throw new IOException(e);
+        } catch (InvalidAlgorithmParameterException e) {
+            throw new IOException(e);
+        }
+        state.reset(false);
+    }
 
-  /** Return CryptoCipher to pool */
-  private void returnCipherState(CipherState state) {
-    if (state != null) {
-      cipherPool.add(state);
+    /** Get CryptoCipher from pool */
+    private CipherState getCipherState() throws IOException {
+        CipherState state = cipherPool.poll();
+        if (state == null) {
+            CryptoCipher cipher;
+            try {
+                cipher = CryptoCipherFactory.getInstance(getCipher()
+                        .getTransformation(), getCipher().getProperties());
+            } catch (GeneralSecurityException e) {
+                throw new IOException(e);
+            }
+            state = new CipherState(cipher);
+        }
+
+        return state;
     }
-  }
 
-  /** Get direct buffer from pool */
-  private ByteBuffer getBuffer() {
-    ByteBuffer buffer = bufferPool.poll();
-    if (buffer == null) {
-      buffer = ByteBuffer.allocateDirect(getBufferSize());
+    /** Return CryptoCipher to pool */
+    private void returnCipherState(CipherState state) {
+        if (state != null) {
+            cipherPool.add(state);
+        }
     }
 
-    return buffer;
-  }
+    /** Get direct buffer from pool */
+    private ByteBuffer getBuffer() {
+        ByteBuffer buffer = bufferPool.poll();
+        if (buffer == null) {
+            buffer = ByteBuffer.allocateDirect(getBufferSize());
+        }
 
-  /** Return direct buffer to pool */
-  private void returnBuffer(ByteBuffer buf) {
-    if (buf != null) {
-      buf.clear();
-      bufferPool.add(buf);
+        return buffer;
     }
-  }
-
-  /**
-   * Overrides the {@link CryptoInputStream#close()}.
-   * Closes this input stream and releases any system resources associated
-   * with the stream.
-   *
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void close() throws IOException {
-    if (!isOpen()) {
-      return;
+
+    /** Return direct buffer to pool */
+    private void returnBuffer(ByteBuffer buf) {
+        if (buf != null) {
+            buf.clear();
+            bufferPool.add(buf);
+        }
     }
 
-    cleanBufferPool();
-    super.close();
-  }
+    /**
+     * Overrides the {@link CryptoInputStream#close()}. Closes this input stream
+     * and releases any system resources associated with the stream.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void close() throws IOException {
+        if (!isOpen()) {
+            return;
+        }
+
+        cleanBufferPool();
+        super.close();
+    }
 
-  /** Clean direct buffer pool */
-  private void cleanBufferPool() {
-    ByteBuffer buf;
-    while ((buf = bufferPool.poll()) != null) {
-      Utils.freeDirectBuffer(buf);
+    /** Clean direct buffer pool */
+    private void cleanBufferPool() {
+        ByteBuffer buf;
+        while ((buf = bufferPool.poll()) != null) {
+            Utils.freeDirectBuffer(buf);
+        }
     }
-  }
 
-  private class CipherState {
-    private CryptoCipher cipher;
-    private boolean reset;
+    private class CipherState {
+        private CryptoCipher cipher;
+        private boolean reset;
 
-    public CipherState(CryptoCipher cipher) {
-      this.cipher = cipher;
-      this.reset = false;
-    }
+        public CipherState(CryptoCipher cipher) {
+            this.cipher = cipher;
+            this.reset = false;
+        }
 
-    public CryptoCipher getCipher() {
-      return cipher;
-    }
+        public CryptoCipher getCipher() {
+            return cipher;
+        }
 
-    public boolean isReset() {
-      return reset;
-    }
+        public boolean isReset() {
+            return reset;
+        }
 
-    public void reset(boolean reset) {
-      this.reset = reset;
+        public void reset(boolean reset) {
+            this.reset = reset;
+        }
     }
-  }
 }

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java b/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java
index cdf13e6..dbcba57 100644
--- a/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java
+++ b/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java
@@ -23,143 +23,148 @@ import java.nio.channels.ReadableByteChannel;
 
 /**
  * The ChannelInput class takes a <code>ReadableByteChannel</code> object and
- * wraps it as <code>Input</code> object acceptable by <code>CryptoInputStream</code>.
+ * wraps it as <code>Input</code> object acceptable by
+ * <code>CryptoInputStream</code>.
  */
 public class ChannelInput implements Input {
-  private static final int SKIP_BUFFER_SIZE = 2048;
+    private static final int SKIP_BUFFER_SIZE = 2048;
 
-  private ByteBuffer buf;
-  private final ReadableByteChannel channel;
+    private ByteBuffer buf;
+    private final ReadableByteChannel channel;
 
-  /**
-   * Constructs the {@link org.apache.commons.crypto.stream.input.ChannelInput}.
-   *
-   * @param channel the ReadableByteChannel object.
-   */
-  public ChannelInput(
-      ReadableByteChannel channel) {
-    this.channel = channel;
-  }
+    /**
+     * Constructs the
+     * {@link org.apache.commons.crypto.stream.input.ChannelInput}.
+     *
+     * @param channel the ReadableByteChannel object.
+     */
+    public ChannelInput(ReadableByteChannel channel) {
+        this.channel = channel;
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#read(ByteBuffer)}.
-   * Reads a sequence of bytes from input into the given buffer.
-   *
-   * @param  dst The buffer into which bytes are to be transferred.
-   * @return the total number of bytes read into the buffer, or
-   *          <code>-1</code> if there is no more data because the end of
-   *          the stream has been reached.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int read(ByteBuffer dst) throws IOException {
-    return channel.read(dst);
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#read(ByteBuffer)}.
+     * Reads a sequence of bytes from input into the given buffer.
+     *
+     * @param dst The buffer into which bytes are to be transferred.
+     * @return the total number of bytes read into the buffer, or
+     *         <code>-1</code> if there is no more data because the end of the
+     *         stream has been reached.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int read(ByteBuffer dst) throws IOException {
+        return channel.read(dst);
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#skip(long)}.
-   * Skips over and discards <code>n</code> bytes of data from this input
-   * stream.
-   *
-   * @param n the number of bytes to be skipped.
-   * @return the actual number of bytes skipped.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public long skip(long n) throws IOException {
-    long remaining = n;
-    int nr;
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#skip(long)}. Skips
+     * over and discards <code>n</code> bytes of data from this input stream.
+     *
+     * @param n the number of bytes to be skipped.
+     * @return the actual number of bytes skipped.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public long skip(long n) throws IOException {
+        long remaining = n;
+        int nr;
 
-    if (n <= 0) {
-      return 0;
-    }
+        if (n <= 0) {
+            return 0;
+        }
 
-    int size = (int)Math.min(SKIP_BUFFER_SIZE, remaining);
-    ByteBuffer skipBuffer = getSkipBuf();
-    while (remaining > 0) {
-      skipBuffer.clear();
-      skipBuffer.limit((int)Math.min(size, remaining));
-      nr = read(skipBuffer);
-      if (nr < 0) {
-        break;
-      }
-      remaining -= nr;
-    }
+        int size = (int) Math.min(SKIP_BUFFER_SIZE, remaining);
+        ByteBuffer skipBuffer = getSkipBuf();
+        while (remaining > 0) {
+            skipBuffer.clear();
+            skipBuffer.limit((int) Math.min(size, remaining));
+            nr = read(skipBuffer);
+            if (nr < 0) {
+                break;
+            }
+            remaining -= nr;
+        }
 
-    return n - remaining;
-  }
+        return n - remaining;
+    }
 
-  /**
-   * Overrides the {@link Input#available()}.
-   * Returns an estimate of the number of bytes that can be read (or
-   * skipped over) from this input stream without blocking by the next
-   * invocation of a method for this input stream. The next invocation
-   * might be the same thread or another thread.  A single read or skip of this
-   * many bytes will not block, but may read or skip fewer bytes.
-   *
-   * @return  an estimate of the number of bytes that can be read (or skipped
-   *          over) from this input stream without blocking or {@code 0} when
-   *          it reaches the end of the input stream.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int available() throws IOException {
-    return 0;
-  }
+    /**
+     * Overrides the {@link Input#available()}. Returns an estimate of the
+     * number of bytes that can be read (or skipped over) from this input stream
+     * without blocking by the next invocation of a method for this input
+     * stream. The next invocation might be the same thread or another thread. A
+     * single read or skip of this many bytes will not block, but may read or
+     * skip fewer bytes.
+     *
+     * @return an estimate of the number of bytes that can be read (or skipped
+     *         over) from this input stream without blocking or {@code 0} when
+     *         it reaches the end of the input stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int available() throws IOException {
+        return 0;
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#read(long, byte[], int, int)}.
-   * Reads up to <code>len</code> bytes of data from the input stream into
-   * an array of bytes.  An attempt is made to read as many as
-   * <code>len</code> bytes, but a smaller number may be read.
-   * The number of bytes actually read is returned as an integer.
-   *
-   * @param position the given position within a stream.
-   * @param buffer the buffer into which the data is read.
-   * @param offset the start offset in array buffer.
-   * @param length the maximum number of bytes to read.
-   * @return the total number of bytes read into the buffer, or
-   *          <code>-1</code> if there is no more data because the end of
-   *          the stream has been reached.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int read(long position, byte[] buffer, int offset, int length)
-      throws IOException {
-    throw new UnsupportedOperationException(
-        "Positioned read is not supported by this implementation");
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#read(long, byte[], int, int)}
+     * . Reads up to <code>len</code> bytes of data from the input stream into
+     * an array of bytes. An attempt is made to read as many as <code>len</code>
+     * bytes, but a smaller number may be read. The number of bytes actually
+     * read is returned as an integer.
+     *
+     * @param position the given position within a stream.
+     * @param buffer the buffer into which the data is read.
+     * @param offset the start offset in array buffer.
+     * @param length the maximum number of bytes to read.
+     * @return the total number of bytes read into the buffer, or
+     *         <code>-1</code> if there is no more data because the end of the
+     *         stream has been reached.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int read(long position, byte[] buffer, int offset, int length)
+            throws IOException {
+        throw new UnsupportedOperationException(
+                "Positioned read is not supported by this implementation");
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#seek(long)}.
-   * Seeks to the given offset from the start of the stream.
-   * The next read() will be from that location.
-   *
-   * @param position the offset from the start of the stream.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void seek(long position) throws IOException {
-    throw new UnsupportedOperationException(
-        "Seek is not supported by this implementation");
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#seek(long)}. Seeks to
+     * the given offset from the start of the stream. The next read() will be
+     * from that location.
+     *
+     * @param position the offset from the start of the stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void seek(long position) throws IOException {
+        throw new UnsupportedOperationException(
+                "Seek is not supported by this implementation");
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#seek(long)}.
-   * Closes this input and releases any system resources associated
-   * with the under layer input.
-   *
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void close() throws IOException {
-    channel.close();
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#seek(long)}. Closes
+     * this input and releases any system resources associated with the under
+     * layer input.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void close() throws IOException {
+        channel.close();
+    }
 
-  private ByteBuffer getSkipBuf() {
-    if (buf == null) {
-      buf = ByteBuffer.allocate(SKIP_BUFFER_SIZE);
+    private ByteBuffer getSkipBuf() {
+        if (buf == null) {
+            buf = ByteBuffer.allocate(SKIP_BUFFER_SIZE);
+        }
+        return buf;
     }
-    return buf;
-  }
 }

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/input/Input.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/input/Input.java b/src/main/java/org/apache/commons/crypto/stream/input/Input.java
index 1657a7c..c8e2f63 100644
--- a/src/main/java/org/apache/commons/crypto/stream/input/Input.java
+++ b/src/main/java/org/apache/commons/crypto/stream/input/Input.java
@@ -21,113 +21,117 @@ import java.io.IOException;
 import java.nio.ByteBuffer;
 
 /**
- * The Input interface abstract the input source of <code>CryptoInputStream</code> so that
- * different implementation of input can be used. The implementation Input interface will usually
- * wraps an input mechanism such as <code>InputStream</code> or <code>ReadableByteChannel</code>.
+ * The Input interface abstract the input source of
+ * <code>CryptoInputStream</code> so that different implementation of input can
+ * be used. The implementation Input interface will usually wraps an input
+ * mechanism such as <code>InputStream</code> or
+ * <code>ReadableByteChannel</code>.
  */
 public interface Input {
-  /**
-   * Reads a sequence of bytes from input into the given buffer.
-   *
-   * <p> An attempt is made to read up to <i>r</i> bytes from the input,
-   * where <i>r</i> is the number of bytes remaining in the buffer, that is,
-   * <tt>dst.remaining()</tt>, at the moment this method is invoked.
-   *
-   * <p> Suppose that a byte sequence of length <i>n</i> is read, where
-   * <tt>0</tt>&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
-   * This byte sequence will be transferred into the buffer so that the first
-   * byte in the sequence is at index <i>p</i> and the last byte is at index
-   * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>,
-   * where <i>p</i> is the buffer's position at the moment this method is
-   * invoked.  Upon return the buffer's position will be equal to
-   * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
-   *
-   * @param  dst
-   *         The buffer into which bytes are to be transferred.
-   * @return the total number of bytes read into the buffer, or
-   *         <code>-1</code> if there is no more data because the end of
-   *         the stream has been reached.
-   * @throws  IOException
-   *          If some other I/O error occurs.
-   */
-  int read(ByteBuffer dst) throws IOException;
+    /**
+     * Reads a sequence of bytes from input into the given buffer.
+     *
+     * <p>
+     * An attempt is made to read up to <i>r</i> bytes from the input, where
+     * <i>r</i> is the number of bytes remaining in the buffer, that is,
+     * <tt>dst.remaining()</tt>, at the moment this method is invoked.
+     *
+     * <p>
+     * Suppose that a byte sequence of length <i>n</i> is read, where <tt>0</tt>
+     * &nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
+     * This byte sequence will be transferred into the buffer so that the first
+     * byte in the sequence is at index <i>p</i> and the last byte is at index
+     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>,
+     * where <i>p</i> is the buffer's position at the moment this method is
+     * invoked. Upon return the buffer's position will be equal to
+     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
+     *
+     * @param dst The buffer into which bytes are to be transferred.
+     * @return the total number of bytes read into the buffer, or
+     *         <code>-1</code> if there is no more data because the end of the
+     *         stream has been reached.
+     * @throws IOException If some other I/O error occurs.
+     */
+    int read(ByteBuffer dst) throws IOException;
 
-  /**
-   * Skips over and discards <code>n</code> bytes of data from this input
-   * The <code>skip</code> method may, for a variety of reasons, end
-   * up skipping over some smaller number of bytes, possibly <code>0</code>.
-   * This may result from any of a number of conditions; reaching end of file
-   * before <code>n</code> bytes have been skipped is only one possibility.
-   * The actual number of bytes skipped is returned.  If <code>n</code> is
-   * negative, no bytes are skipped.
-   *
-   * <p> The <code>skip</code> method of this class creates a
-   * byte array and then repeatedly reads into it until <code>n</code> bytes
-   * have been read or the end of the stream has been reached. Subclasses are
-   * encouraged to provide a more efficient implementation of this method.
-   * For instance, the implementation may depend on the ability to seek.
-   *
-   * @param      n the number of bytes to be skipped.
-   * @return     the actual number of bytes skipped.
-   * @exception  IOException  if the stream does not support seek,
-   *                          or if some other I/O error occurs.
-   */
-  long skip(long n) throws IOException;
+    /**
+     * Skips over and discards <code>n</code> bytes of data from this input The
+     * <code>skip</code> method may, for a variety of reasons, end up skipping
+     * over some smaller number of bytes, possibly <code>0</code>. This may
+     * result from any of a number of conditions; reaching end of file before
+     * <code>n</code> bytes have been skipped is only one possibility. The
+     * actual number of bytes skipped is returned. If <code>n</code> is
+     * negative, no bytes are skipped.
+     *
+     * <p>
+     * The <code>skip</code> method of this class creates a byte array and then
+     * repeatedly reads into it until <code>n</code> bytes have been read or the
+     * end of the stream has been reached. Subclasses are encouraged to provide
+     * a more efficient implementation of this method. For instance, the
+     * implementation may depend on the ability to seek.
+     *
+     * @param n the number of bytes to be skipped.
+     * @return the actual number of bytes skipped.
+     * @exception IOException if the stream does not support seek, or if some
+     *            other I/O error occurs.
+     */
+    long skip(long n) throws IOException;
 
-  /**
-   * Returns an estimate of the number of bytes that can be read (or
-   * skipped over) from this input without blocking by the next
-   * invocation of a method for this input stream. The next invocation
-   * might be the same thread or another thread.  A single read or skip of this
-   * many bytes will not block, but may read or skip fewer bytes.
-   *
-   * <p> It is never correct to use the return value of this method to allocate
-   * a buffer intended to hold all data in this stream.
-   *
-   * @return     an estimate of the number of bytes that can be read (or skipped
-   *             over) from this input stream without blocking or {@code 0} when
-   *             it reaches the end of the input stream.
-   * @exception  IOException if an I/O error occurs.
-   */
-  int available() throws IOException;
+    /**
+     * Returns an estimate of the number of bytes that can be read (or skipped
+     * over) from this input without blocking by the next invocation of a method
+     * for this input stream. The next invocation might be the same thread or
+     * another thread. A single read or skip of this many bytes will not block,
+     * but may read or skip fewer bytes.
+     *
+     * <p>
+     * It is never correct to use the return value of this method to allocate a
+     * buffer intended to hold all data in this stream.
+     *
+     * @return an estimate of the number of bytes that can be read (or skipped
+     *         over) from this input stream without blocking or {@code 0} when
+     *         it reaches the end of the input stream.
+     * @exception IOException if an I/O error occurs.
+     */
+    int available() throws IOException;
 
-  /**
-   * Reads up to the specified number of bytes from a given position within a
-   * stream and return the number of bytes read.
-   * This does not change the current offset of the stream and is thread-safe.
-   *
-   * An implementation may not support positioned read. If the implementation
-   * doesn't support positioned read, it throws UnsupportedOperationException.
-   *
-   * @param position the given position within a stream.
-   * @param buffer the buffer into which the data is read.
-   * @param offset the start offset in array buffer.
-   * @param length the maximum number of bytes to read.
-   * @return the total number of bytes read into the buffer, or
-   *         <code>-1</code> if there is no more data because the end of
-   *         the stream has been reached.
-   * @throws IOException if an I/O error occurs.
-   */
-  int read(long position, byte[] buffer, int offset, int length)
-      throws IOException;
+    /**
+     * Reads up to the specified number of bytes from a given position within a
+     * stream and return the number of bytes read. This does not change the
+     * current offset of the stream and is thread-safe.
+     *
+     * An implementation may not support positioned read. If the implementation
+     * doesn't support positioned read, it throws UnsupportedOperationException.
+     *
+     * @param position the given position within a stream.
+     * @param buffer the buffer into which the data is read.
+     * @param offset the start offset in array buffer.
+     * @param length the maximum number of bytes to read.
+     * @return the total number of bytes read into the buffer, or
+     *         <code>-1</code> if there is no more data because the end of the
+     *         stream has been reached.
+     * @throws IOException if an I/O error occurs.
+     */
+    int read(long position, byte[] buffer, int offset, int length)
+            throws IOException;
 
-  /**
-   * Seeks to the given offset from the start of the stream.
-   * The next read() will be from that location.
-   *
-   * An implementation may not support seek. If the implementation
-   * doesn't support seek, it throws UnsupportedOperationException.
-   *
-   * @param position the offset from the start of the stream.
-   * @throws IOException if an I/O error occurs.
-   */
-  void seek(long position) throws IOException;
+    /**
+     * Seeks to the given offset from the start of the stream. The next read()
+     * will be from that location.
+     *
+     * An implementation may not support seek. If the implementation doesn't
+     * support seek, it throws UnsupportedOperationException.
+     *
+     * @param position the offset from the start of the stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    void seek(long position) throws IOException;
 
-  /**
-   * Closes this input and releases any system resources associated
-   * with the under layer input.
-   *
-   * @exception  IOException  if an I/O error occurs.
-   */
-  void close() throws IOException;
+    /**
+     * Closes this input and releases any system resources associated with the
+     * under layer input.
+     *
+     * @exception IOException if an I/O error occurs.
+     */
+    void close() throws IOException;
 }

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java b/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java
index 20649de..cbbcb9a 100644
--- a/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java
+++ b/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java
@@ -22,136 +22,139 @@ import java.io.InputStream;
 import java.nio.ByteBuffer;
 
 /**
- * The StreamInput class takes a <code>InputStream</code> object and
- * wraps it as <code>Input</code> object acceptable by <code>CryptoInputStream</code>.
+ * The StreamInput class takes a <code>InputStream</code> object and wraps it as
+ * <code>Input</code> object acceptable by <code>CryptoInputStream</code>.
  */
 public class StreamInput implements Input {
-  private final byte[] buf;
-  private final int bufferSize;
-  final InputStream in;
+    private final byte[] buf;
+    private final int bufferSize;
+    final InputStream in;
 
-  /**
-   * Constructs a {@link org.apache.commons.crypto.stream.input.StreamInput}.
-   *
-   * @param inputStream the inputstream object.
-   * @param bufferSize the buffersize.
-   */
-  public StreamInput(InputStream inputStream, int bufferSize) {
-    this.in = inputStream;
-    this.bufferSize = bufferSize;
-    buf = new byte[bufferSize];
-  }
+    /**
+     * Constructs a {@link org.apache.commons.crypto.stream.input.StreamInput}.
+     *
+     * @param inputStream the inputstream object.
+     * @param bufferSize the buffersize.
+     */
+    public StreamInput(InputStream inputStream, int bufferSize) {
+        this.in = inputStream;
+        this.bufferSize = bufferSize;
+        buf = new byte[bufferSize];
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#read(ByteBuffer)}.
-   * Reads a sequence of bytes from input into the given buffer.
-   *
-   * @param  dst
-   *         The buffer into which bytes are to be transferred.
-   *
-   * @return the total number of bytes read into the buffer, or
-   *          <code>-1</code> if there is no more data because the end of
-   *          the stream has been reached.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int read(ByteBuffer dst) throws IOException {
-    int remaining = dst.remaining();
-    int read = 0;
-    while (remaining > 0) {
-      final int n = in.read(buf, 0, Math.min(remaining, bufferSize));
-      if (n == -1) {
-        if (read == 0) {
-          read = -1;
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#read(ByteBuffer)}.
+     * Reads a sequence of bytes from input into the given buffer.
+     *
+     * @param dst The buffer into which bytes are to be transferred.
+     *
+     * @return the total number of bytes read into the buffer, or
+     *         <code>-1</code> if there is no more data because the end of the
+     *         stream has been reached.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int read(ByteBuffer dst) throws IOException {
+        int remaining = dst.remaining();
+        int read = 0;
+        while (remaining > 0) {
+            final int n = in.read(buf, 0, Math.min(remaining, bufferSize));
+            if (n == -1) {
+                if (read == 0) {
+                    read = -1;
+                }
+                break;
+            } else if (n > 0) {
+                dst.put(buf, 0, n);
+                read += n;
+                remaining -= n;
+            }
         }
-        break;
-      } else if (n > 0) {
-        dst.put(buf, 0, n);
-        read += n;
-        remaining -= n;
-      }
+        return read;
     }
-    return read;
-  }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#skip(long)}.
-   * Skips over and discards <code>n</code> bytes of data from this input
-   * stream.
-   *
-   * @param n the number of bytes to be skipped.
-   * @return the actual number of bytes skipped.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public long skip(long n) throws IOException {
-    return in.skip(n);
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#skip(long)}. Skips
+     * over and discards <code>n</code> bytes of data from this input stream.
+     *
+     * @param n the number of bytes to be skipped.
+     * @return the actual number of bytes skipped.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public long skip(long n) throws IOException {
+        return in.skip(n);
+    }
 
-  /**
-   * Overrides the {@link Input#available()}.
-   * Returns an estimate of the number of bytes that can be read (or
-   * skipped over) from this input stream without blocking by the next
-   * invocation of a method for this input stream. The next invocation
-   * might be the same thread or another thread.  A single read or skip of this
-   * many bytes will not block, but may read or skip fewer bytes.
-   *
-   * @return  an estimate of the number of bytes that can be read (or skipped
-   *          over) from this input stream without blocking or {@code 0} when
-   *          it reaches the end of the input stream.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int available() throws IOException {
-    return in.available();
-  }
+    /**
+     * Overrides the {@link Input#available()}. Returns an estimate of the
+     * number of bytes that can be read (or skipped over) from this input stream
+     * without blocking by the next invocation of a method for this input
+     * stream. The next invocation might be the same thread or another thread. A
+     * single read or skip of this many bytes will not block, but may read or
+     * skip fewer bytes.
+     *
+     * @return an estimate of the number of bytes that can be read (or skipped
+     *         over) from this input stream without blocking or {@code 0} when
+     *         it reaches the end of the input stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int available() throws IOException {
+        return in.available();
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#read(long, byte[], int, int)}.
-   * Reads up to <code>len</code> bytes of data from the input stream into
-   * an array of bytes.  An attempt is made to read as many as
-   * <code>len</code> bytes, but a smaller number may be read.
-   * The number of bytes actually read is returned as an integer.
-   *
-   * @param position the given position within a stream.
-   * @param buffer the buffer into which the data is read.
-   * @param offset the start offset in array buffer.
-   * @param length the maximum number of bytes to read.
-   * @return the total number of bytes read into the buffer, or
-   *          <code>-1</code> if there is no more data because the end of
-   *          the stream has been reached.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int read(long position, byte[] buffer, int offset, int length)
-      throws IOException {
-    throw new UnsupportedOperationException(
-        "Positioned read is not supported by this implementation");
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#read(long, byte[], int, int)}
+     * . Reads up to <code>len</code> bytes of data from the input stream into
+     * an array of bytes. An attempt is made to read as many as <code>len</code>
+     * bytes, but a smaller number may be read. The number of bytes actually
+     * read is returned as an integer.
+     *
+     * @param position the given position within a stream.
+     * @param buffer the buffer into which the data is read.
+     * @param offset the start offset in array buffer.
+     * @param length the maximum number of bytes to read.
+     * @return the total number of bytes read into the buffer, or
+     *         <code>-1</code> if there is no more data because the end of the
+     *         stream has been reached.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int read(long position, byte[] buffer, int offset, int length)
+            throws IOException {
+        throw new UnsupportedOperationException(
+                "Positioned read is not supported by this implementation");
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#seek(long)}.
-   * Seeks to the given offset from the start of the stream.
-   * The next read() will be from that location.
-   *
-   * @param position the offset from the start of the stream.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void seek(long position) throws IOException {
-    throw new UnsupportedOperationException(
-        "Seek is not supported by this implementation");
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#seek(long)}. Seeks to
+     * the given offset from the start of the stream. The next read() will be
+     * from that location.
+     *
+     * @param position the offset from the start of the stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void seek(long position) throws IOException {
+        throw new UnsupportedOperationException(
+                "Seek is not supported by this implementation");
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.input.Input#seek(long)}.
-   * Closes this input and releases any system resources associated
-   * with the under layer input.
-   *
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void close() throws IOException {
-    in.close();
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.input.Input#seek(long)}. Closes
+     * this input and releases any system resources associated with the under
+     * layer input.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void close() throws IOException {
+        in.close();
+    }
 }

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/input/package-info.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/input/package-info.java b/src/main/java/org/apache/commons/crypto/stream/input/package-info.java
index 66e7af5..877eba0 100644
--- a/src/main/java/org/apache/commons/crypto/stream/input/package-info.java
+++ b/src/main/java/org/apache/commons/crypto/stream/input/package-info.java
@@ -19,3 +19,4 @@
  * Input classes
  */
 package org.apache.commons.crypto.stream.input;
+

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java b/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java
index 9805484..a28a21e 100644
--- a/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java
+++ b/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java
@@ -22,57 +22,58 @@ import java.nio.ByteBuffer;
 import java.nio.channels.WritableByteChannel;
 
 /**
- * The ChannelOutput class takes a <code>WritableByteChannel</code> object and wraps it as
- * <code>Output</code> object acceptable by <code>CryptoOutputStream</code> as the output target.
+ * The ChannelOutput class takes a <code>WritableByteChannel</code> object and
+ * wraps it as <code>Output</code> object acceptable by
+ * <code>CryptoOutputStream</code> as the output target.
  */
 public class ChannelOutput implements Output {
 
-  private WritableByteChannel channel;
+    private WritableByteChannel channel;
 
-  /**
-   * Constructs a {@link org.apache.commons.crypto.stream.output.ChannelOutput}.
-   *
-   * @param channel the WritableByteChannel object.
-   */
-  public ChannelOutput(WritableByteChannel channel) {
-    this.channel = channel;
-  }
+    /**
+     * Constructs a
+     * {@link org.apache.commons.crypto.stream.output.ChannelOutput}.
+     *
+     * @param channel the WritableByteChannel object.
+     */
+    public ChannelOutput(WritableByteChannel channel) {
+        this.channel = channel;
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.output.Output#write(ByteBuffer)}.
-   * Writes a sequence of bytes to this output from the given buffer.
-   *
-   * @param  src
-   *         The buffer from which bytes are to be retrieved.
-   *
-   * @return The number of bytes written, possibly zero.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int write(ByteBuffer src) throws IOException {
-    return channel.write(src);
-  }
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.output.Output#write(ByteBuffer)}.
+     * Writes a sequence of bytes to this output from the given buffer.
+     *
+     * @param src The buffer from which bytes are to be retrieved.
+     *
+     * @return The number of bytes written, possibly zero.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int write(ByteBuffer src) throws IOException {
+        return channel.write(src);
+    }
 
-  /**
-   * Overrides the {@link Output#flush()}.
-   * Flushes this output and forces any buffered output bytes
-   * to be written out if the under layer output method support.
-   *
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void flush() throws IOException {
-  }
+    /**
+     * Overrides the {@link Output#flush()}. Flushes this output and forces any
+     * buffered output bytes to be written out if the under layer output method
+     * support.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void flush() throws IOException {
+    }
 
-  /**
-   * Overrides the {@link Output#close()}.
-   * Closes this output and releases any system resources associated
-   * with the under layer output.
-   *
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void close() throws IOException {
-    channel.close();
-  }
+    /**
+     * Overrides the {@link Output#close()}. Closes this output and releases any
+     * system resources associated with the under layer output.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void close() throws IOException {
+        channel.close();
+    }
 }

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/output/Output.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/output/Output.java b/src/main/java/org/apache/commons/crypto/stream/output/Output.java
index 34f1610..5dbb835 100644
--- a/src/main/java/org/apache/commons/crypto/stream/output/Output.java
+++ b/src/main/java/org/apache/commons/crypto/stream/output/Output.java
@@ -21,56 +21,57 @@ import java.io.IOException;
 import java.nio.ByteBuffer;
 
 /**
- * The Output interface abstract the output target of <code>CryptoOutputStream</code> so that
- * different implementation of output can be used. The implementation Output interface will usually
- * wraps an output mechanism such as <code>OutputStream</code> or <code>WritableByteChannel</code>.
+ * The Output interface abstract the output target of
+ * <code>CryptoOutputStream</code> so that different implementation of output
+ * can be used. The implementation Output interface will usually wraps an output
+ * mechanism such as <code>OutputStream</code> or
+ * <code>WritableByteChannel</code>.
  */
 public interface Output {
 
-  /**
-   * Writes a sequence of bytes to this output from the given buffer.
-   *
-   * <p> An attempt is made to write up to <i>r</i> bytes to the channel,
-   * where <i>r</i> is the number of bytes remaining in the buffer, that is,
-   * <tt>src.remaining()</tt>, at the moment this method is invoked.
-   *
-   * <p> Suppose that a byte sequence of length <i>n</i> is written, where
-   * <tt>0</tt>&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
-   * This byte sequence will be transferred from the buffer starting at index
-   * <i>p</i>, where <i>p</i> is the buffer's position at the moment this
-   * method is invoked; the index of the last byte written will be
-   * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>.
-   * Upon return the buffer's position will be equal to
-   * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
-   *
-   * @param  src
-   *         The buffer from which bytes are to be retrieved.
-   *
-   * @return The number of bytes written, possibly zero.
-   *
-   * @throws  IOException
-   *          If some other I/O error occurs.
-   */
-  int write(ByteBuffer src) throws IOException;
+    /**
+     * Writes a sequence of bytes to this output from the given buffer.
+     *
+     * <p>
+     * An attempt is made to write up to <i>r</i> bytes to the channel, where
+     * <i>r</i> is the number of bytes remaining in the buffer, that is,
+     * <tt>src.remaining()</tt>, at the moment this method is invoked.
+     *
+     * <p>
+     * Suppose that a byte sequence of length <i>n</i> is written, where
+     * <tt>0</tt>&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>
+     * &nbsp;<i>r</i>. This byte sequence will be transferred from the buffer
+     * starting at index <i>p</i>, where <i>p</i> is the buffer's position at
+     * the moment this method is invoked; the index of the last byte written
+     * will be <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;
+     * <tt>1</tt>. Upon return the buffer's position will be equal to
+     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
+     *
+     * @param src The buffer from which bytes are to be retrieved.
+     *
+     * @return The number of bytes written, possibly zero.
+     *
+     * @throws IOException If some other I/O error occurs.
+     */
+    int write(ByteBuffer src) throws IOException;
 
-  /**
-   * Flushes this output and forces any buffered output bytes
-   * to be written out if the under layer output method support.
-   * The general contract of <code>flush</code> is
-   * that calling it is an indication that, if any bytes previously
-   * written have been buffered by the implementation of the output
-   * stream, such bytes should immediately be written to their
-   * intended destination.
-   *
-   * @throws IOException  if an I/O error occurs.
-   */
-  void flush() throws IOException;
+    /**
+     * Flushes this output and forces any buffered output bytes to be written
+     * out if the under layer output method support. The general contract of
+     * <code>flush</code> is that calling it is an indication that, if any bytes
+     * previously written have been buffered by the implementation of the output
+     * stream, such bytes should immediately be written to their intended
+     * destination.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    void flush() throws IOException;
 
-  /**
-   * Closes this output and releases any system resources associated
-   * with the under layer output.
-   *
-   * @throws IOException  if an I/O error occurs.
-   */
-  void close() throws IOException;
+    /**
+     * Closes this output and releases any system resources associated with the
+     * under layer output.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    void close() throws IOException;
 }

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java b/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java
index 8c0e4d7..78c9bab 100644
--- a/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java
+++ b/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java
@@ -22,76 +22,77 @@ import java.io.OutputStream;
 import java.nio.ByteBuffer;
 
 /**
- * The StreamOutput class takes a <code>OutputStream</code> object and wraps it as
- * <code>Output</code> object acceptable by <code>CryptoOutputStream</code> as the output target.
+ * The StreamOutput class takes a <code>OutputStream</code> object and wraps it
+ * as <code>Output</code> object acceptable by <code>CryptoOutputStream</code>
+ * as the output target.
  */
 public class StreamOutput implements Output {
-  private final byte[] buf;
-  private final int bufferSize;
-  private final OutputStream out;
+    private final byte[] buf;
+    private final int bufferSize;
+    private final OutputStream out;
 
-  /**
-   * Constructs a {@link org.apache.commons.crypto.stream.output.StreamOutput}.
-   *
-   * @param out the OutputStream object.
-   * @param bufferSize the buffersize.
-   */
-  public StreamOutput(OutputStream out, int bufferSize) {
-    this.out = out;
-    this.bufferSize = bufferSize;
-    buf = new byte[bufferSize];
-  }
+    /**
+     * Constructs a {@link org.apache.commons.crypto.stream.output.StreamOutput}
+     * .
+     *
+     * @param out the OutputStream object.
+     * @param bufferSize the buffersize.
+     */
+    public StreamOutput(OutputStream out, int bufferSize) {
+        this.out = out;
+        this.bufferSize = bufferSize;
+        buf = new byte[bufferSize];
+    }
 
-  /**
-   * Overrides the {@link org.apache.commons.crypto.stream.output.Output#write(ByteBuffer)}.
-   * Writes a sequence of bytes to this output from the given buffer.
-   *
-   * @param  src
-   *         The buffer from which bytes are to be retrieved.
-   *
-   * @return The number of bytes written, possibly zero.
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public int write(ByteBuffer src) throws IOException {
-    final int len = src.remaining();
+    /**
+     * Overrides the
+     * {@link org.apache.commons.crypto.stream.output.Output#write(ByteBuffer)}.
+     * Writes a sequence of bytes to this output from the given buffer.
+     *
+     * @param src The buffer from which bytes are to be retrieved.
+     *
+     * @return The number of bytes written, possibly zero.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public int write(ByteBuffer src) throws IOException {
+        final int len = src.remaining();
 
-    int remaining = len;
-    while(remaining > 0) {
-      final int n = Math.min(remaining, bufferSize);
-      src.get(buf, 0, n);
-      out.write(buf, 0, n);
-      remaining = src.remaining();
-    }
+        int remaining = len;
+        while (remaining > 0) {
+            final int n = Math.min(remaining, bufferSize);
+            src.get(buf, 0, n);
+            out.write(buf, 0, n);
+            remaining = src.remaining();
+        }
 
-    return len;
-  }
+        return len;
+    }
 
-  /**
-   * Overrides the {@link Output#flush()}.
-   * Flushes this output and forces any buffered output bytes
-   * to be written out if the under layer output method support.
-   *
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void flush() throws IOException {
-    out.flush();
-  }
+    /**
+     * Overrides the {@link Output#flush()}. Flushes this output and forces any
+     * buffered output bytes to be written out if the under layer output method
+     * support.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void flush() throws IOException {
+        out.flush();
+    }
 
-  /**
-   * Overrides the {@link Output#close()}.
-   * Closes this output and releases any system resources associated
-   * with the under layer output.
-   *
-   * @throws IOException if an I/O error occurs.
-   */
-  @Override
-  public void close() throws IOException {
-    out.close();
-  }
+    /**
+     * Overrides the {@link Output#close()}. Closes this output and releases any
+     * system resources associated with the under layer output.
+     *
+     * @throws IOException if an I/O error occurs.
+     */
+    @Override
+    public void close() throws IOException {
+        out.close();
+    }
 
-  protected OutputStream getOut() {
-    return out;
-  }
+    protected OutputStream getOut() {
+        return out;
+    }
 }

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/output/package-info.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/output/package-info.java b/src/main/java/org/apache/commons/crypto/stream/output/package-info.java
index eca3927..c31b85e 100644
--- a/src/main/java/org/apache/commons/crypto/stream/output/package-info.java
+++ b/src/main/java/org/apache/commons/crypto/stream/output/package-info.java
@@ -19,3 +19,4 @@
  * Output classes
  */
 package org.apache.commons.crypto.stream.output;
+

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/stream/package-info.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/stream/package-info.java b/src/main/java/org/apache/commons/crypto/stream/package-info.java
index 416d78b..6ae28e3 100644
--- a/src/main/java/org/apache/commons/crypto/stream/package-info.java
+++ b/src/main/java/org/apache/commons/crypto/stream/package-info.java
@@ -19,3 +19,4 @@
  * Stream classes
  */
 package org.apache.commons.crypto.stream;
+

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/95a8d486/src/main/java/org/apache/commons/crypto/utils/IOUtils.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/crypto/utils/IOUtils.java b/src/main/java/org/apache/commons/crypto/utils/IOUtils.java
index a3ecda4..4b0e6ee 100644
--- a/src/main/java/org/apache/commons/crypto/utils/IOUtils.java
+++ b/src/main/java/org/apache/commons/crypto/utils/IOUtils.java
@@ -28,71 +28,74 @@ import org.apache.commons.logging.Log;
  */
 public class IOUtils {
 
-  private IOUtils() {}
+    private IOUtils() {
+    }
 
-  /**
-   * Does the readFully based on the Input read.
-   *
-   * @param in the input stream of bytes.
-   * @param buf the buffer to be read.
-   * @param off the start offset in array buffer.
-   * @param len the maximum number of bytes to read.
-   * @throws IOException if an I/O error occurs.
-   */
-  public static void readFully(InputStream in, byte buf[],
-      int off, int len) throws IOException {
-    int toRead = len;
-    while (toRead > 0) {
-      int ret = in.read(buf, off, toRead);
-      if (ret < 0) {
-        throw new IOException( "Premature EOF from inputStream");
-      }
-      toRead -= ret;
-      off += ret;
+    /**
+     * Does the readFully based on the Input read.
+     *
+     * @param in the input stream of bytes.
+     * @param buf the buffer to be read.
+     * @param off the start offset in array buffer.
+     * @param len the maximum number of bytes to read.
+     * @throws IOException if an I/O error occurs.
+     */
+    public static void readFully(InputStream in, byte buf[], int off, int len)
+            throws IOException {
+        int toRead = len;
+        while (toRead > 0) {
+            int ret = in.read(buf, off, toRead);
+            if (ret < 0) {
+                throw new IOException("Premature EOF from inputStream");
+            }
+            toRead -= ret;
+            off += ret;
+        }
     }
-  }
 
-  /**
-   * Does the readFully based on Input's positioned read.
-   * This does not change the current offset of the stream and is thread-safe.
-   *
-   * @param in the input source.
-   * @param position the given position.
-   * @param buffer the buffer to be read.
-   * @param length the maximum number of bytes to read.
-   * @param offset the start offset in array buffer.
-   * @throws IOException if an I/O error occurs.
-   */
-  public static void readFully(Input in, long position,
-      byte[] buffer, int offset, int length) throws IOException {
-    int nread = 0;
-    while (nread < length) {
-      int nbytes = in.read(position+nread, buffer, offset+nread, length-nread);
-      if (nbytes < 0) {
-        throw new IOException("End of stream reached before reading fully.");
-      }
-      nread += nbytes;
+    /**
+     * Does the readFully based on Input's positioned read. This does not change
+     * the current offset of the stream and is thread-safe.
+     *
+     * @param in the input source.
+     * @param position the given position.
+     * @param buffer the buffer to be read.
+     * @param length the maximum number of bytes to read.
+     * @param offset the start offset in array buffer.
+     * @throws IOException if an I/O error occurs.
+     */
+    public static void readFully(Input in, long position, byte[] buffer,
+            int offset, int length) throws IOException {
+        int nread = 0;
+        while (nread < length) {
+            int nbytes = in.read(position + nread, buffer, offset + nread,
+                    length - nread);
+            if (nbytes < 0) {
+                throw new IOException(
+                        "End of stream reached before reading fully.");
+            }
+            nread += nbytes;
+        }
     }
-  }
 
-  /**
-   * Closes the Closeable objects and <b>ignore</b> any {@link IOException} or
-   * null pointers. Must only be used for cleanup in exception handlers.
-   *
-   * @param log the log to record problems to at debug level. Can be null.
-   * @param closeables the objects to close.
-   */
-  public static void cleanup(Log log, java.io.Closeable... closeables) {
-    for (java.io.Closeable c : closeables) {
-      if (c != null) {
-        try {
-          c.close();
-        } catch(Throwable e) {
-          if (log != null && log.isDebugEnabled()) {
-            log.debug("Exception in closing " + c, e);
-          }
+    /**
+     * Closes the Closeable objects and <b>ignore</b> any {@link IOException} or
+     * null pointers. Must only be used for cleanup in exception handlers.
+     *
+     * @param log the log to record problems to at debug level. Can be null.
+     * @param closeables the objects to close.
+     */
+    public static void cleanup(Log log, java.io.Closeable... closeables) {
+        for (java.io.Closeable c : closeables) {
+            if (c != null) {
+                try {
+                    c.close();
+                } catch (Throwable e) {
+                    if (log != null && log.isDebugEnabled()) {
+                        log.debug("Exception in closing " + c, e);
+                    }
+                }
+            }
         }
-      }
     }
-  }
 }


Mime
View raw message