/FileExtraction/Java_unseen/dlitz_resin/modules/resin/src/com/caucho/server/http/AbstractHttpResponse.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.server.http;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.caucho.env.meter.CountSensor;
import com.caucho.env.meter.MeterService;
import com.caucho.server.dispatch.BadRequestException;
import com.caucho.server.session.CookieImpl;
import com.caucho.server.session.SessionImpl;
import com.caucho.server.webapp.WebApp;
import com.caucho.util.CaseInsensitiveIntMap;
import com.caucho.util.CharBuffer;
import com.caucho.util.L10N;
import com.caucho.util.QDate;
import com.caucho.vfs.ClientDisconnectException;
import com.caucho.vfs.TempBuffer;

/**
 * Encapsulates the servlet response, controlling response headers and the
 * response stream.
 */
abstract public class AbstractHttpResponse {
  private static final Logger log
    = Logger.getLogger(AbstractHttpResponse.class.getName());
  private static final L10N L = new L10N(AbstractHttpResponse.class);
  
  private static final CountSensor _statusXxxSensor
    = MeterService.createCountMeter("Resin|Http|xxx");
  private static final CountSensor _status2xxSensor
    = MeterService.createCountMeter("Resin|Http|2xx");
  private static final CountSensor _status200Sensor
    = MeterService.createCountMeter("Resin|Http|200");
  private static final CountSensor _status3xxSensor
    = MeterService.createCountMeter("Resin|Http|3xx");
  private static final CountSensor _status304Sensor
    = MeterService.createCountMeter("Resin|Http|304");
  private static final CountSensor _status4xxSensor
    = MeterService.createCountMeter("Resin|Http|4xx");
  private static final CountSensor _status400Sensor
    = MeterService.createCountMeter("Resin|Http|400");
  private static final CountSensor _status404Sensor
    = MeterService.createCountMeter("Resin|Http|404");
  private static final CountSensor _status5xxSensor
    = MeterService.createCountMeter("Resin|Http|5xx");
  private static final CountSensor _status500Sensor
    = MeterService.createCountMeter("Resin|HTTP|500");
  private static final CountSensor _status503Sensor
    = MeterService.createCountMeter("Resin|HTTP|503");

  protected static final CaseInsensitiveIntMap _headerCodes;
  protected static final int HEADER_CACHE_CONTROL = 1;
  protected static final int HEADER_CONTENT_TYPE = HEADER_CACHE_CONTROL + 1;
  protected static final int HEADER_CONTENT_LENGTH = HEADER_CONTENT_TYPE + 1;
  protected static final int HEADER_DATE = HEADER_CONTENT_LENGTH + 1;
  protected static final int HEADER_SERVER = HEADER_DATE + 1;
  protected static final int HEADER_CONNECTION = HEADER_SERVER + 1;

  private static final ConcurrentHashMap<String,ContentType> _contentTypeMap
    = new ConcurrentHashMap<String,ContentType>();

  protected final AbstractHttpRequest _request;

  protected final ArrayList<String> _headerKeys = new ArrayList<String>();
  protected final ArrayList<String> _headerValues = new ArrayList<String>();

  protected final ArrayList<String> _footerKeys = new ArrayList<String>();
  protected final ArrayList<String> _footerValues = new ArrayList<String>();

  private final AbstractResponseStream _responseStream;

  private final ServletOutputStreamImpl _responseOutputStream
    = new ServletOutputStreamImpl();
  private final ResponseWriter _responsePrintWriter
    = new ResponseWriter();

  protected final QDate _calendar = new QDate(false);

  protected final CharBuffer _cb = new CharBuffer();
  protected final char [] _headerBuffer = new char[256];

  private HttpBufferStore _bufferStore;

  private boolean _isHeaderWritten;

  protected long _contentLength;
  private boolean _isClosed;

  protected AbstractHttpResponse(AbstractHttpRequest request)
  {
    _request = request;

    _responseStream = createResponseStream();
  }

  TempBuffer getBuffer()
  {
    return _bufferStore.getTempBuffer();
  }

  protected final QDate getCalendar()
  {
    return _calendar;
  }

  /**
   * If set true, client disconnect exceptions are no propagated to the
   * server code.
   */
  public boolean isIgnoreClientDisconnect()
  {
    return _request.isIgnoreClientDisconnect();
  }

