modules/tomcat-lite/java/org/apache/tomcat/lite/http/HttpMessage.java - tomcat80 - Git at Google

 /*
  */
 package org.apache.tomcat.lite.http;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintWriter;
 import java.io.UnsupportedEncodingException;
 import java.io.Writer;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Locale;
 import java.util.TimeZone;

 import org.apache.tomcat.lite.http.HttpChannel.RequestCompleted;
 import org.apache.tomcat.lite.http.HttpConnector.HttpConnection;
 import org.apache.tomcat.lite.io.BBuffer;
 import org.apache.tomcat.lite.io.BufferedIOReader;
 import org.apache.tomcat.lite.io.CBuffer;
 import org.apache.tomcat.lite.io.FastHttpDateFormat;
 import org.apache.tomcat.lite.io.IOBuffer;
 import org.apache.tomcat.lite.io.IOInputStream;
 import org.apache.tomcat.lite.io.IOOutputStream;
 import org.apache.tomcat.lite.io.IOReader;
 import org.apache.tomcat.lite.io.IOWriter;
 import org.apache.tomcat.lite.io.UrlEncoding;


 /**
  * Basic Http request or response message.
  *
  * Because the HttpChannel can be used for both client and
  * server, and to make proxy and other code simpler - the request
  * and response are represented by the same class.
  *
  * @author Costin Manolache
  */
 public abstract class HttpMessage {

     public static enum State {
         HEAD,
         BODY_DATA,
         DONE
     }

     /**
      * Raw, off-the-wire message.
      */
     public static class HttpMessageBytes {
         BBuffer head1 = BBuffer.wrapper();
         BBuffer head2 = BBuffer.wrapper();
         BBuffer proto = BBuffer.wrapper();

         BBuffer query = BBuffer.wrapper();

         List<BBuffer> headerNames = new ArrayList<BBuffer>();
         List<BBuffer> headerValues  = new ArrayList<BBuffer>();

         int headerCount;

         public BBuffer status() {
             return head1;
         }

         public BBuffer method() {
             return head1;
         }

         public BBuffer url() {
             return head2;
         }

         public BBuffer query() {
             return query;
         }

         public BBuffer protocol() {
             return proto;
         }

         public BBuffer message() {
             return head2;
         }

         public int addHeader() {
             if (headerCount >= headerNames.size()) {
                 // make space for the new header.
                 headerNames.add(BBuffer.wrapper());
                 headerValues.add(BBuffer.wrapper());
             }
             return headerCount++;
         }

         public BBuffer getHeaderName(int i) {
             if (i >= headerNames.size()) {
                 return null;
             }
             return headerNames.get(i);
         }

         public BBuffer getHeaderValue(int i) {
             if (i >= headerValues.size()) {
                 return null;
             }
             return headerValues.get(i);
         }

         public void recycle() {
             head1.recycle();
             head2.recycle();
             proto.recycle();
             query.recycle();
             headerCount = 0;
             for (int i = 0; i < headerCount; i++) {
                 headerNames.get(i).recycle();
                 headerValues.get(i).recycle();
             }
         }
     }

     protected static final TimeZone GMT_ZONE = TimeZone.getTimeZone("GMT");

     private HttpMessageBytes msgBytes = new HttpMessageBytes();

     protected HttpMessage.State state = HttpMessage.State.HEAD;

     protected HttpChannel httpCh;

     protected MultiMap headers = new MultiMap().insensitive();

     protected CBuffer protoMB;

     // Cookies
     protected boolean cookiesParsed = false;

     // TODO: cookies parsed when headers are added !
     protected ArrayList<ServerCookie> cookies;
     protected ArrayList<ServerCookie> cookiesCache;

     protected UrlEncoding urlDecoder = new UrlEncoding();
     protected String charEncoding;

     IOReader reader;
     BufferedIOReader bufferedReader;
     HttpWriter writer;
     IOWriter conv;

     IOOutputStream out;
     private IOInputStream in;

     boolean commited;

     protected IOBuffer body;

     long contentLength = -2;
     boolean chunked;

     /**
      * The set of SimpleDateFormat formats to use in getDateHeader().
      *
      * Notice that because SimpleDateFormat is not thread-safe, we can't
      * declare formats[] as a static variable.
      */
     protected SimpleDateFormat formats[] = null;


     BBuffer clBuffer = BBuffer.allocate(64);

     public HttpMessage(HttpChannel httpCh) {
         this.httpCh = httpCh;

         out = new IOOutputStream(httpCh.getOut(), httpCh);
         conv = new IOWriter(httpCh);
         writer = new HttpWriter(this, out, conv);

         in = new IOInputStream(httpCh, httpCh.getIOTimeout());

         reader = new IOReader(httpCh.getIn());
         bufferedReader = new BufferedIOReader(reader);

         cookies = new ArrayList<ServerCookie>();
         cookiesCache = new ArrayList<ServerCookie>();
         protoMB = CBuffer.newInstance();
     }

     public void addHeader(String name, String value) {
         getMimeHeaders().addValue(name).set(value);
     }

     public void setHeader(String name, String value) {
         getMimeHeaders().setValue(name).set(value);
     }

     public void setMimeHeaders(MultiMap resHeaders) {
         this.headers = resHeaders;
     }

     public String getHeader(String name) {
         CBuffer cb = headers.getHeader(name);
         return (cb == null) ? null : cb.toString();
     }

     public MultiMap getMimeHeaders() {
         return headers;
     }

     /**
      * Return the value of the specified date header, if any; otherwise
      * return -1.
      *
      * @param name Name of the requested date header
      *
      * @exception IllegalArgumentException if the specified header value
      *  cannot be converted to a date
      */
     public long getDateHeader(String name) {

         String value = getHeader(name);
         if (value == null)
             return (-1L);
         if (formats == null) {
             formats = new SimpleDateFormat[] {
                 new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US),
                 new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss zzz", Locale.US),
                 new SimpleDateFormat("EEE MMMM d HH:mm:ss yyyy", Locale.US)
             };
             formats[0].setTimeZone(GMT_ZONE);
             formats[1].setTimeZone(GMT_ZONE);
             formats[2].setTimeZone(GMT_ZONE);
         }

         // Attempt to convert the date header in a variety of formats
         long result = FastHttpDateFormat.parseDate(value, formats);
         if (result != (-1L)) {
             return result;
         }
         throw new IllegalArgumentException(value);

     }


     public Collection<String> getHeaderNames() {

         MultiMap headers = getMimeHeaders();
         int n = headers.size();
         ArrayList<String> result = new ArrayList<String>();
         for (int i = 0; i < n; i++) {
             result.add(headers.getName(i).toString());
         }
         return result;
     }

     public boolean containsHeader(String name) {
         return headers.getHeader(name) != null;
     }

     public void setContentLength(long len) {
         contentLength = len;
         clBuffer.setLong(len);
         setCLHeader();
     }

     public void setContentLength(int len) {
         contentLength = len;
         clBuffer.setLong(len);
         setCLHeader();
     }

     private void setCLHeader() {
         MultiMap.Entry clB = headers.setEntry("content-length");
         clB.valueB = clBuffer;
     }

     public long getContentLengthLong() {
         if (contentLength == -2) {
             CBuffer clB = headers.getHeader("content-length");
             contentLength = (clB == null) ?
                     -1 : clB.getLong();
         }
         return contentLength;
     }

     public int getContentLength() {
         long length = getContentLengthLong();

         if (length < Integer.MAX_VALUE) {
             return (int) length;
         }
         return -1;
     }

     public String getContentType() {
         CBuffer contentTypeMB = headers.getHeader("content-type");
         if (contentTypeMB == null) {
             return null;
         }
         return contentTypeMB.toString();
     }

     public void setContentType(String contentType) {
         CBuffer clB = getMimeHeaders().getHeader("content-type");
         if (clB == null) {
             setHeader("Content-Type", contentType);
         } else {
             clB.set(contentType);
         }
     }

     /**
      * Get the character encoding used for this request.
      * Need a field because it can be overriden. Used to construct the
      * Reader.
      */
     public String getCharacterEncoding() {
         if (charEncoding != null)
             return charEncoding;

         charEncoding = ContentType.getCharsetFromContentType(getContentType());
         return charEncoding;
     }

     private static final String DEFAULT_ENCODING = "ISO-8859-1";

     public String getEncoding() {
         String charEncoding = getCharacterEncoding();
         if (charEncoding == null) {
             return DEFAULT_ENCODING;
         } else {
             return charEncoding;
         }
     }

     public void setCharacterEncoding(String enc)
             throws UnsupportedEncodingException {
         this.charEncoding = enc;
     }


     public void recycle() {
         commited = false;
         headers.recycle();
         protoMB.set("HTTP/1.1");
         for (int i = 0; i < cookies.size(); i++) {
             cookies.get(i).recycle();
         }
         cookies.clear();
         charEncoding = null;
         bufferedReader.recycle();

         writer.recycle();
         conv.recycle();

         contentLength = -2;
         chunked = false;
         clBuffer.recycle();
         state = State.HEAD;
         cookiesParsed = false;
         getMsgBytes().recycle();

     }


     public String getProtocol() {
         return protoMB.toString();
     }

     public void setProtocol(String proto) {
         protoMB.set(proto);
     }

     public CBuffer protocol() {
         return protoMB;
     }

     public ServerCookie getCookie(String name) {
         for (ServerCookie sc: getServerCookies()) {
             if (sc.getName().equalsIgnoreCase(name)) {
                 return sc;
             }
         }
         return null;
     }

     public List<ServerCookie> getServerCookies() {
         if (!cookiesParsed) {
             cookiesParsed = true;
             ServerCookie.processCookies(cookies, cookiesCache, getMsgBytes());
         }
         return cookies;
     }

     public UrlEncoding getURLDecoder() {
         return urlDecoder;
     }

     public boolean isCommitted() {
         return commited;
     }

     public void setCommitted(boolean b) {
         commited = b;
     }

     public HttpChannel getHttpChannel() {
         return httpCh;
     }

     public IOBuffer getBody() {
         return body;
     }

     void setBody(IOBuffer body) {
         this.body = body;
     }

     public void flush() throws IOException {
         httpCh.startSending();
     }

     // not servlet input stream
     public IOInputStream getBodyInputStream() {
         return in;
     }

     public InputStream getInputStream() {
         return in;
     }

     public IOOutputStream getOutputStream() {
         return out;
     }

     public IOOutputStream getBodyOutputStream() {
         return out;
     }

     public IOReader getBodyReader() throws IOException {
         reader.setEncoding(getCharacterEncoding());
         return reader;
     }

     public BBuffer readAll(BBuffer chunk, long to) throws IOException {
         return httpCh.readAll(chunk, to);
     }

     public BBuffer readAll() throws IOException {
         return httpCh.readAll(null, httpCh.ioTimeout);
     }

     /**
      * We're done with this object, it can be recycled.
      * Any use after this should throw exception or affect an
      *  unrelated request.
      */
     public void release() throws IOException {
         httpCh.release();
     }

     public void setCompletedCallback(RequestCompleted doneAllCallback) throws IOException {
         httpCh.setCompletedCallback(doneAllCallback);
     }

     public void setReadTimeout(long to) {
         reader.setTimeout(to);
     }

     /**
      * Returns a buffered reader.
      */
     public BufferedReader getReader() throws IOException {
         reader.setEncoding(getCharacterEncoding());
         return bufferedReader;
     }

     public PrintWriter getWriter() {
         return new PrintWriter(getBodyWriter());
     }

     public HttpWriter getBodyWriter() {
         conv.setEncoding(getCharacterEncoding());
         return writer;
     }


     protected void processMimeHeaders() {
         for (int idx = 0; idx < getMsgBytes().headerCount; idx++) {
             BBuffer nameBuf = getMsgBytes().getHeaderName(idx);
             BBuffer valBuf = getMsgBytes().getHeaderValue(idx);

             MultiMap.Entry header = headers.addEntry(nameBuf);
             header.valueB = valBuf;
         }
     }


     protected abstract void processReceivedHeaders() throws IOException;

     public abstract boolean hasBody();

     public HttpMessageBytes getMsgBytes() {
         // TODO: serialize if not set
         return msgBytes;
     }

 }
	/*
	*/
	package org.apache.tomcat.lite.http;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.PrintWriter;
	import java.io.UnsupportedEncodingException;
	import java.io.Writer;
	import java.text.SimpleDateFormat;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import java.util.Locale;
	import java.util.TimeZone;

	import org.apache.tomcat.lite.http.HttpChannel.RequestCompleted;
	import org.apache.tomcat.lite.http.HttpConnector.HttpConnection;
	import org.apache.tomcat.lite.io.BBuffer;
	import org.apache.tomcat.lite.io.BufferedIOReader;
	import org.apache.tomcat.lite.io.CBuffer;
	import org.apache.tomcat.lite.io.FastHttpDateFormat;
	import org.apache.tomcat.lite.io.IOBuffer;
	import org.apache.tomcat.lite.io.IOInputStream;
	import org.apache.tomcat.lite.io.IOOutputStream;
	import org.apache.tomcat.lite.io.IOReader;
	import org.apache.tomcat.lite.io.IOWriter;
	import org.apache.tomcat.lite.io.UrlEncoding;


	/**
	* Basic Http request or response message.
	*
	* Because the HttpChannel can be used for both client and
	* server, and to make proxy and other code simpler - the request
	* and response are represented by the same class.
	*
	* @author Costin Manolache
	*/
	public abstract class HttpMessage {

	public static enum State {
	HEAD,
	BODY_DATA,
	DONE
	}

	/**
	* Raw, off-the-wire message.
	*/
	public static class HttpMessageBytes {
	BBuffer head1 = BBuffer.wrapper();
	BBuffer head2 = BBuffer.wrapper();
	BBuffer proto = BBuffer.wrapper();

	BBuffer query = BBuffer.wrapper();

	List<BBuffer> headerNames = new ArrayList<BBuffer>();
	List<BBuffer> headerValues = new ArrayList<BBuffer>();

	int headerCount;

	public BBuffer status() {
	return head1;
	}

	public BBuffer method() {
	return head1;
	}

	public BBuffer url() {
	return head2;
	}

	public BBuffer query() {
	return query;
	}

	public BBuffer protocol() {
	return proto;
	}

	public BBuffer message() {
	return head2;
	}

	public int addHeader() {
	if (headerCount >= headerNames.size()) {
	// make space for the new header.
	headerNames.add(BBuffer.wrapper());
	headerValues.add(BBuffer.wrapper());
	}
	return headerCount++;
	}

	public BBuffer getHeaderName(int i) {
	if (i >= headerNames.size()) {
	return null;
	}
	return headerNames.get(i);
	}

	public BBuffer getHeaderValue(int i) {
	if (i >= headerValues.size()) {
	return null;
	}
	return headerValues.get(i);
	}

	public void recycle() {
	head1.recycle();
	head2.recycle();
	proto.recycle();
	query.recycle();
	headerCount = 0;
	for (int i = 0; i < headerCount; i++) {
	headerNames.get(i).recycle();
	headerValues.get(i).recycle();
	}
	}
	}

	protected static final TimeZone GMT_ZONE = TimeZone.getTimeZone("GMT");

	private HttpMessageBytes msgBytes = new HttpMessageBytes();

	protected HttpMessage.State state = HttpMessage.State.HEAD;

	protected HttpChannel httpCh;

	protected MultiMap headers = new MultiMap().insensitive();

	protected CBuffer protoMB;

	// Cookies
	protected boolean cookiesParsed = false;

	// TODO: cookies parsed when headers are added !
	protected ArrayList<ServerCookie> cookies;
	protected ArrayList<ServerCookie> cookiesCache;

	protected UrlEncoding urlDecoder = new UrlEncoding();
	protected String charEncoding;

	IOReader reader;
	BufferedIOReader bufferedReader;
	HttpWriter writer;
	IOWriter conv;

	IOOutputStream out;
	private IOInputStream in;

	boolean commited;

	protected IOBuffer body;

	long contentLength = -2;
	boolean chunked;

	/**
	* The set of SimpleDateFormat formats to use in getDateHeader().
	*
	* Notice that because SimpleDateFormat is not thread-safe, we can't
	* declare formats[] as a static variable.
	*/
	protected SimpleDateFormat formats[] = null;


	BBuffer clBuffer = BBuffer.allocate(64);

	public HttpMessage(HttpChannel httpCh) {
	this.httpCh = httpCh;

	out = new IOOutputStream(httpCh.getOut(), httpCh);
	conv = new IOWriter(httpCh);
	writer = new HttpWriter(this, out, conv);

	in = new IOInputStream(httpCh, httpCh.getIOTimeout());

	reader = new IOReader(httpCh.getIn());
	bufferedReader = new BufferedIOReader(reader);

	cookies = new ArrayList<ServerCookie>();
	cookiesCache = new ArrayList<ServerCookie>();
	protoMB = CBuffer.newInstance();
	}

	public void addHeader(String name, String value) {
	getMimeHeaders().addValue(name).set(value);
	}

	public void setHeader(String name, String value) {
	getMimeHeaders().setValue(name).set(value);
	}

	public void setMimeHeaders(MultiMap resHeaders) {
	this.headers = resHeaders;
	}

	public String getHeader(String name) {
	CBuffer cb = headers.getHeader(name);
	return (cb == null) ? null : cb.toString();
	}

	public MultiMap getMimeHeaders() {
	return headers;
	}

	/**
	* Return the value of the specified date header, if any; otherwise
	* return -1.
	*
	* @param name Name of the requested date header
	*
	* @exception IllegalArgumentException if the specified header value
	* cannot be converted to a date
	*/
	public long getDateHeader(String name) {

	String value = getHeader(name);
	if (value == null)
	return (-1L);
	if (formats == null) {
	formats = new SimpleDateFormat[] {
	new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US),
	new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss zzz", Locale.US),
	new SimpleDateFormat("EEE MMMM d HH:mm:ss yyyy", Locale.US)
	};
	formats[0].setTimeZone(GMT_ZONE);
	formats[1].setTimeZone(GMT_ZONE);
	formats[2].setTimeZone(GMT_ZONE);
	}

	// Attempt to convert the date header in a variety of formats
	long result = FastHttpDateFormat.parseDate(value, formats);
	if (result != (-1L)) {
	return result;
	}
	throw new IllegalArgumentException(value);

	}


	public Collection<String> getHeaderNames() {

	MultiMap headers = getMimeHeaders();
	int n = headers.size();
	ArrayList<String> result = new ArrayList<String>();
	for (int i = 0; i < n; i++) {
	result.add(headers.getName(i).toString());
	}
	return result;
	}

	public boolean containsHeader(String name) {
	return headers.getHeader(name) != null;
	}

	public void setContentLength(long len) {
	contentLength = len;
	clBuffer.setLong(len);
	setCLHeader();
	}

	public void setContentLength(int len) {
	contentLength = len;
	clBuffer.setLong(len);
	setCLHeader();
	}

	private void setCLHeader() {
	MultiMap.Entry clB = headers.setEntry("content-length");
	clB.valueB = clBuffer;
	}

	public long getContentLengthLong() {
	if (contentLength == -2) {
	CBuffer clB = headers.getHeader("content-length");
	contentLength = (clB == null) ?
	-1 : clB.getLong();
	}
	return contentLength;
	}

	public int getContentLength() {
	long length = getContentLengthLong();

	if (length < Integer.MAX_VALUE) {
	return (int) length;
	}
	return -1;
	}

	public String getContentType() {
	CBuffer contentTypeMB = headers.getHeader("content-type");
	if (contentTypeMB == null) {
	return null;
	}
	return contentTypeMB.toString();
	}

	public void setContentType(String contentType) {
	CBuffer clB = getMimeHeaders().getHeader("content-type");
	if (clB == null) {
	setHeader("Content-Type", contentType);
	} else {
	clB.set(contentType);
	}
	}

	/**
	* Get the character encoding used for this request.
	* Need a field because it can be overriden. Used to construct the
	* Reader.
	*/
	public String getCharacterEncoding() {
	if (charEncoding != null)
	return charEncoding;

	charEncoding = ContentType.getCharsetFromContentType(getContentType());
	return charEncoding;
	}

	private static final String DEFAULT_ENCODING = "ISO-8859-1";

	public String getEncoding() {
	String charEncoding = getCharacterEncoding();
	if (charEncoding == null) {
	return DEFAULT_ENCODING;
	} else {
	return charEncoding;
	}
	}

	public void setCharacterEncoding(String enc)
	throws UnsupportedEncodingException {
	this.charEncoding = enc;
	}


	public void recycle() {
	commited = false;
	headers.recycle();
	protoMB.set("HTTP/1.1");
	for (int i = 0; i < cookies.size(); i++) {
	cookies.get(i).recycle();
	}
	cookies.clear();
	charEncoding = null;
	bufferedReader.recycle();

	writer.recycle();
	conv.recycle();

	contentLength = -2;
	chunked = false;
	clBuffer.recycle();
	state = State.HEAD;
	cookiesParsed = false;
	getMsgBytes().recycle();

	}


	public String getProtocol() {
	return protoMB.toString();
	}

	public void setProtocol(String proto) {
	protoMB.set(proto);
	}

	public CBuffer protocol() {
	return protoMB;
	}

	public ServerCookie getCookie(String name) {
	for (ServerCookie sc: getServerCookies()) {
	if (sc.getName().equalsIgnoreCase(name)) {
	return sc;
	}
	}
	return null;
	}

	public List<ServerCookie> getServerCookies() {
	if (!cookiesParsed) {
	cookiesParsed = true;
	ServerCookie.processCookies(cookies, cookiesCache, getMsgBytes());
	}
	return cookies;
	}

	public UrlEncoding getURLDecoder() {
	return urlDecoder;
	}

	public boolean isCommitted() {
	return commited;
	}

	public void setCommitted(boolean b) {
	commited = b;
	}

	public HttpChannel getHttpChannel() {
	return httpCh;
	}

	public IOBuffer getBody() {
	return body;
	}

	void setBody(IOBuffer body) {
	this.body = body;
	}

	public void flush() throws IOException {
	httpCh.startSending();
	}

	// not servlet input stream
	public IOInputStream getBodyInputStream() {
	return in;
	}

	public InputStream getInputStream() {
	return in;
	}

	public IOOutputStream getOutputStream() {
	return out;
	}

	public IOOutputStream getBodyOutputStream() {
	return out;
	}

	public IOReader getBodyReader() throws IOException {
	reader.setEncoding(getCharacterEncoding());
	return reader;
	}

	public BBuffer readAll(BBuffer chunk, long to) throws IOException {
	return httpCh.readAll(chunk, to);
	}

	public BBuffer readAll() throws IOException {
	return httpCh.readAll(null, httpCh.ioTimeout);
	}

	/**
	* We're done with this object, it can be recycled.
	* Any use after this should throw exception or affect an
	* unrelated request.
	*/
	public void release() throws IOException {
	httpCh.release();
	}

	public void setCompletedCallback(RequestCompleted doneAllCallback) throws IOException {
	httpCh.setCompletedCallback(doneAllCallback);
	}

	public void setReadTimeout(long to) {
	reader.setTimeout(to);
	}

	/**
	* Returns a buffered reader.
	*/
	public BufferedReader getReader() throws IOException {
	reader.setEncoding(getCharacterEncoding());
	return bufferedReader;
	}

	public PrintWriter getWriter() {
	return new PrintWriter(getBodyWriter());
	}

	public HttpWriter getBodyWriter() {
	conv.setEncoding(getCharacterEncoding());
	return writer;
	}


	protected void processMimeHeaders() {
	for (int idx = 0; idx < getMsgBytes().headerCount; idx++) {
	BBuffer nameBuf = getMsgBytes().getHeaderName(idx);
	BBuffer valBuf = getMsgBytes().getHeaderValue(idx);

	MultiMap.Entry header = headers.addEntry(nameBuf);
	header.valueB = valBuf;
	}
	}


	protected abstract void processReceivedHeaders() throws IOException;

	public abstract boolean hasBody();

	public HttpMessageBytes getMsgBytes() {
	// TODO: serialize if not set
	return msgBytes;
	}

	}