//
//  ========================================================================
//  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.server;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;

import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.continuation.ContinuationThrowable;
import org.eclipse.jetty.http.EncodedHttpURI;
import org.eclipse.jetty.http.Generator;
import org.eclipse.jetty.http.HttpBuffers;
import org.eclipse.jetty.http.HttpException;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpGenerator;
import org.eclipse.jetty.http.HttpHeaderValues;
import org.eclipse.jetty.http.HttpHeaders;
import org.eclipse.jetty.http.HttpMethods;
import org.eclipse.jetty.http.HttpParser;
import org.eclipse.jetty.http.HttpStatus;
import org.eclipse.jetty.http.HttpURI;
import org.eclipse.jetty.http.HttpVersions;
import org.eclipse.jetty.http.MimeTypes;
import org.eclipse.jetty.http.Parser;
import org.eclipse.jetty.io.AbstractConnection;
import org.eclipse.jetty.io.Buffer;
import org.eclipse.jetty.io.BufferCache.CachedBuffer;
import org.eclipse.jetty.io.Buffers;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.EofException;
import org.eclipse.jetty.io.RuntimeIOException;
import org.eclipse.jetty.io.UncheckedPrintWriter;
import org.eclipse.jetty.server.handler.ErrorHandler;
import org.eclipse.jetty.server.nio.NIOConnector;
import org.eclipse.jetty.server.ssl.SslConnector;
import org.eclipse.jetty.util.QuotedStringTokenizer;
import org.eclipse.jetty.util.StringUtil;
import org.eclipse.jetty.util.URIUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.eclipse.jetty.util.resource.Resource;

/**
 * <p>A HttpConnection represents the connection of a HTTP client to the server
 * and is created by an instance of a {@link Connector}. It's prime function is
 * to associate {@link Request} and {@link Response} instances with a {@link EndPoint}.
 * </p>
 * <p>
 * A connection is also the prime mechanism used by jetty to recycle objects without
 * pooling.  The {@link Request},  {@link Response}, {@link HttpParser}, {@link HttpGenerator}
 * and {@link HttpFields} instances are all recycled for the duraction of
 * a connection. Where appropriate, allocated buffers are also kept associated
 * with the connection via the parser and/or generator.
 * </p>
 * <p>
 * The connection state is held by 3 separate state machines: The request state, the
 * response state and the continuation state.  All three state machines must be driven
 * to completion for every request, and all three can complete in any order.
 * </p>
 * <p>
 * The HttpConnection support protocol upgrade.  If on completion of a request, the
 * response code is 101 (switch protocols), then the org.eclipse.jetty.io.Connection
 * request attribute is checked to see if there is a new Connection instance. If so,
 * the new connection is returned from {@link #handle()} and is used for future
 * handling of the underlying connection.   Note that for switching protocols that
 * don't use 101 responses (eg CONNECT), the response should be sent and then the
 * status code changed to 101 before returning from the handler.  Implementors
 * of new Connection types should be careful to extract any buffered data from
 * (HttpParser)http.getParser()).getHeaderBuffer() and
 * (HttpParser)http.getParser()).getBodyBuffer() to initialise their new connection.
 * </p>
 *
 */
public abstract class AbstractHttpConnection  extends AbstractConnection
{
	private static final Logger LOG = LoggerFactory.getLogger(AbstractHttpConnection.class);

	private static final int UNKNOWN = -2;
	private static final ThreadLocal<AbstractHttpConnection> __currentConnection = new ThreadLocal<AbstractHttpConnection>();

	private int _requests;

	protected final Connector _connector;
	protected final Server _server;
	protected final HttpURI _uri;

	protected final Parser _parser;
	protected final HttpFields _requestFields;
	protected final Request _request;
	protected volatile ServletInputStream _in;

	protected final Generator _generator;
	protected final HttpFields _responseFields;
	protected final Response _response;
	protected volatile Output _out;
	protected volatile OutputWriter _writer;
	protected volatile PrintWriter _printWriter;