  /**
   * Return true if the connection has disconnected
   */
  public boolean isConnectionClosed()
  {
    return _request.isConnectionClosed();
  }

  /**
   * Called when the client has disconnected
   */
  public void clientDisconnect()
  {
    try {
      _responseStream.close();
    } catch (Exception e) {
      log.log(Level.FINER, e.toString(), e);
    }
    
    _request.clientDisconnect();
  }

  /**
   * Return true for the top request.
   */
  /*
  public boolean isTop()
  {
    if (_request instanceof AbstractHttpRequest)
      return ((AbstractHttpRequest) _request).isTop();
    else
      return false;
  }
  */

  /**
   * Returns the next response.
   */
  public ServletResponse getResponse()
  {
    return null;
  }

  /**
   * Returns the corresponding request.
   */
  public AbstractHttpRequest getRequest()
  {
    return _request;
  }

  /**
   * Returns true for closed requests.
   */
  public boolean isClosed()
  {
    return _isClosed;
  }

  /**
   * Initializes the Response at the beginning of the request.
   */
  public void startRequest(HttpBufferStore bufferStore)
    throws IOException
  {
    _bufferStore = bufferStore;

    _headerKeys.clear();
    _headerValues.clear();

    _footerKeys.clear();
    _footerValues.clear();

    _responseStream.start();

    _isHeaderWritten = false;

    _contentLength = -1;
    _isClosed = false;
  }

  public void startInvocation()
  {
  }

  abstract protected AbstractResponseStream createResponseStream();

  /**
   * For a HEAD request, the response stream should write no data.
   */
  protected void setHead()
  {
    _responseStream.setHead();
  }

  /**
   * For a HEAD request, the response stream should write no data.
   */
  protected final boolean isHead()
  {
    return _responseStream.isHead();
  }

  //
  // headers
  //

  /**
   * Returns true if the response already contains the named header.
   *
   * @param name name of the header to test.
   */
  public boolean containsHeader(String name)
  {
    for (int i = 0; i < _headerKeys.size(); i++) {
      String oldKey = _headerKeys.get(i);

      if (oldKey.equalsIgnoreCase(name))
        return true;
    }

    if (name.equalsIgnoreCase("content-type"))
      return _request.getResponseFacade().getContentType() != null;

    if (name.equalsIgnoreCase("content-length"))
      return _contentLength >= 0;

    return false;
  }

  /**
   * Returns the value of an already set output header.
   *
   * @param name name of the header to get.
   */
  public String getHeader(String name)
  {
    ArrayList<String> keys = _headerKeys;

    int headerSize = keys.size();
    for (int i = 0; i < headerSize; i++) {
      String oldKey = keys.get(i);

      if (oldKey.equalsIgnoreCase(name))
        return (String) _headerValues.get(i);
    }

    if (name.equalsIgnoreCase("content-type"))
      return _request.getResponseFacade().getContentType();

    if (name.equalsIgnoreCase("content-length"))
      return _contentLength >= 0 ? String.valueOf(_contentLength) : null;

    return null;
  }

  /**
   * Sets a header, replacing an already-existing header.
   *
   * @param key the header key to set.
   * @param value the header value to set.
   */
  public void setHeader(String key, String value)
  {
    if (value == null)
      throw new NullPointerException();

    if (setSpecial(key, value)) {
      return;
    }

    // server/05e8 (tck)
    // XXX: server/13w0 for _isHeaderWritten because the Expires in caching
    // occurs after the output fills (committed), which contradicts the tck
    // requirements
    if (isCommitted() && ! _isHeaderWritten) {
      return;
    }

    setHeaderImpl(key, value);
  }


  /**
   * Sets a header, replacing an already-existing header.
   *
   * @param key the header key to set.
   * @param value the header value to set.
   */
  protected void setHeaderImpl(String key, String value)
  {
    int i = 0;
    boolean hasHeader = false;
    
    ArrayList<String> keys = _headerKeys;
    ArrayList<String> values = _headerValues;

    for (i = keys.size() - 1; i >= 0; i--) {
      String oldKey = keys.get(i);

      if (oldKey.equalsIgnoreCase(key)) {
        if (hasHeader) {
          keys.remove(i);
          values.remove(i);
        }
        else {
          hasHeader = true;

          values.set(i, value);
        }
      }
    }

    if (! hasHeader) {
      keys.add(key);
      values.add(value);
    }
  }



