TapeInputStream.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.commons.compress.archivers.dump;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.zip.DataFormatException;
import java.util.zip.Inflater;

import org.apache.commons.compress.utils.ExactMath;
import org.apache.commons.compress.utils.IOUtils;

/**
 * Filter stream that mimics a physical tape drive capable of compressing the data stream.
 *
 * @NotThreadSafe
 */
final class TapeInputStream extends FilterInputStream {
    private static final int RECORD_SIZE = DumpArchiveConstants.TP_SIZE;
    private byte[] blockBuffer = new byte[DumpArchiveConstants.TP_SIZE];
    private int currBlkIdx = -1;
    private int blockSize = DumpArchiveConstants.TP_SIZE;
    private int readOffset = DumpArchiveConstants.TP_SIZE;
    private boolean isCompressed;
    private long bytesRead;

    /**
     * Constructs a new instance.
     *
     * @param in the underlying input stream.
     */
    TapeInputStream(final InputStream in) {
        super(in);
    }

    /**
     * @see java.io.InputStream#available
     */
    @Override
    public int available() throws IOException {
        if (readOffset < blockSize) {
            return blockSize - readOffset;
        }

        return in.available();
    }

    /**
     * Close the input stream.
     *
     * @throws IOException on error
     */
    @Override
    public void close() throws IOException {
        if (in != null && in != System.in) {
            in.close();
        }
    }

    /**
     * Gets number of bytes read.
     *
     * @return number of bytes read.
     */
    public long getBytesRead() {
        return bytesRead;
    }

    /**
     * Peek at the next record from the input stream and return the data.
     *
     * @return The record data.
     * @throws IOException on error
     */
    public byte[] peek() throws IOException {
        // we need to read from the underlying stream. This
        // isn't a problem since it would be the first step in
        // any subsequent read() anyway.
        if (readOffset == blockSize) {
            try {
                readBlock(true);
            } catch (final ShortFileException sfe) { // NOSONAR
                return null;
            }
        }

        // copy data, increment counters.
        final byte[] b = new byte[RECORD_SIZE];
        System.arraycopy(blockBuffer, readOffset, b, 0, b.length);

        return b;
    }

    /**
     * @see java.io.InputStream#read()
     */
    @Override
    public int read() throws IOException {
        throw new IllegalArgumentException("All reads must be multiple of record size (" + RECORD_SIZE + " bytes.");
    }

    /**
     * {@inheritDoc}
     *
     * <p>
     * reads the full given length unless EOF is reached.
     * </p>
     *
     * @param len length to read, must be a multiple of the stream's record size
     */
    @Override
    public int read(final byte[] b, int off, final int len) throws IOException {
        if (len == 0) {
            return 0;
        }
        if (len % RECORD_SIZE != 0) {
            throw new IllegalArgumentException("All reads must be multiple of record size (" + RECORD_SIZE + " bytes.");
        }

        int bytes = 0;

        while (bytes < len) {
            // we need to read from the underlying stream.
            // this will reset readOffset value.
            // return -1 if there's a problem.
            if (readOffset == blockSize) {
                try {
                    readBlock(true);
                } catch (final ShortFileException sfe) { // NOSONAR
                    return -1;
                }
            }

            int n = 0;

            if (readOffset + len - bytes <= blockSize) {
                // we can read entirely from the buffer.
                n = len - bytes;
            } else {
                // copy what we can from the buffer.
                n = blockSize - readOffset;
            }

            // copy data, increment counters.
            System.arraycopy(blockBuffer, readOffset, b, off, n);
            readOffset += n;
            bytes += n;
            off += n;
        }

        return bytes;
    }

