    001/*
    002 *  Licensed to the Apache Software Foundation (ASF) under one or more
    003 *  contributor license agreements.  See the NOTICE file distributed with
    004 *  this work for additional information regarding copyright ownership.
    005 *  The ASF licenses this file to You under the Apache License, Version 2.0
    006 *  (the "License"); you may not use this file except in compliance with
    007 *  the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 *  Unless required by applicable law or agreed to in writing, software
    012 *  distributed under the License is distributed on an "AS IS" BASIS,
    013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 *  See the License for the specific language governing permissions and
    015 *  limitations under the License.
    016 */
    017package org.apache.commons.compress.utils;
    018
    019import java.io.IOException;
    020import java.io.InputStream;
    021import java.nio.ByteBuffer;
    022
    023/**
    024 * NIO backed bounded input stream for reading a predefined amount of data from.
    025 * @ThreadSafe this base class is thread safe but implementations must not be.
    026 * @since 1.21
    027 */
    028public abstract class BoundedArchiveInputStream extends InputStream {
    029
    030    private final long end;
    031    private ByteBuffer singleByteBuffer;
    032    private long loc;
    033
    034    /**
    035     * Create a new bounded input stream.
    036     *
    037     * @param start     position in the stream from where the reading of this bounded stream starts.
    038     * @param remaining amount of bytes which are allowed to read from the bounded stream.
    039     */
    040    public BoundedArchiveInputStream(final long start, final long remaining) {
    041        this.end = start + remaining;
    042        if (this.end < start) {
    043            // check for potential vulnerability due to overflow
    044            throw new IllegalArgumentException("Invalid length of stream at offset=" + start + ", length=" + remaining);
    045        }
    046        loc = start;
    047    }
    048
    049    @Override
    050    public synchronized int read() throws IOException {
    051        if (loc >= end) {
    052            return -1;
    053        }
    054        if (singleByteBuffer == null) {
    055            singleByteBuffer = ByteBuffer.allocate(1);
    056        } else {
    057            singleByteBuffer.rewind();
    058        }
    059        final int read = read(loc, singleByteBuffer);
    060        if (read < 1) {
    061            return -1;
    062        }
    063        loc++;
    064        return singleByteBuffer.get() & 0xff;
    065    }
    066
    067    @Override
    068    public synchronized int read(final byte[] b, final int off, final int len) throws IOException {
    069        if (loc >= end) {
    070            return -1;
    071        }
    072        final long maxLen = Math.min(len, end - loc);
    073        if (maxLen <= 0) {
    074            return 0;
    075        }
    076        if (off < 0 || off > b.length || maxLen > b.length - off) {
    077            throw new IndexOutOfBoundsException("offset or len are out of bounds");
    078        }
    079
    080        final ByteBuffer buf = ByteBuffer.wrap(b, off, (int) maxLen);
    081        final int ret = read(loc, buf);
    082        if (ret > 0) {
    083            loc += ret;
    084        }
    085        return ret;
    086    }
    087
    088    /**
    089     * Read content of the stream into a {@link ByteBuffer}.
    090     * @param pos position to start the read.
    091     * @param buf buffer to add the read content.
    092     * @return number of read bytes.
    093     * @throws IOException if I/O fails.
    094     */
    095    protected abstract int read(long pos, ByteBuffer buf) throws IOException;
    096}