  /**
   * Adds a new header.  If an old header with that name exists,
   * both headers are output.
   *
   * @param key the header key.
   * @param value the header value.
   */
  public void addHeader(String key, String value)
  {
    // server/05e8 (tck)
    if (isCommitted()) {
      return;
    }

    addHeaderImpl(key, value);
  }

  /**
   * Adds a new header.  If an old header with that name exists,
   * both headers are output.
   *
   * @param key the header key.
   * @param value the header value.
   */
  public void addHeaderImpl(String key, String value)
  {
    if (setSpecial(key, value))
      return;

    _headerKeys.add(key);
    _headerValues.add(value);
  }

  protected static ContentType parseContentType(String contentType)
  {
    ContentType item = _contentTypeMap.get(contentType);

    if (item == null) {
      item = new ContentType(contentType);

      _contentTypeMap.put(contentType, item);
    }

    return item;
  }

  /**
   * Special processing for a special value.
   */
  protected boolean setSpecial(String key, String value)
  {
    int length = key.length();
    if (256 <= length)
      return false;

    key.getChars(0, length, _headerBuffer, 0);

    switch (_headerCodes.get(_headerBuffer, length)) {
    case HEADER_CACHE_CONTROL:
      // server/13d9, server/13dg
      if (value.startsWith("max-age")) {
      }
      else if (value.startsWith("s-maxage")) {
      }
      else if (value.equals("x-anonymous")) {
      }
      else {
        _request.getResponseFacade().setCacheControl(true);
      }

      return false;

    case HEADER_CONNECTION:
      if ("close".equalsIgnoreCase(value))
        _request.killKeepalive("client connection: close");
      return true;

    case HEADER_CONTENT_TYPE:
      _request.getResponseFacade().setContentType(value);
      return true;

    case HEADER_CONTENT_LENGTH:
      // server/05a8
      // php/164v
      _contentLength = parseLong(value);
      return true;

    case HEADER_DATE:
      return true;

    case HEADER_SERVER:
      return false;

    default:
      return false;
    }
  }
  
  private long parseLong(String string)
  {
    int length = string.length();
   
    int i;
    int ch = 0;
    for (i = 0;
         i < length && Character.isWhitespace((ch = string.charAt(i)));
         i++) {
    }
    
    int sign = 1;
    long value = 0;
    
    if (ch == '-') {
      sign = -1;
      
      if (i < length)
        ch = string.charAt(i++);
    }
    else if (ch == '+') {
      if (i < length)
        ch = string.charAt(i++);
    }
    
    if (! ('0' <= ch && ch <= '9')) {
      throw new IllegalArgumentException(L.l("'{0}' is an invalid content-length",
                                             string));
    }
    
    for (;
         i < length && '0' <= (ch = string.charAt(i)) && ch <= '9';
         i++) {
      value = 10 * value + ch - '0';
    }

    return sign * value;
  }

  public void removeHeader(String key)
  {
    ArrayList<String> keys = _headerKeys;
    ArrayList<String> values = _headerValues;

    for (int i = keys.size() - 1; i >= 0; i--) {
      String oldKey = keys.get(i);

      if (oldKey.equalsIgnoreCase(key)) {
        keys.remove(i);
        values.remove(i);
        return;
      }
    }
  }

  /**
   * Convenience for setting an integer header.  An old header with the
   * same name will be replaced.
   *
   * @param name the header name.
   * @param value an integer to be converted to a string for the header.
   */
  public void setIntHeader(String name, int value)
  {
    _cb.clear();
    _cb.append(value);
    setHeader(name, _cb.toString());
  }

  /**
   * Convenience for adding an integer header.  If an old header already
   * exists, both will be sent to the browser.
   *
   * @param key the header name.
   * @param value an integer to be converted to a string for the header.
   */
  public void addIntHeader(String key, int value)
  {
    _cb.clear();
    _cb.append(value);
    addHeader(key, _cb.toString());
  }

  /**
   * Convenience for setting a date header.  An old header with the
   * same name will be replaced.
   *
   * @param name the header name.
   * @param value an time in milliseconds to be converted to a date string.
   */
  public void setDateHeader(String name, long value)
  {
    _calendar.setGMTTime(value);

    setHeader(name, _calendar.printDate());
  }


  /**
   * Convenience for adding a date header.  If an old header with the
   * same name exists, both will be displayed.
   *
   * @param key the header name.
   * @param value an time in milliseconds to be converted to a date string.
   */
  public void addDateHeader(String key, long value)
  {
    _calendar.setGMTTime(value);

    addHeader(key, _calendar.printDate());
  }

