View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17  package org.apache.commons.fileupload.util;
    18
    19  import java.io.FilterInputStream;
    20  import java.io.IOException;
    21  import java.io.InputStream;
    22
    23
    24  /**
    25   * An input stream, which limits its data size. This stream is
    26   * used, if the content length is unknown.
    27   */
    28  public abstract class LimitedInputStream
    29          extends FilterInputStream implements Closeable {
    30      /**
    31       * The maximum size of an item, in bytes.
    32       */
    33      private long sizeMax;
    34      /**
    35       * The current number of bytes.
    36       */
    37      private long count;
    38      /**
    39       * Whether this stream is already closed.
    40       */
    41      private boolean closed;
    42
    43      /**
    44       * Creates a new instance.
    45       * @param pIn The input stream, which shall be limited.
    46       * @param pSizeMax The limit; no more than this number of bytes
    47       *   shall be returned by the source stream.
    48       */
    49      public LimitedInputStream(InputStream pIn, long pSizeMax) {
    50          super(pIn);
    51          sizeMax = pSizeMax;
    52      }
    53
    54      /**
    55       * Called to indicate, that the input streams limit has
    56       * been exceeded.
    57       * @param pSizeMax The input streams limit, in bytes.
    58       * @param pCount The actual number of bytes.
    59       * @throws IOException The called method is expected
    60       *   to raise an IOException.
    61       */
    62      protected abstract void raiseError(long pSizeMax, long pCount)
    63              throws IOException;
    64
    65      /** Called to check, whether the input streams
    66       * limit is reached.
    67       * @throws IOException The given limit is exceeded.
    68       */
    69      private void checkLimit() throws IOException {
    70          if (count > sizeMax) {
    71              raiseError(sizeMax, count);
    72          }
    73      }
    74
    75      /**
    76       * Reads the next byte of data from this input stream. The value
    77       * byte is returned as an <code>int</code> in the range
    78       * <code>0</code> to <code>255</code>. If no byte is available
    79       * because the end of the stream has been reached, the value
    80       * <code>-1</code> is returned. This method blocks until input data
    81       * is available, the end of the stream is detected, or an exception
    82       * is thrown.
    83       * <p>
    84       * This method
    85       * simply performs <code>in.read()</code> and returns the result.
    86       *
    87       * @return     the next byte of data, or <code>-1</code> if the end of the
    88       *             stream is reached.
    89       * @exception  IOException  if an I/O error occurs.
    90       * @see        java.io.FilterInputStream#in
    91       */
    92      public int read() throws IOException {
    93          int res = super.read();
    94          if (res != -1) {
    95              count++;
    96              checkLimit();
    97          }
    98          return res;
    99      }
    100
    101     /**
    102      * Reads up to <code>len</code> bytes of data from this input stream
    103      * into an array of bytes. If <code>len</code> is not zero, the method
    104      * blocks until some input is available; otherwise, no
    105      * bytes are read and <code>0</code> is returned.
    106      * <p>
    107      * This method simply performs <code>in.read(b, off, len)</code>
    108      * and returns the result.
    109      *
    110      * @param      b     the buffer into which the data is read.
    111      * @param      off   The start offset in the destination array
    112      *                   <code>b</code>.
    113      * @param      len   the maximum number of bytes read.
    114      * @return     the total number of bytes read into the buffer, or
    115      *             <code>-1</code> if there is no more data because the end of
    116      *             the stream has been reached.
    117      * @exception  NullPointerException If <code>b</code> is <code>null</code>.
    118      * @exception  IndexOutOfBoundsException If <code>off</code> is negative,
    119      * <code>len</code> is negative, or <code>len</code> is greater than
    120      * <code>b.length - off</code>
    121      * @exception  IOException  if an I/O error occurs.
    122      * @see        java.io.FilterInputStream#in
    123      */
    124     public int read(byte[] b, int off, int len) throws IOException {
    125         int res = super.read(b, off, len);
    126         if (res > 0) {
    127             count += res;
    128             checkLimit();
    129         }
    130         return res;
    131     }
    132
    133     /**
    134      * Returns, whether this stream is already closed.
    135      * @return True, if the stream is closed, otherwise false.
    136      * @throws IOException An I/O error occurred.
    137      */
    138     public boolean isClosed() throws IOException {
    139         return closed;
    140     }
    141
    142     /**
    143      * Closes this input stream and releases any system resources
    144      * associated with the stream.
    145      * This
    146      * method simply performs <code>in.close()</code>.
    147      *
    148      * @exception  IOException  if an I/O error occurs.
    149      * @see        java.io.FilterInputStream#in
    150      */
    151     public void close() throws IOException {
    152         closed = true;
    153         super.close();
    154     }
    155 }