org.apache.commons.compress.archivers.dump.TapeInputStream Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-compress Show documentation
Show all versions of commons-compress Show documentation
Apache Commons Compress software defines an API for working with
compression and archive formats. These include: bzip2, gzip, pack200,
lzma, xz, Snappy, traditional Unix Compress, DEFLATE, DEFLATE64, LZ4,
Brotli, Zstandard and ar, cpio, jar, tar, zip, dump, 7z, arj.
/*
* 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}
*
*
* reads the full given length unless EOF is reached.
*
*
* @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.
*
*
* skips the full given length unless EOF is reached.
*
*
* @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;
}
}