  public ArrayList<String> getHeaderKeys()
  {
    return _headerKeys;
  }

  public ArrayList<String> getHeaderValues()
  {
    return _headerValues;
  }

  public Collection<String> getHeaders(String name)
  {
    ArrayList<String> headers = new ArrayList<String>();

    for (int i = 0; i < _headerKeys.size(); i++) {
      String key = _headerKeys.get(i);

      if (key.equals(name))
        headers.add(_headerValues.get(i));
    }

    return headers;
  }

  public Collection<String> getHeaderNames()
  {
    return new HashSet<String>(_headerKeys);
  }

  public ArrayList<String> getFooterKeys()
  {
    return _footerKeys;
  }

  public ArrayList<String> getFooterValues()
  {
    return _footerValues;
  }

  /**
   * Sets the content length of the result.  In general, Resin will handle
   * the content length, but for things like long downloads adding the
   * length will give a valuable hint to the browser.
   *
   * @param length the length of the content.
   */
  public void setContentLength(int length)
  {
    _contentLength = length;
  }

  /**
   * Returns the value of the content-length header.
   */
  public long getContentLengthHeader()
  {
    return _contentLength;
  }

  /**
   * Sets a footer, replacing an already-existing footer
   *
   * @param key the header key to set.
   * @param value the header value to set.
   */
  public void setFooter(String key, String value)
  {
    if (value == null)
      throw new NullPointerException();

    int i = 0;
    boolean hasFooter = false;

    for (i = _footerKeys.size() - 1; i >= 0; i--) {
      String oldKey = _footerKeys.get(i);

      if (oldKey.equalsIgnoreCase(key)) {
        if (hasFooter) {
          _footerKeys.remove(i);
          _footerValues.remove(i);
        }
        else {
          hasFooter = true;

          _footerValues.set(i, value);
        }
      }
    }

    if (! hasFooter) {
      _footerKeys.add(key);
      _footerValues.add(value);
    }
  }

  /**
   * Adds a new footer.  If an old footer with that name exists,
   * both footers are output.
   *
   * @param key the footer key.
   * @param value the footer value.
   */
  public void addFooter(String key, String value)
  {
    if (setSpecial(key, value))
      return;

    _footerKeys.add(key);
    _footerValues.add(value);
  }

  protected boolean hasFooter()
  {
    return _footerKeys.size() > 0;
  }

  /**
   * Gets the response stream.
   */
  protected AbstractResponseStream getResponseStream()
  {
    return _responseStream;
  }

  protected ServletOutputStreamImpl getResponseOutputStream()
  {
    return _responseOutputStream;
  }

  protected ResponseWriter getResponsePrintWriter()
  {
    return _responsePrintWriter;
  }

  /**
   * Returns true if some data has been sent to the browser.
   */
  public boolean isCommitted()
  {
    if (_responseStream.isCommitted())
      return true;

    // server/05a7
    if (_contentLength > 0
        && _contentLength <= _responseStream.getContentLength()) {
      return true;
    }

    return false;
  }

  protected void reset()
  {
    _headerKeys.clear();
    _headerValues.clear();

    _contentLength = -1;
  }

  /**
   * Returns the number of bytes sent to the output.
   */
  public int getContentLength()
  {
    return _responseStream.getContentLength();
  }

  /**
   * Returns true if the headers have been written.
   */
  public boolean isHeaderWritten()
  {
    return _isHeaderWritten;
  }

  /**
   * Returns true if the headers have been written.
   */
  public void setHeaderWritten(boolean isWritten)
  {
    _isHeaderWritten = isWritten;
  }

  /**
   * Writes the continue
   */
  final void writeContinue()
    throws IOException
  {
    if (! isHeaderWritten()) {
      // writeContinueInt(_rawWrite);
      // _rawWrite.flush();

      writeContinueInt();
    }
  }

  /**
   * Writes the continue
   */
  protected void writeContinueInt()
    throws IOException
  {
  }

