Frames | No Frames |
1: /* ChunkedInputStream.java -- 2: Copyright (C) 2004, 2006 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: import java.net.ProtocolException; 44: 45: 46: // 47: // Note that we rely on the implemtation of skip() in the super class 48: // (InputStream) calling our read methods to account for chunk headers 49: // while skipping. 50: // 51: 52: 53: /** 54: * Input stream wrapper for the "chunked" transfer-coding. 55: * 56: * @author Chris Burdess (dog@gnu.org) 57: */ 58: public class ChunkedInputStream 59: extends InputStream 60: { 61: 62: private static final byte CR = 0x0d; 63: private static final byte LF = 0x0a; 64: 65: Headers headers; 66: 67: /** The underlying stream. */ 68: private InputStream in; 69: 70: /** Size of the chunk we're reading. */ 71: int size; 72: /** Number of bytes we've read in this chunk. */ 73: int count; 74: /** 75: * True when we should read meta-information, false when we should 76: * read data. 77: */ 78: boolean meta; 79: /** True when we've hit EOF. */ 80: boolean eof; 81: 82: /** 83: * Constructor. 84: * @param in the response socket input stream 85: * @param headers the headers to receive additional header lines 86: */ 87: public ChunkedInputStream(InputStream in, Headers headers) 88: { 89: this.in = in; 90: this.headers = headers; 91: size = -1; 92: count = 0; 93: meta = true; 94: } 95: 96: public int read() 97: throws IOException 98: { 99: byte[] buf = new byte[1]; 100: int len = read(buf, 0, 1); 101: if (len == -1) 102: { 103: return -1; 104: } 105: return 0xff & buf[0]; 106: } 107: 108: public synchronized int read(byte[] buffer, int offset, int length) 109: throws IOException 110: { 111: if (eof) 112: { 113: return -1; 114: } 115: if (meta) 116: { 117: // Read chunk header 118: int c, last = 0; 119: boolean seenSemi = false; 120: StringBuilder buf = new StringBuilder(); 121: do 122: { 123: c = in.read(); 124: if (c == 0x3b) // ; 125: { 126: seenSemi = true; 127: } 128: else if (c == 0x0a && last == 0x0d) // CRLF 129: { 130: try 131: { 132: size = Integer.parseInt(buf.toString(), 16); 133: } 134: catch (NumberFormatException nfe) 135: { 136: IOException ioe = new IOException("Bad chunk header"); 137: ioe.initCause(nfe); 138: // Unrecoverable. Don't try to read more. 139: in.close(); 140: throw ioe; 141: } 142: break; 143: } 144: else if (!seenSemi && c >= 0x30) 145: { 146: buf.append ((char) c); 147: } 148: last = c; 149: } 150: while(c != -1); 151: count = 0; 152: meta = false; 153: } 154: if (size == 0) 155: { 156: // Read trailer 157: headers.parse(in); 158: eof = true; 159: return -1; 160: } 161: else 162: { 163: int canRead = Math.min(size - count, length); 164: int len = in.read(buffer, offset, canRead); 165: if (len == -1) 166: { 167: // This is an error condition but it isn't clear what we 168: // should do with it. 169: eof = true; 170: return -1; 171: } 172: count += len; 173: if (count == size) 174: { 175: // Read CRLF 176: int c1 = in.read(); 177: int c2 = in.read(); 178: if (c1 == -1 || c2 == -1) 179: { 180: // EOF before CRLF: bad, but ignore 181: eof = true; 182: return -1; 183: } 184: if (c1 != 0x0d || c2 != 0x0a) 185: { 186: throw new ProtocolException("expecting CRLF: " + c1 + "," + c2); 187: } 188: meta = true; 189: } 190: return len; 191: } 192: } 193: 194: /** 195: * This method returns the number of bytes that can be read from 196: * this stream before a read might block. Even if the underlying 197: * InputStream has data available past the end of the current chunk, 198: * we have no way of knowing how large the next chunk header will 199: * be. So we cannot report available data past the current chunk. 200: * 201: * @return The number of bytes that can be read before a read might 202: * block 203: * 204: * @exception IOException If an error occurs 205: */ 206: public int available() throws IOException 207: { 208: if (meta) 209: return 0; 210: 211: return Math.min(in.available(), size - count); 212: } 213: 214: /** 215: * This method closes the ChunkedInputStream by closing the underlying 216: * InputStream. 217: * 218: * @exception IOException If an error occurs 219: */ 220: public void close() throws IOException 221: { 222: in.close(); 223: } 224: 225: }