libjava/classpath/gnu/java/net/protocol/http/LimitedLengthInputStream.java

   1 /* LimitedLengthInputStream.java --
   2    Copyright (C) 2005 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package gnu.java.net.protocol.http;
  40
  41 import java.io.IOException;
  42 import java.io.InputStream;
  43
  44 /**
  45  * InputStream that limits the total number of bytes that can be read
  46  * from an underlying stream.  In addition to limiting the number of
  47  * bytes read, close() is not propagated to the underlying stream.
  48  *
  49  * @author David Daney (ddaney@avtrex.com)
  50  */
  51 class LimitedLengthInputStream
  52   extends InputStream
  53 {
  54   private long remainingLen;
  55   private boolean restrictLen;
  56   private HTTPConnection connection;
  57   private boolean eof;
  58   private InputStream in;
  59   private boolean doClose;
  60
  61
  62   private void handleClose()
  63     throws IOException
  64   {
  65     eof = true;
  66     if (doClose)
  67       {
  68         in.close();
  69       }
  70     else
  71       {
  72         connection.release();
  73       }
  74     in = null;
  75     connection = null;
  76   }
  77
  78   /**
  79    * Constructor.
  80    *
  81    * @param in the underlying stream
  82    *
  83    * @param maxLen the maximum number of bytes to read
  84    *
  85    * @param restrictLen if true the number of bytes that can be read
  86    * from this stream will be limited to maxLen, otherwise the number
  87    * of bytes is not restricted.
  88    *
  89    * @param con the HTTPConnection associated with this stream
  90    *
  91    * @param doClose if true con will be closed when finished reading,
  92    * else it will be placed back in the connection pool.
  93    *
  94    */
  95   LimitedLengthInputStream(InputStream in,
  96                            long maxLen,
  97                            boolean restrictLen,
  98                            HTTPConnection con,
  99                            boolean doClose)
 100     throws IOException
 101
 102   {
 103     this.in = in;
 104     this.remainingLen = maxLen;
 105     this.restrictLen = restrictLen;
 106     this.connection = con;
 107     this.doClose = doClose;
 108
 109     if (restrictLen)
 110       {
 111         if (maxLen < 0)
 112           throw new IllegalArgumentException();
 113         else if (maxLen == 0)
 114           handleClose(); // Nothing to do, release the connection.
 115       }
 116   }
 117
 118   public synchronized int read()
 119     throws IOException
 120   {
 121     if (eof)
 122       return -1; // EOF
 123
 124     int r;
 125
 126     if (restrictLen)
 127       {
 128         r = in.read();
 129         if (-1 != r)
 130           remainingLen--;
 131
 132         if (0 == remainingLen)
 133           handleClose();
 134       }
 135     else
 136       {
 137         r = in.read();
 138         if (r == -1)
 139           handleClose();
 140       }
 141
 142     return r;
 143   }
 144
 145   public int read(byte[] buffer)
 146     throws IOException
 147   {
 148     return read(buffer, 0, buffer.length);
 149   }
 150
 151   public synchronized int read(byte[] buffer, int offset, int length)
 152     throws IOException
 153   {
 154     if (eof)
 155       return -1; // EOF
 156
 157     if (restrictLen && length > remainingLen)
 158       length = (int) remainingLen;
 159
 160     int r = in.read(buffer, offset, length);
 161
 162     if (-1 == r)
 163       handleClose();
 164
 165     if (restrictLen && r > 0)
 166       {
 167         remainingLen -= r;
 168         if (0 == remainingLen)
 169           handleClose();
 170       }
 171     return r;
 172   }
 173
 174   public synchronized long skip(long n)
 175     throws IOException
 176   {
 177
 178     if (eof)
 179       return 0;
 180
 181     if (restrictLen && n > remainingLen)
 182       n = remainingLen;
 183
 184     long r = in.skip(n);
 185
 186     if (restrictLen)
 187       {
 188         remainingLen -= r;
 189         if (0 == remainingLen)
 190           handleClose();
 191       }
 192     return r;
 193   }
 194
 195   public synchronized int available()
 196     throws IOException
 197   {
 198     if (eof)
 199       return 0;
 200
 201     int a = in.available();
 202     if (restrictLen && a > remainingLen)
 203       a = (int)remainingLen;
 204     return a;
 205   }
 206
 207   public synchronized void close()
 208     throws IOException
 209   {
 210     if (eof)
 211       return;
 212
 213     // If we get to here, the stream was not fully read.  Just throw
 214     // it away.
 215
 216     doClose = true;
 217
 218     handleClose();
 219   }
 220 }