  /**
   * Writes the headers to the stream.  Called prior to the first flush
   * of data.
   *
   * @param os browser stream.
   * @param length length of the response if known, or -1 is unknown.
   * @return true if the content is chunked.
   */
  public final boolean writeHeaders(int length)
    throws IOException
  {
    if (isHeaderWritten())
      return false;
    
    HttpServletRequestImpl req = _request.getRequestFacade();
    HttpServletResponseImpl res = _request.getResponseFacade();

    if (res == null)
      return false;
    
    if (res.getStatus() == HttpServletResponse.SC_NOT_MODIFIED) {
      res.handleNotModified();
      length = -1;
    }

    _isHeaderWritten = true;
    boolean isHead = false;

    if (_request.getMethod().equals("HEAD")) {
      isHead = true;
      _responseStream.setHead();
    }

    WebApp webApp = _request.getWebApp();

    int statusCode = res.getStatus();

    addSensorCount(statusCode, webApp);

    if (req != null) {
      HttpSession session = req.getMemorySession();
      if (session instanceof SessionImpl)
        ((SessionImpl) session).saveBeforeHeaders();

      res.addServletCookie(webApp);
    }

    return writeHeadersInt(length, isHead);
  }
  
  private void addSensorCount(int statusCode, WebApp webApp)
  {
    int majorCode = statusCode / 100;

    switch (majorCode) {
    case 2:
      _status2xxSensor.start();
      switch (statusCode) {
      case 200:
        _status200Sensor.start();
        break;
      default:
        break;
      }
      break;
    case 3:
      _status3xxSensor.start();
      switch (statusCode) {
      case 304:
        _status304Sensor.start();
        break;
      default:
        break;
      }
      break;
    case 4:
      _status4xxSensor.start();
      switch (statusCode) {
      case 400:
        _status400Sensor.start();
        break;
      case 404:
        _status404Sensor.start();
        break;
      default:
        break;
      }
      break;
    case 5:
      if (webApp != null)
        webApp.addStatus500();
      
      _status5xxSensor.start();
      
      switch (statusCode) {
      case 500:
        _status500Sensor.start();
        break;
      case 503:
        _status503Sensor.start();
        break;
      default:
        break;
      }
      break;
    default:
      _statusXxxSensor.start();
      break;
    }
  }
    
  abstract protected boolean writeHeadersInt(int length,
                                             boolean isHead)
    throws IOException;

  /**
   * Fills the response for a cookie
   *
   * @param cb result buffer to contain the generated string
   * @param cookie the cookie
   * @param date the current date
   * @param version the cookies version
   */
  public boolean fillCookie(CharBuffer cb, Cookie cookie,
                            long date, int version,
                            boolean isCookie2)
  {
    // How to deal with quoted values?  Old browsers can't deal with
    // the quotes.

    cb.clear();
    cb.append(cookie.getName());
    if (isCookie2) {
      cb.append("=\"");
      cb.append(cookie.getValue());
      cb.append("\"");
    }
    else {
      cb.append("=");
      String v = cookie.getValue();
      int len = v != null ? v.length() : 0;
      
      for (int i = 0; i < len; i++) {
        char ch = v.charAt(i);
        
        if (ch == ' ') {
          // server/010y, #3897
          return fillCookie(cb, cookie, date, version, true);
        }
        
        cb.append(ch);
      }
    }

    String domain = cookie.getDomain();
    if (domain != null && ! domain.equals("")) {
      if (isCookie2) {
        cb.append("; Domain=");

        cb.append('"');
        cb.append(domain);
        cb.append('"');
      }
      else {
        cb.append("; domain=");
        cb.append(domain);
      }
    }

    String path = cookie.getPath();
    if (path != null && ! path.equals("")) {
      if (isCookie2) {
        cb.append("; Path=");

        cb.append('"');
        cb.append(path);
        cb.append('"');
      }
      else {
        // Caps from TCK test
        if (version > 0)
          cb.append("; Path=");
        else
          cb.append("; path=");
        cb.append(path);
      }
    }

    if (cookie.getSecure()) {
      if (version > 0)
        cb.append("; Secure");
      else
        cb.append("; secure");
    }

    int maxAge = cookie.getMaxAge();
    if (version > 0) {
      if (maxAge >= 0) {
        cb.append("; Max-Age=");
        cb.append(maxAge);
      }

      cb.append("; Version=");
      cb.append(version);

      if (cookie.getComment() == null) {
      }
      else if (isCookie2) {
        cb.append("; Comment=\"");
        cb.append(cookie.getComment());
        cb.append("\"");
      }
      else {
        cb.append("; Comment=");
        cb.append(cookie.getComment());
      }

      if (cookie instanceof CookieImpl) {
        CookieImpl extCookie = (CookieImpl) cookie;
        String port = extCookie.getPort();

        if (port != null && isCookie2) {
          cb.append("; Port=\"");
          cb.append(port);
          cb.append("\"");
        }
      }
    }

    if (isCookie2) {
    }
    else if (maxAge == 0) {
      cb.append("; expires=Thu, 01-Dec-1994 16:00:00 GMT");
    }
    else if (maxAge >= 0) {
      _calendar.setGMTTime(date + 1000L * (long) maxAge);
      cb.append("; expires=");
      cb.append(_calendar.format("%a, %d-%b-%Y %H:%M:%S GMT"));
    }

    if (cookie.isHttpOnly()) {
      cb.append("; HttpOnly");
    }

    return true;
  }

