ojluni/src/main/java/sun/net/httpserver/ExchangeImpl.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package sun.net.httpserver;

 import java.io.*;
 import java.net.*;
 import javax.net.ssl.*;
 import java.util.*;
 import java.util.logging.Logger;
 import java.text.*;
 import com.sun.net.httpserver.*;

 class ExchangeImpl {

     Headers reqHdrs, rspHdrs;
     Request req;
     String method;
     boolean writefinished;
     URI uri;
     HttpConnection connection;
     long reqContentLen;
     long rspContentLen;
     /* raw streams which access the socket directly */
     InputStream ris;
     OutputStream ros;
     Thread thread;
     /* close the underlying connection when this exchange finished */
     boolean close;
     boolean closed;
     boolean http10 = false;

     /* for formatting the Date: header */
     private static final String pattern = "EEE, dd MMM yyyy HH:mm:ss zzz";
     private static final TimeZone gmtTZ = TimeZone.getTimeZone("GMT");
     private static final ThreadLocal<DateFormat> dateFormat =
          new ThreadLocal<DateFormat>() {
              @Override protected DateFormat initialValue() {
                  DateFormat df = new SimpleDateFormat(pattern, Locale.US);
                  df.setTimeZone(gmtTZ);
                  return df;
          }
      };

     private static final String HEAD = "HEAD";

     /* streams which take care of the HTTP protocol framing
      * and are passed up to higher layers
      */
     InputStream uis;
     OutputStream uos;
     LeftOverInputStream uis_orig; // uis may have be a user supplied wrapper
     PlaceholderOutputStream uos_orig;

     boolean sentHeaders; /* true after response headers sent */
     Map<String,Object> attributes;
     int rcode = -1;
     HttpPrincipal principal;
     ServerImpl server;

     ExchangeImpl (
         String m, URI u, Request req, long len, HttpConnection connection
     ) throws IOException {
         this.req = req;
         this.reqHdrs = req.headers();
         this.rspHdrs = new Headers();
         this.method = m;
         this.uri = u;
         this.connection = connection;
         this.reqContentLen = len;
         /* ros only used for headers, body written directly to stream */
         this.ros = req.outputStream();
         this.ris = req.inputStream();
         server = getServerImpl();
         server.startExchange();
     }

     public Headers getRequestHeaders () {
         return new UnmodifiableHeaders (reqHdrs);
     }

     public Headers getResponseHeaders () {
         return rspHdrs;
     }

     public URI getRequestURI () {
         return uri;
     }

     public String getRequestMethod (){
         return method;
     }

     public HttpContextImpl getHttpContext (){
         return connection.getHttpContext();
     }

     private boolean isHeadRequest() {
         return HEAD.equals(getRequestMethod());
     }

     public void close () {
         if (closed) {
             return;
         }
         closed = true;

         /* close the underlying connection if,
          * a) the streams not set up yet, no response can be sent, or
          * b) if the wrapper output stream is not set up, or
          * c) if the close of the input/outpu stream fails
          */
         try {
             if (uis_orig == null || uos == null) {
                 connection.close();
                 return;
             }
             if (!uos_orig.isWrapped()) {
                 connection.close();
                 return;
             }
             if (!uis_orig.isClosed()) {
                 uis_orig.close();
             }
             uos.close();
         } catch (IOException e) {
             connection.close();
         }
     }

     public InputStream getRequestBody () {
         if (uis != null) {
             return uis;
         }
         if (reqContentLen == -1L) {
             uis_orig = new ChunkedInputStream (this, ris);
             uis = uis_orig;
         } else {
             uis_orig = new FixedLengthInputStream (this, ris, reqContentLen);
             uis = uis_orig;
         }
         return uis;
     }

     LeftOverInputStream getOriginalInputStream () {
         return uis_orig;
     }

     public int getResponseCode () {
         return rcode;
     }

     public OutputStream getResponseBody () {
         /* TODO. Change spec to remove restriction below. Filters
          * cannot work with this restriction
          *
          * if (!sentHeaders) {
          *    throw new IllegalStateException ("headers not sent");
          * }
          */
         if (uos == null) {
             uos_orig = new PlaceholderOutputStream (null);
             uos = uos_orig;
         }
         return uos;
     }


     /* returns the place holder stream, which is the stream
      * returned from the 1st call to getResponseBody()
      * The "real" ouputstream is then placed inside this
      */
     PlaceholderOutputStream getPlaceholderResponseBody () {
         getResponseBody();
         return uos_orig;
     }

     public void sendResponseHeaders (int rCode, long contentLen)
     throws IOException
     {
         if (sentHeaders) {
             throw new IOException ("headers already sent");
         }
         this.rcode = rCode;
         String statusLine = "HTTP/1.1 "+rCode+Code.msg(rCode)+"\r\n";
         OutputStream tmpout = new BufferedOutputStream (ros);
         PlaceholderOutputStream o = getPlaceholderResponseBody();
         tmpout.write (bytes(statusLine, 0), 0, statusLine.length());
         boolean noContentToSend = false; // assume there is content
         rspHdrs.set ("Date", dateFormat.get().format (new Date()));

         /* check for response type that is not allowed to send a body */

         if ((rCode>=100 && rCode <200) /* informational */
             ||(rCode == 204)           /* no content */
             ||(rCode == 304))          /* not modified */
         {
             if (contentLen != -1) {
                 Logger logger = server.getLogger();
                 String msg = "sendResponseHeaders: rCode = "+ rCode
                     + ": forcing contentLen = -1";
                 logger.warning (msg);
             }
             contentLen = -1;
         }

         if (isHeadRequest()) {
             /* HEAD requests should not set a content length by passing it
              * through this API, but should instead manually set the required
              * headers.*/
             if (contentLen >= 0) {
                 final Logger logger = server.getLogger();
                 String msg =
                     "sendResponseHeaders: being invoked with a content length for a HEAD request";
                 logger.warning (msg);
             }
             noContentToSend = true;
             contentLen = 0;
         } else { /* not a HEAD request */
             if (contentLen == 0) {
                 if (http10) {
                     o.setWrappedStream (new UndefLengthOutputStream (this, ros));
                     close = true;
                 } else {
                     rspHdrs.set ("Transfer-encoding", "chunked");
                     o.setWrappedStream (new ChunkedOutputStream (this, ros));
                 }
             } else {
                 if (contentLen == -1) {
                     noContentToSend = true;
                     contentLen = 0;
                 }
                 rspHdrs.set("Content-length", Long.toString(contentLen));
                 o.setWrappedStream (new FixedLengthOutputStream (this, ros, contentLen));
             }
         }
         write (rspHdrs, tmpout);
         this.rspContentLen = contentLen;
         tmpout.flush() ;
         tmpout = null;
         sentHeaders = true;
         if (noContentToSend) {
             WriteFinishedEvent e = new WriteFinishedEvent (this);
             server.addEvent (e);
             closed = true;
         }
         server.logReply (rCode, req.requestLine(), null);
     }

     void write (Headers map, OutputStream os) throws IOException {
         Set<Map.Entry<String,List<String>>> entries = map.entrySet();
         for (Map.Entry<String,List<String>> entry : entries) {
             String key = entry.getKey();
             byte[] buf;
             List<String> values = entry.getValue();
             for (String val : values) {
                 int i = key.length();
                 buf = bytes (key, 2);
                 buf[i++] = ':';
                 buf[i++] = ' ';
                 os.write (buf, 0, i);
                 buf = bytes (val, 2);
                 i = val.length();
                 buf[i++] = '\r';
                 buf[i++] = '\n';
                 os.write (buf, 0, i);
             }
         }
         os.write ('\r');
         os.write ('\n');
     }

     private byte[] rspbuf = new byte [128]; // used by bytes()

     /**
      * convert string to byte[], using rspbuf
      * Make sure that at least "extra" bytes are free at end
      * of rspbuf. Reallocate rspbuf if not big enough.
      * caller must check return value to see if rspbuf moved
      */
     private byte[] bytes (String s, int extra) {
         int slen = s.length();
         if (slen+extra > rspbuf.length) {
             int diff = slen + extra - rspbuf.length;
             rspbuf = new byte [2* (rspbuf.length + diff)];
         }
         char c[] = s.toCharArray();
         for (int i=0; i<c.length; i++) {
             rspbuf[i] = (byte)c[i];
         }
         return rspbuf;
     }

     public InetSocketAddress getRemoteAddress (){
         Socket s = connection.getChannel().socket();
         InetAddress ia = s.getInetAddress();
         int port = s.getPort();
         return new InetSocketAddress (ia, port);
     }

     public InetSocketAddress getLocalAddress (){
         Socket s = connection.getChannel().socket();
         InetAddress ia = s.getLocalAddress();
         int port = s.getLocalPort();
         return new InetSocketAddress (ia, port);
     }

     public String getProtocol (){
         String reqline = req.requestLine();
         int index = reqline.lastIndexOf (' ');
         return reqline.substring (index+1);
     }

     public SSLSession getSSLSession () {
         SSLEngine e = connection.getSSLEngine();
         if (e == null) {
             return null;
         }
         return e.getSession();
     }

     public Object getAttribute (String name) {
         if (name == null) {
             throw new NullPointerException ("null name parameter");
         }
         if (attributes == null) {
             attributes = getHttpContext().getAttributes();
         }
         return attributes.get (name);
     }

     public void setAttribute (String name, Object value) {
         if (name == null) {
             throw new NullPointerException ("null name parameter");
         }
         if (attributes == null) {
             attributes = getHttpContext().getAttributes();
         }
         attributes.put (name, value);
     }

     public void setStreams (InputStream i, OutputStream o) {
         assert uis != null;
         if (i != null) {
             uis = i;
         }
         if (o != null) {
             uos = o;
         }
     }

     /**
      * PP
      */
     HttpConnection getConnection () {
         return connection;
     }

     ServerImpl getServerImpl () {
         return getHttpContext().getServerImpl();
     }

     public HttpPrincipal getPrincipal () {
         return principal;
     }

     void setPrincipal (HttpPrincipal principal) {
         this.principal = principal;
     }

     static ExchangeImpl get (HttpExchange t) {
         if (t instanceof HttpExchangeImpl) {
             return ((HttpExchangeImpl)t).getExchangeImpl();
         } else {
             assert t instanceof HttpsExchangeImpl;
             return ((HttpsExchangeImpl)t).getExchangeImpl();
         }
     }
 }

 /**
  * An OutputStream which wraps another stream
  * which is supplied either at creation time, or sometime later.
  * If a caller/user tries to write to this stream before
  * the wrapped stream has been provided, then an IOException will
  * be thrown.
  */
 class PlaceholderOutputStream extends java.io.OutputStream {

     OutputStream wrapped;

     PlaceholderOutputStream (OutputStream os) {
         wrapped = os;
     }

     void setWrappedStream (OutputStream os) {
         wrapped = os;
     }

     boolean isWrapped () {
         return wrapped != null;
     }

     private void checkWrap () throws IOException {
         if (wrapped == null) {
             throw new IOException ("response headers not sent yet");
         }
     }

     public void write(int b) throws IOException {
         checkWrap();
         wrapped.write (b);
     }

     public void write(byte b[]) throws IOException {
         checkWrap();
         wrapped.write (b);
     }

     public void write(byte b[], int off, int len) throws IOException {
         checkWrap();
         wrapped.write (b, off, len);
     }

     public void flush() throws IOException {
         checkWrap();
         wrapped.flush();
     }

     public void close() throws IOException {
         checkWrap();
         wrapped.close();
     }
 }
	/*
	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.net.httpserver;

	import java.io.*;
	import java.net.*;
	import javax.net.ssl.*;
	import java.util.*;
	import java.util.logging.Logger;
	import java.text.*;
	import com.sun.net.httpserver.*;

	class ExchangeImpl {

	Headers reqHdrs, rspHdrs;
	Request req;
	String method;
	boolean writefinished;
	URI uri;
	HttpConnection connection;
	long reqContentLen;
	long rspContentLen;
	/* raw streams which access the socket directly */
	InputStream ris;
	OutputStream ros;
	Thread thread;
	/* close the underlying connection when this exchange finished */
	boolean close;
	boolean closed;
	boolean http10 = false;

	/* for formatting the Date: header */
	private static final String pattern = "EEE, dd MMM yyyy HH:mm:ss zzz";
	private static final TimeZone gmtTZ = TimeZone.getTimeZone("GMT");
	private static final ThreadLocal<DateFormat> dateFormat =
	new ThreadLocal<DateFormat>() {
	@Override protected DateFormat initialValue() {
	DateFormat df = new SimpleDateFormat(pattern, Locale.US);
	df.setTimeZone(gmtTZ);
	return df;
	}
	};

	private static final String HEAD = "HEAD";

	/* streams which take care of the HTTP protocol framing
	* and are passed up to higher layers
	*/
	InputStream uis;
	OutputStream uos;
	LeftOverInputStream uis_orig; // uis may have be a user supplied wrapper
	PlaceholderOutputStream uos_orig;

	boolean sentHeaders; /* true after response headers sent */
	Map<String,Object> attributes;
	int rcode = -1;
	HttpPrincipal principal;
	ServerImpl server;

	ExchangeImpl (
	String m, URI u, Request req, long len, HttpConnection connection
	) throws IOException {
	this.req = req;
	this.reqHdrs = req.headers();
	this.rspHdrs = new Headers();
	this.method = m;
	this.uri = u;
	this.connection = connection;
	this.reqContentLen = len;
	/* ros only used for headers, body written directly to stream */
	this.ros = req.outputStream();
	this.ris = req.inputStream();
	server = getServerImpl();
	server.startExchange();
	}

	public Headers getRequestHeaders () {
	return new UnmodifiableHeaders (reqHdrs);
	}

	public Headers getResponseHeaders () {
	return rspHdrs;
	}

	public URI getRequestURI () {
	return uri;
	}

	public String getRequestMethod (){
	return method;
	}

	public HttpContextImpl getHttpContext (){
	return connection.getHttpContext();
	}

	private boolean isHeadRequest() {
	return HEAD.equals(getRequestMethod());
	}

	public void close () {
	if (closed) {
	return;
	}
	closed = true;

	/* close the underlying connection if,
	* a) the streams not set up yet, no response can be sent, or
	* b) if the wrapper output stream is not set up, or
	* c) if the close of the input/outpu stream fails
	*/
	try {
	if (uis_orig == null \|\| uos == null) {
	connection.close();
	return;
	}
	if (!uos_orig.isWrapped()) {
	connection.close();
	return;
	}
	if (!uis_orig.isClosed()) {
	uis_orig.close();
	}
	uos.close();
	} catch (IOException e) {
	connection.close();
	}
	}

	public InputStream getRequestBody () {
	if (uis != null) {
	return uis;
	}
	if (reqContentLen == -1L) {
	uis_orig = new ChunkedInputStream (this, ris);
	uis = uis_orig;
	} else {
	uis_orig = new FixedLengthInputStream (this, ris, reqContentLen);
	uis = uis_orig;
	}
	return uis;
	}

	LeftOverInputStream getOriginalInputStream () {
	return uis_orig;
	}

	public int getResponseCode () {
	return rcode;
	}

	public OutputStream getResponseBody () {
	/* TODO. Change spec to remove restriction below. Filters
	* cannot work with this restriction
	*
	* if (!sentHeaders) {
	* throw new IllegalStateException ("headers not sent");
	* }
	*/
	if (uos == null) {
	uos_orig = new PlaceholderOutputStream (null);
	uos = uos_orig;
	}
	return uos;
	}


	/* returns the place holder stream, which is the stream
	* returned from the 1st call to getResponseBody()
	* The "real" ouputstream is then placed inside this
	*/
	PlaceholderOutputStream getPlaceholderResponseBody () {
	getResponseBody();
	return uos_orig;
	}

	public void sendResponseHeaders (int rCode, long contentLen)
	throws IOException
	{
	if (sentHeaders) {
	throw new IOException ("headers already sent");
	}
	this.rcode = rCode;
	String statusLine = "HTTP/1.1 "+rCode+Code.msg(rCode)+"\r\n";
	OutputStream tmpout = new BufferedOutputStream (ros);
	PlaceholderOutputStream o = getPlaceholderResponseBody();
	tmpout.write (bytes(statusLine, 0), 0, statusLine.length());
	boolean noContentToSend = false; // assume there is content
	rspHdrs.set ("Date", dateFormat.get().format (new Date()));

	/* check for response type that is not allowed to send a body */

	if ((rCode>=100 && rCode <200) /* informational */
	\|\|(rCode == 204) /* no content */
	\|\|(rCode == 304)) /* not modified */
	{
	if (contentLen != -1) {
	Logger logger = server.getLogger();
	String msg = "sendResponseHeaders: rCode = "+ rCode
	+ ": forcing contentLen = -1";
	logger.warning (msg);
	}
	contentLen = -1;
	}

	if (isHeadRequest()) {
	/* HEAD requests should not set a content length by passing it
	* through this API, but should instead manually set the required
	* headers.*/
	if (contentLen >= 0) {
	final Logger logger = server.getLogger();
	String msg =
	"sendResponseHeaders: being invoked with a content length for a HEAD request";
	logger.warning (msg);
	}
	noContentToSend = true;
	contentLen = 0;
	} else { /* not a HEAD request */
	if (contentLen == 0) {
	if (http10) {
	o.setWrappedStream (new UndefLengthOutputStream (this, ros));
	close = true;
	} else {
	rspHdrs.set ("Transfer-encoding", "chunked");
	o.setWrappedStream (new ChunkedOutputStream (this, ros));
	}
	} else {
	if (contentLen == -1) {
	noContentToSend = true;
	contentLen = 0;
	}
	rspHdrs.set("Content-length", Long.toString(contentLen));
	o.setWrappedStream (new FixedLengthOutputStream (this, ros, contentLen));
	}
	}
	write (rspHdrs, tmpout);
	this.rspContentLen = contentLen;
	tmpout.flush() ;
	tmpout = null;
	sentHeaders = true;
	if (noContentToSend) {
	WriteFinishedEvent e = new WriteFinishedEvent (this);
	server.addEvent (e);
	closed = true;
	}
	server.logReply (rCode, req.requestLine(), null);
	}

	void write (Headers map, OutputStream os) throws IOException {
	Set<Map.Entry<String,List<String>>> entries = map.entrySet();
	for (Map.Entry<String,List<String>> entry : entries) {
	String key = entry.getKey();
	byte[] buf;
	List<String> values = entry.getValue();
	for (String val : values) {
	int i = key.length();
	buf = bytes (key, 2);
	buf[i++] = ':';
	buf[i++] = ' ';
	os.write (buf, 0, i);
	buf = bytes (val, 2);
	i = val.length();
	buf[i++] = '\r';
	buf[i++] = '\n';
	os.write (buf, 0, i);
	}
	}
	os.write ('\r');
	os.write ('\n');
	}

	private byte[] rspbuf = new byte [128]; // used by bytes()

	/**
	* convert string to byte[], using rspbuf
	* Make sure that at least "extra" bytes are free at end
	* of rspbuf. Reallocate rspbuf if not big enough.
	* caller must check return value to see if rspbuf moved
	*/
	private byte[] bytes (String s, int extra) {
	int slen = s.length();
	if (slen+extra > rspbuf.length) {
	int diff = slen + extra - rspbuf.length;
	rspbuf = new byte [2* (rspbuf.length + diff)];
	}
	char c[] = s.toCharArray();
	for (int i=0; i<c.length; i++) {
	rspbuf[i] = (byte)c[i];
	}
	return rspbuf;
	}

	public InetSocketAddress getRemoteAddress (){
	Socket s = connection.getChannel().socket();
	InetAddress ia = s.getInetAddress();
	int port = s.getPort();
	return new InetSocketAddress (ia, port);
	}

	public InetSocketAddress getLocalAddress (){
	Socket s = connection.getChannel().socket();
	InetAddress ia = s.getLocalAddress();
	int port = s.getLocalPort();
	return new InetSocketAddress (ia, port);
	}

	public String getProtocol (){
	String reqline = req.requestLine();
	int index = reqline.lastIndexOf (' ');
	return reqline.substring (index+1);
	}

	public SSLSession getSSLSession () {
	SSLEngine e = connection.getSSLEngine();
	if (e == null) {
	return null;
	}
	return e.getSession();
	}

	public Object getAttribute (String name) {
	if (name == null) {
	throw new NullPointerException ("null name parameter");
	}
	if (attributes == null) {
	attributes = getHttpContext().getAttributes();
	}
	return attributes.get (name);
	}

	public void setAttribute (String name, Object value) {
	if (name == null) {
	throw new NullPointerException ("null name parameter");
	}
	if (attributes == null) {
	attributes = getHttpContext().getAttributes();
	}
	attributes.put (name, value);
	}

	public void setStreams (InputStream i, OutputStream o) {
	assert uis != null;
	if (i != null) {
	uis = i;
	}
	if (o != null) {
	uos = o;
	}
	}

	/**
	* PP
	*/
	HttpConnection getConnection () {
	return connection;
	}

	ServerImpl getServerImpl () {
	return getHttpContext().getServerImpl();
	}

	public HttpPrincipal getPrincipal () {
	return principal;
	}

	void setPrincipal (HttpPrincipal principal) {
	this.principal = principal;
	}

	static ExchangeImpl get (HttpExchange t) {
	if (t instanceof HttpExchangeImpl) {
	return ((HttpExchangeImpl)t).getExchangeImpl();
	} else {
	assert t instanceof HttpsExchangeImpl;
	return ((HttpsExchangeImpl)t).getExchangeImpl();
	}
	}
	}

	/**
	* An OutputStream which wraps another stream
	* which is supplied either at creation time, or sometime later.
	* If a caller/user tries to write to this stream before
	* the wrapped stream has been provided, then an IOException will
	* be thrown.
	*/
	class PlaceholderOutputStream extends java.io.OutputStream {

	OutputStream wrapped;

	PlaceholderOutputStream (OutputStream os) {
	wrapped = os;
	}

	void setWrappedStream (OutputStream os) {
	wrapped = os;
	}

	boolean isWrapped () {
	return wrapped != null;
	}

	private void checkWrap () throws IOException {
	if (wrapped == null) {
	throw new IOException ("response headers not sent yet");
	}
	}

	public void write(int b) throws IOException {
	checkWrap();
	wrapped.write (b);
	}

	public void write(byte b[]) throws IOException {
	checkWrap();
	wrapped.write (b);
	}

	public void write(byte b[], int off, int len) throws IOException {
	checkWrap();
	wrapped.write (b, off, len);
	}

	public void flush() throws IOException {
	checkWrap();
	wrapped.flush();
	}

	public void close() throws IOException {
	checkWrap();
	wrapped.close();
	}
	}