	int _include;

	private Object _associatedObject; // associated object

	private int _version = UNKNOWN;

	private String _charset;
	private boolean _expect = false;
	private boolean _expect100Continue = false;
	private boolean _expect102Processing = false;
	private boolean _head = false;
	private boolean _host = false;
	private boolean _delayedHandling=false;
	private boolean _earlyEOF = false;

	/* ------------------------------------------------------------ */
	public static AbstractHttpConnection getCurrentConnection()
	{
		return __currentConnection.get();
	}

	/* ------------------------------------------------------------ */
	protected static void setCurrentConnection(AbstractHttpConnection connection)
	{
		__currentConnection.set(connection);
	}

	/* ------------------------------------------------------------ */
	public AbstractHttpConnection(Connector connector, EndPoint endpoint, Server server)
	{
		super(endpoint);
		_uri = StringUtil.__UTF8.equals(URIUtil.__CHARSET)?new HttpURI():new EncodedHttpURI(URIUtil.__CHARSET);
		_connector = connector;
		HttpBuffers ab = (HttpBuffers)_connector;
		_parser = newHttpParser(ab.getRequestBuffers(), endpoint, new RequestHandler());
		_requestFields = new HttpFields();
		_responseFields = new HttpFields();
		_request = new Request(this);
		_response = new Response(this);
		_generator = newHttpGenerator(ab.getResponseBuffers(), endpoint);
		_server = server;
	}

	/* ------------------------------------------------------------ */
	protected AbstractHttpConnection(Connector connector, EndPoint endpoint, Server server,
			Parser parser, Generator generator, Request request)
	{
		super(endpoint);

		_uri = URIUtil.__CHARSET.equals(StringUtil.__UTF8)?new HttpURI():new EncodedHttpURI(URIUtil.__CHARSET);
		_connector = connector;
		_parser = parser;
		_requestFields = new HttpFields();
		_responseFields = new HttpFields();
		_request = request;
		_response = new Response(this);
		_generator = generator;
		_server = server;
	}

	protected HttpParser newHttpParser(Buffers requestBuffers, EndPoint endpoint, HttpParser.EventHandler requestHandler)
	{
		return new HttpParser(requestBuffers, endpoint, requestHandler);
	}