  /**
   * Closes the request, called from web-app for early close.
   */
  public void close()
    throws IOException
  {
    // server/125i
    if (! _request.isSuspend()) {
      finishInvocation(true);

      // finishRequest(true);
    }
  }

  /**
   * Complete the invocation.  Flushes the streams, completes caching
   * and writes the appropriate logs.
   */
  public void finishInvocation() throws IOException
  {
    // server/1960, server/1l11
    // finishInvocation(false);
    boolean isClose = ! _request.isSuspend();

    finishInvocation(isClose);
  }

  /**
   * Complete the invocation.  Flushes the streams, completes caching
   * and writes the appropriate logs.
   */
  public void finishRequest() throws IOException
  {
    finishRequest(false);
  }

  /**
   * Complete the request.  Flushes the streams, completes caching
   * and writes the appropriate logs.
   *
   * @param isClose true if the response should be flushed.
   */
  private void finishInvocation(boolean isClose)
    throws IOException
  {
    if (_isClosed)
      return;

    try {
      // server/137p
      HttpServletResponseImpl response = _request.getResponseFacade();
      if (response != null
          && response.getStatus() == HttpServletResponse.SC_NOT_MODIFIED) {
        response.handleNotModified();
      }

      if (_responseStream == null) {
      }
      else if (isClose) {
        _responseStream.close();
      }
      else if (_request.getRequestFacade().isAsyncStarted()
               && _responseStream.getContentLength() == 0) {
        
      }
      else {
        _responseStream.flush();
      }
    } catch (ClientDisconnectException e) {
      _request.killKeepalive("client disconnect: " + e);
      
      clientDisconnect();

      if (isIgnoreClientDisconnect())
        log.fine(e.toString());
      else
        throw e;
    } catch (IOException e) {
      _request.killKeepalive("client ioexception: " + e);

      clientDisconnect();

      throw e;
    }
    
    // server/2600 - for _isClosed
  }

  /**
   * Complete the request.  Flushes the streams, completes caching
   * and writes the appropriate logs.
   *
   * @param isClose true if the response should be flushed.
   */
  private void finishRequest(boolean isClose) throws IOException
  {
    if (_isClosed)
      return;

    try {
      _bufferStore = null;

      AbstractHttpRequest request = _request;

      try {
        request.skip();
      } catch (BadRequestException e) {
        log.warning(e.toString());
        log.log(Level.FINE, e.toString(), e);
      } catch (ClientDisconnectException e) {
        log.log(Level.FINER, e.toString(), e);
      } catch (Exception e) {
        log.log(Level.WARNING, e.toString(), e);
      }

      _isClosed = true;

      // server/0506
      // _responseStream.close();
      /*
    } catch (ClientDisconnectException e) {
      _request.killKeepalive();
      _isClientDisconnect = true;

      if (isIgnoreClientDisconnect())
        log.fine(e.toString());
      else
        throw e;
    } catch (IOException e) {
      _request.killKeepalive();
      _isClientDisconnect = true;

      throw e;
      */
    } finally {
      _isClosed = true;
    }
  }

  protected void free()
  {
  }

  static {
    _headerCodes = new CaseInsensitiveIntMap();
    _headerCodes.put("cache-control", HEADER_CACHE_CONTROL);
    _headerCodes.put("connection", HEADER_CONNECTION);
    _headerCodes.put("content-type", HEADER_CONTENT_TYPE);
    _headerCodes.put("content-length", HEADER_CONTENT_LENGTH);
    _headerCodes.put("date", HEADER_DATE);
    _headerCodes.put("server", HEADER_SERVER);
  }
}
