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