	protected HttpGenerator newHttpGenerator(Buffers responseBuffers, EndPoint endPoint)
	{
		return new HttpGenerator(responseBuffers, endPoint);
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return the parser used by this connection
	 */
	public Parser getParser()
	{
		return _parser;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return the number of requests handled by this connection
	 */
	public int getRequests()
	{
		return _requests;
	}

	/* ------------------------------------------------------------ */
	public Server getServer()
	{
		return _server;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return Returns the associatedObject.
	 */
	public Object getAssociatedObject()
	{
		return _associatedObject;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @param associatedObject The associatedObject to set.
	 */
	public void setAssociatedObject(Object associatedObject)
	{
		_associatedObject = associatedObject;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return Returns the connector.
	 */
	public Connector getConnector()
	{
		return _connector;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return Returns the requestFields.
	 */
	public HttpFields getRequestFields()
	{
		return _requestFields;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return Returns the responseFields.
	 */
	public HttpFields getResponseFields()
	{
		return _responseFields;
	}

	/* ------------------------------------------------------------ */
	/**
	 * Find out if the request supports CONFIDENTIAL security.
	 * @param request the incoming HTTP request
	 * @return the result of calling {@link Connector#isConfidential(Request)}, or false
	 * if there is no connector
	 */
	public boolean isConfidential(Request request)
	{
		return _connector != null && _connector.isConfidential(request);
	}

	/* ------------------------------------------------------------ */
	/**
	 * Find out if the request supports INTEGRAL security.
	 * @param request the incoming HTTP request
	 * @return the result of calling {@link Connector#isIntegral(Request)}, or false
	 * if there is no connector
	 */
	public boolean isIntegral(Request request)
	{
		return _connector != null && _connector.isIntegral(request);
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return <code>false</code> (this method is not yet implemented)
	 */
	public boolean getResolveNames()
	{
		return _connector.getResolveNames();
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return Returns the request.
	 */
	public Request getRequest()
	{
		return _request;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return Returns the response.
	 */
	public Response getResponse()
	{
		return _response;
	}

	/* ------------------------------------------------------------ */
	/**
	 * Get the inputStream from the connection.
	 * <p>
	 * If the associated response has the Expect header set to 100 Continue,
	 * then accessing the input stream indicates that the handler/servlet
	 * is ready for the request body and thus a 100 Continue response is sent.
	 *
	 * @return The input stream for this connection.
	 * The stream will be created if it does not already exist.
	 * @throws IOException if the input stream cannot be retrieved
	 */
	public ServletInputStream getInputStream() throws IOException
	{
		// If the client is expecting 100 CONTINUE, then send it now.
		if (_expect100Continue)
		{
			// is content missing?
			if (((HttpParser)_parser).getHeaderBuffer()==null || ((HttpParser)_parser).getHeaderBuffer().length()<2)
			{
				if (_generator.isCommitted())
					throw new IllegalStateException("Committed before 100 Continues");

				((HttpGenerator)_generator).send1xx(HttpStatus.CONTINUE_100);
			}
			_expect100Continue=false;
		}

		if (_in == null)
			_in = new HttpInput(AbstractHttpConnection.this);
		return _in;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @return The output stream for this connection. The stream will be created if it does not already exist.
	 */
	public ServletOutputStream getOutputStream()
	{
		if (_out == null)
			_out = new Output();
		return _out;
	}

	/* ------------------------------------------------------------ */
	/**
	 * @param encoding the PrintWriter encoding
	 * @return A {@link PrintWriter} wrapping the {@link #getOutputStream output stream}. The writer is created if it
	 *    does not already exist.
	 */
	public PrintWriter getPrintWriter(String encoding)
	{
		getOutputStream();
		if (_writer==null)
		{
			_writer=new OutputWriter();
			if (_server.isUncheckedPrintWriter())
				_printWriter=new UncheckedPrintWriter(_writer);
			else
				_printWriter = new PrintWriter(_writer)
				{
					public void close()
					{
						synchronized (lock)
						{
							try
							{
								out.close();
							}
							catch (IOException e)
							{
								setError();
							}
						}
					}
				};
		}
		_writer.setCharacterEncoding(encoding);
		return _printWriter;
	}

	/* ------------------------------------------------------------ */
	public boolean isResponseCommitted()
	{
		return _generator.isCommitted();
	}

	/* ------------------------------------------------------------ */
	public boolean isEarlyEOF()
	{
		return _earlyEOF;
	}

	/* ------------------------------------------------------------ */
	public void reset()
	{
		_parser.reset();
		_parser.returnBuffers(); // TODO maybe only on unhandle
		_requestFields.clear();
		_request.recycle();
		_generator.reset();
		_generator.returnBuffers();// TODO maybe only on unhandle
		_responseFields.clear();
		_response.recycle();
		_uri.clear();
		_writer=null;
		_earlyEOF = false;
	}

	/* ------------------------------------------------------------ */
	protected void handleRequest() throws IOException
	{
		boolean error = false;

		String threadName=null;
		Throwable async_exception=null;
		try
		{
			if (LOG.isDebugEnabled())
			{
				threadName=Thread.currentThread().getName();
				Thread.currentThread().setName(threadName+" - "+_uri);
			}


			// Loop here to handle async request redispatches.
			// The loop is controlled by the call to async.unhandle in the
			// finally block below.  If call is from a non-blocking connector,
			// then the unhandle will return false only if an async dispatch has
			// already happened when unhandle is called.   For a blocking connector,
			// the wait for the asynchronous dispatch or timeout actually happens
			// within the call to unhandle().

			final Server server=_server;
			boolean was_continuation=_request._async.isContinuation();
			boolean handling=_request._async.handling() && server!=null && server.isRunning();
			while (handling)
			{
				_request.setHandled(false);

				String info=null;
				try
				{
					_uri.getPort();
					String path = null;

					try
					{
						path = _uri.getDecodedPath();
					}
					catch (Exception e)
					{
						LOG.warn("Failed UTF-8 decode for request path, trying ISO-8859-1");
						LOG.trace("",e);
						path = _uri.getDecodedPath(StringUtil.__ISO_8859_1);
					}

					info=URIUtil.canonicalPath(path);
					if (info==null && !_request.getMethod().equals(HttpMethods.CONNECT))
					{
						if (path==null && _uri.getScheme()!=null && _uri.getHost()!=null)
						{
							info="/";
							_request.setRequestURI("");
						}
						else
							throw new HttpException(400);
					}
					_request.setPathInfo(info);

					if (_out!=null)
						_out.reopen();

					if (_request._async.isInitial())
					{
						_request.setDispatcherType(DispatcherType.REQUEST);
						_connector.customize(_endp, _request);
						server.handle(this);
					}
					else
					{
						if (_request._async.isExpired()&&!was_continuation)
						{
							async_exception = (Throwable)_request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);
							_response.setStatus(500,async_exception==null?"Async Timeout":"Async Exception");
							_request.setAttribute(RequestDispatcher.ERROR_STATUS_CODE,new Integer(500));
							_request.setAttribute(RequestDispatcher.ERROR_MESSAGE, _response.getReason());
							_request.setDispatcherType(DispatcherType.ERROR);
						}
						else
							_request.setDispatcherType(DispatcherType.ASYNC);
						server.handleAsync(this);
					}
				}
				catch (ContinuationThrowable e)
				{
					LOG.trace("",e);
				}
				catch (EofException e)
				{
					async_exception=e;
					LOG.debug("",e);
					error=true;
					_request.setHandled(true);
					if (!_response.isCommitted())
						_generator.sendError(500, null, null, true);
				}
				catch (RuntimeIOException e)
				{
					async_exception=e;
					LOG.debug("",e);
					error=true;
					_request.setHandled(true);
				}
				catch (HttpException e)
				{
					LOG.debug("",e);
					error=true;
					_request.setHandled(true);
					_response.sendError(e.getStatus(), e.getReason());
				}
				catch (Throwable e)
				{
					async_exception=e;
					LOG.warn(String.valueOf(_uri),e);
					error=true;
					_request.setHandled(true);
					_generator.sendError(info==null?400:500, null, null, true);
					
				}
				finally
				{
					// Complete async requests 
					if (error && _request.isAsyncStarted())
						_request.getAsyncContinuation().errorComplete();
						
					was_continuation=_request._async.isContinuation();
					handling = !_request._async.unhandle() && server.isRunning() && _server!=null;
				}
			}
		}
		finally
		{
			if (threadName!=null)
				Thread.currentThread().setName(threadName);

			if (_request._async.isUncompleted())
			{
				
				_request._async.doComplete(async_exception);

				if (_expect100Continue)
				{
					LOG.debug("100 continues not sent");
					// We didn't send 100 continues, but the latest interpretation
					// of the spec (see httpbis) is that the client will either
					// send the body anyway, or close.  So we no longer need to
					// do anything special here other than make the connection not persistent
					_expect100Continue = false;
					if (!_response.isCommitted())
						_generator.setPersistent(false);
				}

				if(_endp.isOpen())
				{
					if (error)
					{
						_endp.shutdownOutput();
						_generator.setPersistent(false);
						if (!_generator.isComplete())
							_response.complete();
					}
					else
					{
						if (!_response.isCommitted() && !_request.isHandled())
							_response.sendError(HttpServletResponse.SC_NOT_FOUND);
						_response.complete();
						if (_generator.isPersistent())
							_connector.persist(_endp);
					}
				}
				else
				{
					_response.complete();
				}

				_request.setHandled(true);
			}
		}
	}

	/* ------------------------------------------------------------ */
	public abstract Connection handle() throws IOException;

	/* ------------------------------------------------------------ */
	public void commitResponse(boolean last) throws IOException
	{
		if (!_generator.isCommitted())
		{
			_generator.setResponse(_response.getStatus(), _response.getReason());
			try
			{
				// If the client was expecting 100 continues, but we sent something
				// else, then we need to close the connection
				if (_expect100Continue && _response.getStatus()!=100)
					_generator.setPersistent(false);
				_generator.completeHeader(_responseFields, last);
			}
			catch(RuntimeException e)
			{
				LOG.warn("header full: " + e);

				_response.reset();
				_generator.reset();
				_generator.setResponse(HttpStatus.INTERNAL_SERVER_ERROR_500,null);
				_generator.completeHeader(_responseFields,Generator.LAST);
				_generator.complete();
				throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR_500);
			}

		}
		if (last)
			_generator.complete();
	}

	/* ------------------------------------------------------------ */
	public void completeResponse() throws IOException
	{
		if (!_generator.isCommitted())
		{
			_generator.setResponse(_response.getStatus(), _response.getReason());
			try
			{
				_generator.completeHeader(_responseFields, Generator.LAST);
			}
			catch(RuntimeException e)
			{
				LOG.warn("header full: "+e);
				LOG.debug("",e);

				_response.reset();
				_generator.reset();
				_generator.setResponse(HttpStatus.INTERNAL_SERVER_ERROR_500,null);
				_generator.completeHeader(_responseFields,Generator.LAST);
				_generator.complete();
				throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR_500);
			}
		}

		_generator.complete();
	}

	/* ------------------------------------------------------------ */
	public void flushResponse() throws IOException
	{
		try
		{
			commitResponse(Generator.MORE);
			_generator.flushBuffer();
		}
		catch(IOException e)
		{
			throw (e instanceof EofException) ? e:new EofException(e);
		}
	}

	/* ------------------------------------------------------------ */
	public Generator getGenerator()
	{
		return _generator;
	}

	/* ------------------------------------------------------------ */
	public boolean isIncluding()
	{
		return _include>0;
	}

	/* ------------------------------------------------------------ */
	public void include()
	{
		_include++;
	}

	/* ------------------------------------------------------------ */
	public void included()
	{
		_include--;
		if (_out!=null)
			_out.reopen();
	}

	/* ------------------------------------------------------------ */
	public boolean isIdle()
	{
		return _generator.isIdle() && (_parser.isIdle() || _delayedHandling);
	}

	/* ------------------------------------------------------------ */
	/**
	 * @see org.eclipse.jetty.io.Connection#isSuspended()
	 */
	public boolean isSuspended()
	{
		return _request.getAsyncContinuation().isSuspended();
	}

	/* ------------------------------------------------------------ */
	public void onClose()
	{
		LOG.debug("closed {}",this);
	}

	/* ------------------------------------------------------------ */
	public boolean isExpecting100Continues()
	{
		return _expect100Continue;
	}

	/* ------------------------------------------------------------ */
	public boolean isExpecting102Processing()
	{
		return _expect102Processing;
	}

	/* ------------------------------------------------------------ */
	public int getMaxIdleTime()
	{
		if (_connector.isLowResources() && _endp.getMaxIdleTime()==_connector.getMaxIdleTime())
			return _connector.getLowResourceMaxIdleTime();
		if (_endp.getMaxIdleTime()>0)
			return _endp.getMaxIdleTime();
		return _connector.getMaxIdleTime();
	}

	/* ------------------------------------------------------------ */
	public String toString()
	{
		return String.format("%s,g=%s,p=%s,r=%d",
				super.toString(),
				_generator,
				_parser,
				_requests);
	}

	/* ------------------------------------------------------------ */
	protected void startRequest(Buffer method, Buffer uri, Buffer version) throws IOException
	{
		uri=uri.asImmutableBuffer();

		_host = false;
		_expect = false;
		_expect100Continue=false;
		_expect102Processing=false;
		_delayedHandling=false;
		_charset=null;

		if(_request.getTimeStamp()==0)
			_request.setTimeStamp(System.currentTimeMillis());
		_request.setMethod(method.toString());

		try
		{
			_head=false;
			switch (HttpMethods.CACHE.getOrdinal(method))
			{
			  case HttpMethods.CONNECT_ORDINAL:
				  _uri.parseConnect(uri.array(), uri.getIndex(), uri.length());
				  break;

			  case HttpMethods.HEAD_ORDINAL:
				  _head=true;
				  _uri.parse(uri.array(), uri.getIndex(), uri.length());
				  break;

			  default:
				  _uri.parse(uri.array(), uri.getIndex(), uri.length());
			}

			_request.setUri(_uri);

			if (version==null)
			{
				_request.setProtocol(HttpVersions.HTTP_0_9);
				_version=HttpVersions.HTTP_0_9_ORDINAL;
			}
			else
			{
				version= HttpVersions.CACHE.get(version);
				if (version==null)
					throw new HttpException(HttpStatus.BAD_REQUEST_400,null);
				_version = HttpVersions.CACHE.getOrdinal(version);
				if (_version <= 0) _version = HttpVersions.HTTP_1_0_ORDINAL;
				_request.setProtocol(version.toString());
			}
		}
		catch (Exception e)
		{
			LOG.debug("",e);
			if (e instanceof HttpException)
				throw (HttpException)e;
			throw new HttpException(HttpStatus.BAD_REQUEST_400,null,e);
		}
	}

	/* ------------------------------------------------------------ */
	protected void parsedHeader(Buffer name, Buffer value) throws IOException
	{
		int ho = HttpHeaders.CACHE.getOrdinal(name);
		switch (ho)
		{
			case HttpHeaders.HOST_ORDINAL:
				// TODO check if host matched a host in the URI.
				_host = true;
				break;

			case HttpHeaders.EXPECT_ORDINAL:
				if (_version>=HttpVersions.HTTP_1_1_ORDINAL)
				{
					value = HttpHeaderValues.CACHE.lookup(value);
					switch(HttpHeaderValues.CACHE.getOrdinal(value))
					{
						case HttpHeaderValues.CONTINUE_ORDINAL:
							_expect100Continue=_generator instanceof HttpGenerator;
							break;

						case HttpHeaderValues.PROCESSING_ORDINAL:
							_expect102Processing=_generator instanceof HttpGenerator;
							break;

						default:
							String[] values = value.toString().split(",");
							for  (int i=0;values!=null && i<values.length;i++)
							{
								CachedBuffer cb=HttpHeaderValues.CACHE.get(values[i].trim());
								if (cb==null)
									_expect=true;
								else
								{
									switch(cb.getOrdinal())
									{
										case HttpHeaderValues.CONTINUE_ORDINAL:
											_expect100Continue=_generator instanceof HttpGenerator;
											break;
										case HttpHeaderValues.PROCESSING_ORDINAL:
											_expect102Processing=_generator instanceof HttpGenerator;
											break;
										default:
											_expect=true;
									}
								}
							}
					}
				}
				break;

			case HttpHeaders.ACCEPT_ENCODING_ORDINAL:
			case HttpHeaders.USER_AGENT_ORDINAL:
				value = HttpHeaderValues.CACHE.lookup(value);
				break;

			case HttpHeaders.CONTENT_TYPE_ORDINAL:
				value = MimeTypes.CACHE.lookup(value);
				_charset=MimeTypes.getCharsetFromContentType(value);
				break;
		}

		_requestFields.add(name, value);
	}

	/* ------------------------------------------------------------ */
	protected void headerComplete() throws IOException
	{
		// Handle idle race
		if (_endp.isOutputShutdown())
		{
			_endp.close();
			return;
		}
		
		_requests++;
		_generator.setVersion(_version);
		switch (_version)
		{
			case HttpVersions.HTTP_0_9_ORDINAL:
				break;
			case HttpVersions.HTTP_1_0_ORDINAL:
				_generator.setHead(_head);
				if (_parser.isPersistent())
				{
					_responseFields.add(HttpHeaders.CONNECTION_BUFFER, HttpHeaderValues.KEEP_ALIVE_BUFFER);
					_generator.setPersistent(true);
				}
				else if (HttpMethods.CONNECT.equals(_request.getMethod()))
				{
					_generator.setPersistent(true);
					_parser.setPersistent(true);
				}
				break;

			case HttpVersions.HTTP_1_1_ORDINAL:
				_generator.setHead(_head);

				if (!_parser.isPersistent())
				{
					_responseFields.add(HttpHeaders.CONNECTION_BUFFER,HttpHeaderValues.CLOSE_BUFFER);
					_generator.setPersistent(false);
				}

				if (!_host)
				{
					LOG.debug("!host {}",this);
					_generator.setResponse(HttpStatus.BAD_REQUEST_400, null);
					_responseFields.put(HttpHeaders.CONNECTION_BUFFER, HttpHeaderValues.CLOSE_BUFFER);
					_generator.completeHeader(_responseFields, true);
					_generator.complete();
					return;
				}

				if (_expect)
				{
					LOG.debug("!expectation {}",this);
					_generator.setResponse(HttpStatus.EXPECTATION_FAILED_417, null);
					_responseFields.put(HttpHeaders.CONNECTION_BUFFER, HttpHeaderValues.CLOSE_BUFFER);
					_generator.completeHeader(_responseFields, true);
					_generator.complete();
					return;
				}

				break;
			default:
		}

		if(_charset!=null)
			_request.setCharacterEncodingUnchecked(_charset);

		// Either handle now or wait for first content
		if ((((HttpParser)_parser).getContentLength()<=0 && !((HttpParser)_parser).isChunking())||_expect100Continue)
			handleRequest();
		else
			_delayedHandling=true;
	}

	/* ------------------------------------------------------------ */
	protected void content(Buffer buffer) throws IOException
	{
		if (_delayedHandling)
		{
			_delayedHandling=false;
			handleRequest();
		}
	}

	/* ------------------------------------------------------------ */
	public void messageComplete(long contentLength) throws IOException
	{
		if (_delayedHandling)
		{
			_delayedHandling=false;
			handleRequest();
		}
	}

	/* ------------------------------------------------------------ */
	public void earlyEOF()
	{
		_earlyEOF = true;
	}

	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	private class RequestHandler extends HttpParser.EventHandler
	{
		/*
		 *
		 * @see org.eclipse.jetty.server.server.HttpParser.EventHandler#startRequest(org.eclipse.io.Buffer,
		 *      org.eclipse.io.Buffer, org.eclipse.io.Buffer)
		 */
		@Override
		public void startRequest(Buffer method, Buffer uri, Buffer version) throws IOException
		{
			AbstractHttpConnection.this.startRequest(method, uri, version);
		}

		/*
		 * @see org.eclipse.jetty.server.server.HttpParser.EventHandler#parsedHeaderValue(org.eclipse.io.Buffer)
		 */
		@Override
		public void parsedHeader(Buffer name, Buffer value) throws IOException
		{
			AbstractHttpConnection.this.parsedHeader(name, value);
		}

		/*
		 * @see org.eclipse.jetty.server.server.HttpParser.EventHandler#headerComplete()
		 */
		@Override
		public void headerComplete() throws IOException
		{
			AbstractHttpConnection.this.headerComplete();
		}

		/* ------------------------------------------------------------ */
		/*
		 * @see org.eclipse.jetty.server.server.HttpParser.EventHandler#content(int, org.eclipse.io.Buffer)
		 */
		@Override
		public void content(Buffer ref) throws IOException
		{
			AbstractHttpConnection.this.content(ref);
		}

		/* ------------------------------------------------------------ */
		/*
		 * (non-Javadoc)
		 *
		 * @see org.eclipse.jetty.server.server.HttpParser.EventHandler#messageComplete(int)
		 */
		@Override
		public void messageComplete(long contentLength) throws IOException
		{
			AbstractHttpConnection.this.messageComplete(contentLength);
		}

		/* ------------------------------------------------------------ */
		/*
		 * (non-Javadoc)
		 *
		 * @see org.eclipse.jetty.server.server.HttpParser.EventHandler#startResponse(org.eclipse.io.Buffer, int,
		 *      org.eclipse.io.Buffer)
		 */
		@Override
		public void startResponse(Buffer version, int status, Buffer reason)
		{
			if (LOG.isDebugEnabled())
				LOG.debug("Bad request!: "+version+" "+status+" "+reason);
		}

		/* ------------------------------------------------------------ */
		/*
		 * (non-Javadoc)
		 *
		 * @see org.eclipse.jetty.server.server.HttpParser.EventHandler#earlyEOF()
		 */
		@Override
		public void earlyEOF()
		{
			AbstractHttpConnection.this.earlyEOF();
		}
	}

	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	public class Output extends HttpOutput
	{
		Output()
		{
			super(AbstractHttpConnection.this);
		}

		/* ------------------------------------------------------------ */
		/*
		 * @see java.io.OutputStream#close()
		 */
		@Override
		public void close() throws IOException
		{
			if (isClosed())
				return;

			if (!isIncluding() && !super._generator.isCommitted())
				commitResponse(Generator.LAST);
			else
				flushResponse();

			super.close();
		}


		/* ------------------------------------------------------------ */
		/*
		 * @see java.io.OutputStream#flush()
		 */
		@Override
		public void flush() throws IOException
		{
			if (!super._generator.isCommitted())
				commitResponse(Generator.MORE);
			super.flush();
		}

		/* ------------------------------------------------------------ */
		/*
		 * @see javax.servlet.ServletOutputStream#print(java.lang.String)
		 */
		@Override
		public void print(String s) throws IOException
		{
			if (isClosed())
				throw new IOException("Closed");
			PrintWriter writer=getPrintWriter(null);
			writer.print(s);
		}

		/* ------------------------------------------------------------ */
		public void sendResponse(Buffer response) throws IOException
		{
			((HttpGenerator)super._generator).sendResponse(response);
		}

		/* ------------------------------------------------------------ */
		public void sendContent(Object content) throws IOException
		{
			Resource resource=null;

			if (isClosed())
				throw new IOException("Closed");

			if (super._generator.isWritten())
				throw new IllegalStateException("!empty");

			if (content instanceof Resource)
			{
				resource=(Resource)content;
				_responseFields.putDateField(HttpHeaders.LAST_MODIFIED_BUFFER, resource.lastModified());
				content=resource.getInputStream();
			}

			// Process content.
			if (content instanceof Buffer)
			{
				super._generator.addContent((Buffer) content, Generator.LAST);
				commitResponse(Generator.LAST);
			}
			else if (content instanceof InputStream)
			{
				InputStream in = (InputStream)content;

				try
				{
					int max = super._generator.prepareUncheckedAddContent();
					Buffer buffer = super._generator.getUncheckedBuffer();

					int len=buffer.readFrom(in,max);

					while (len>=0)
					{
						super._generator.completeUncheckedAddContent();
						_out.flush();

						max = super._generator.prepareUncheckedAddContent();
						buffer = super._generator.getUncheckedBuffer();
						len=buffer.readFrom(in,max);
					}
					super._generator.completeUncheckedAddContent();
					_out.flush();
				}
				finally
				{
					if (resource!=null)
						resource.release();
					else
						in.close();
				}
			}
			else
				throw new IllegalArgumentException("unknown content type?");


		}
	}

	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	public class OutputWriter extends HttpWriter
	{
		OutputWriter()
		{
			super(AbstractHttpConnection.this._out);
		}
	}


}