    /**
     * Read next block. All decompression is handled here.
     *
     * @param decompress if false the buffer will not be decompressed. This is an optimization for longer seeks.
     */
    private void readBlock(final boolean decompress) throws IOException {
        if (in == null) {
            throw new IOException("Input buffer is closed");
        }

        if (!isCompressed || currBlkIdx == -1) {
            // file is not compressed
            readFully(blockBuffer, 0, blockSize);
            bytesRead += blockSize;
        } else {
            readFully(blockBuffer, 0, 4);
            bytesRead += 4;

            final int h = DumpArchiveUtil.convert32(blockBuffer, 0);
            final boolean compressed = (h & 0x01) == 0x01;

            if (!compressed) {
                // file is compressed but this block is not.
                readFully(blockBuffer, 0, blockSize);
                bytesRead += blockSize;
            } else {
                // this block is compressed.
                final int flags = h >> 1 & 0x07;
                int length = h >> 4 & 0x0FFFFFFF;
                final byte[] compBuffer = readRange(length);
                bytesRead += length;

                if (!decompress) {
                    // just in case someone reads the data.
                    Arrays.fill(blockBuffer, (byte) 0);
                } else {
                    switch (DumpArchiveConstants.COMPRESSION_TYPE.find(flags & 0x03)) {
                    case ZLIB:

                        final Inflater inflator = new Inflater();
                        try {
                            inflator.setInput(compBuffer, 0, compBuffer.length);
                            length = inflator.inflate(blockBuffer);

                            if (length != blockSize) {
                                throw new ShortFileException();
                            }
                        } catch (final DataFormatException e) {
                            throw new DumpArchiveException("Bad data", e);
                        } finally {
                            inflator.end();
                        }

                        break;

                    case BZLIB:
                        throw new UnsupportedCompressionAlgorithmException("BZLIB2");

                    case LZO:
                        throw new UnsupportedCompressionAlgorithmException("LZO");

                    default:
                        throw new UnsupportedCompressionAlgorithmException();
                    }
                }
            }
        }

        currBlkIdx++;
        readOffset = 0;
    }

    /**
     * Read buffer
     */
    private void readFully(final byte[] b, final int off, final int len) throws IOException {
        final int count = IOUtils.readFully(in, b, off, len);
        if (count < len) {
            throw new ShortFileException();
        }
    }

    private byte[] readRange(final int len) throws IOException {
        final byte[] ret = IOUtils.readRange(in, len);
        if (ret.length < len) {
            throw new ShortFileException();
        }
        return ret;
    }

    /**
     * Read a record from the input stream and return the data.
     *
     * @return The record data.
     * @throws IOException on error
     */
    public byte[] readRecord() throws IOException {
        final byte[] result = new byte[RECORD_SIZE];

        // the read implementation will loop internally as long as
        // input is available
        if (-1 == read(result, 0, result.length)) {
            throw new ShortFileException();
        }

        return result;
    }

    /**
     * Sets the DumpArchive Buffer's block size. We need to sync the block size with the dump archive's actual block size since compression is handled at the
     * block level.
     *
     * @param recsPerBlock records per block
     * @param isCompressed true if the archive is compressed
     * @throws IOException more than one block has been read
     * @throws IOException there was an error reading additional blocks.
     * @throws IOException recsPerBlock is smaller than 1
     */
    public void resetBlockSize(final int recsPerBlock, final boolean isCompressed) throws IOException {
        this.isCompressed = isCompressed;

        if (recsPerBlock < 1) {
            throw new IOException("Block with " + recsPerBlock + " records found, must be at least 1");
        }
        blockSize = RECORD_SIZE * recsPerBlock;
        if (blockSize < 1) {
            throw new IOException("Block size cannot be less than or equal to 0: " + blockSize);
        }

        // save first block in case we need it again
        final byte[] oldBuffer = blockBuffer;

        // read rest of new block
        blockBuffer = new byte[blockSize];
        System.arraycopy(oldBuffer, 0, blockBuffer, 0, RECORD_SIZE);
        readFully(blockBuffer, RECORD_SIZE, blockSize - RECORD_SIZE);

        this.currBlkIdx = 0;
        this.readOffset = RECORD_SIZE;
    }

    /**
     * Skip bytes. Same as read but without the arraycopy.
     *
     * <p>
     * skips the full given length unless EOF is reached.
     * </p>
     *
     * @param len length to read, must be a multiple of the stream's record size
     */
    @Override
    public long skip(final long len) throws IOException {
        if (len % RECORD_SIZE != 0) {
            throw new IllegalArgumentException("All reads must be multiple of record size (" + RECORD_SIZE + " bytes.");
        }

        long bytes = 0;

        while (bytes < len) {
            // we need to read from the underlying stream.
            // this will reset readOffset value. We do not perform
            // any decompression if we won't eventually read the data.
            // return -1 if there's a problem.
            if (readOffset == blockSize) {
                try {
                    readBlock(len - bytes < blockSize);
                } catch (final ShortFileException sfe) { // NOSONAR
                    return -1;
                }
            }

            long n = 0;

            if (readOffset + (len - bytes) <= blockSize) {
                // we can read entirely from the buffer.
                n = len - bytes;
            } else {
                // copy what we can from the buffer.
                n = (long) blockSize - readOffset;
            }

            // do not copy data but still increment counters.
            readOffset = ExactMath.add(readOffset, n);
            bytes += n;
        }

        return bytes;
    }
}