/* Request.java --   Copyright (C) 2004, 2005 Free Software Foundation, Inc.This file is part of GNU Classpath.GNU Classpath is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation; either version 2, or (at your option)any later version. GNU Classpath is distributed in the hope that it will be useful, butWITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNUGeneral Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU Classpath; see the file COPYING.  If not, write to theFree Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA02110-1301 USA.Linking this library statically or dynamically with other modules ismaking a combined work based on this library.  Thus, the terms andconditions of the GNU General Public License cover the wholecombination.As a special exception, the copyright holders of this library give youpermission to link this library with independent modules to produce anexecutable, regardless of the license terms of these independentmodules, and to copy and distribute the resulting executable underterms of your choice, provided that you also meet, for each linkedindependent module, the terms and conditions of the license of thatmodule.  An independent module is a module which is not derived fromor based on this library.  If you modify this library, you may extendthis exception to your version of the library, but you are notobligated to do so.  If you do not wish to do so, delete thisexception statement from your version. */package gnu.java.net.protocol.http;import gnu.java.net.BASE64;import gnu.java.net.LineInputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.ProtocolException;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import java.text.DateFormat;import java.text.ParseException;import java.util.Calendar;import java.util.Date;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Properties;import java.util.zip.GZIPInputStream;import java.util.zip.InflaterInputStream;/** * A single HTTP request. * * @author Chris Burdess (dog@gnu.org) */public class Request{  /**   * The connection context in which this request is invoked.   */  protected final HTTPConnection connection;  /**   * The HTTP method to invoke.   */  protected final String method;  /**   * The path identifying the resource.   * This string must conform to the abs_path definition given in RFC2396,   * with an optional "?query" part, and must be URI-escaped by the caller.   */  protected final String path;  /**   * The headers in this request.   */  protected final Headers requestHeaders;  /**   * The request body provider.   */  protected RequestBodyWriter requestBodyWriter;  /**   * Request body negotiation threshold for 100-continue expectations.   */  protected int requestBodyNegotiationThreshold;  /**   * Map of response header handlers.   */  protected Map responseHeaderHandlers;  /**   * The authenticator.   */  protected Authenticator authenticator;  /**   * Whether this request has been dispatched yet.   */  private boolean dispatched;  /**   * Constructor for a new request.   * @param connection the connection context   * @param method the HTTP method   * @param path the resource path including query part   */  protected Request(HTTPConnection connection, String method,                    String path)  {    this.connection = connection;    this.method = method;    this.path = path;    requestHeaders = new Headers();    responseHeaderHandlers = new HashMap();    requestBodyNegotiationThreshold = 4096;  }  /**   * Returns the connection associated with this request.   * @see #connection   */  public HTTPConnection getConnection()  {    return connection;  }  /**   * Returns the HTTP method to invoke.   * @see #method   */  public String getMethod()  {    return method;  }  /**   * Returns the resource path.   * @see #path   */  public String getPath()  {    return path;  }  /**   * Returns the full request-URI represented by this request, as specified   * by HTTP/1.1.   */  public String getRequestURI()  {    return connection.getURI() + path;  }  /**   * Returns the headers in this request.   */  public Headers getHeaders()  {    return requestHeaders;  }  /**   * Returns the value of the specified header in this request.   * @param name the header name   */  public String getHeader(String name)  {    return requestHeaders.getValue(name);  }  /**   * Returns the value of the specified header in this request as an integer.   * @param name the header name   */  public int getIntHeader(String name)  {    return requestHeaders.getIntValue(name);  }  /**   * Returns the value of the specified header in this request as a date.   * @param name the header name   */  public Date getDateHeader(String name)  {    return requestHeaders.getDateValue(name);  }  /**   * Sets the specified header in this request.   * @param name the header name   * @param value the header value   */  public void setHeader(String name, String value)  {    requestHeaders.put(name, value);  }  /**   * Convenience method to set the entire request body.   * @param requestBody the request body content   */  public void setRequestBody(byte[] requestBody)  {    setRequestBodyWriter(new ByteArrayRequestBodyWriter(requestBody));  }  /**   * Sets the request body provider.   * @param requestBodyWriter the handler used to obtain the request body   */  public void setRequestBodyWriter(RequestBodyWriter requestBodyWriter)  {    this.requestBodyWriter = requestBodyWriter;  }  /**   * Sets a callback handler to be invoked for the specified header name.   * @param name the header name   * @param handler the handler to receive the value for the header   */  public void setResponseHeaderHandler(String name,                                       ResponseHeaderHandler handler)  {    responseHeaderHandlers.put(name, handler);  }  /**   * Sets an authenticator that can be used to handle authentication   * automatically.   * @param authenticator the authenticator   */  public void setAuthenticator(Authenticator authenticator)  {    this.authenticator = authenticator;  }  /**   * Sets the request body negotiation threshold.   * If this is set, it determines the maximum size that the request body   * may be before body negotiation occurs(via the   * <code>100-continue</code> expectation). This ensures that a large   * request body is not sent when the server wouldn't have accepted it   * anyway.   * @param threshold the body negotiation threshold, or &lt;=0 to disable   * request body negotation entirely   */  public void setRequestBodyNegotiationThreshold(int threshold)  {    requestBodyNegotiationThreshold = threshold;  }  /**   * Dispatches this request.   * A request can only be dispatched once; calling this method a second   * time results in a protocol exception.   * @exception IOException if an I/O error occurred   * @return an HTTP response object representing the result of the operation   */  public Response dispatch()    throws IOException  {    if (dispatched)      {        throw new ProtocolException("request already dispatched");      }    final String CRLF = "\r\n";    final String HEADER_SEP = ": ";    final String US_ASCII = "US-ASCII";    final String version = connection.getVersion();    Response response;    int contentLength = -1;    boolean retry = false;    int attempts = 0;    boolean expectingContinue = false;    if (requestBodyWriter != null)      {        contentLength = requestBodyWriter.getContentLength();        if (contentLength > requestBodyNegotiationThreshold)          {            expectingContinue = true;            setHeader("Expect", "100-continue");          }        else          {            setHeader("Content-Length", Integer.toString(contentLength));          }      }        try      {        // Loop while authentication fails or continue        do          {            retry = false;                        // Get socket output and input streams            OutputStream out = connection.getOutputStream();            // Request line            String requestUri = path;            if (connection.isUsingProxy() &&                !"*".equals(requestUri) &&                !"CONNECT".equals(method))              {                requestUri = getRequestURI();              }            String line = method + ' ' + requestUri + ' ' + version + CRLF;            out.write(line.getBytes(US_ASCII));            // Request headers            for (Iterator i = requestHeaders.keySet().iterator();                 i.hasNext(); )              {                String name =(String) i.next();                String value =(String) requestHeaders.get(name);                line = name + HEADER_SEP + value + CRLF;                out.write(line.getBytes(US_ASCII));              }            out.write(CRLF.getBytes(US_ASCII));            // Request body            if (requestBodyWriter != null && !expectingContinue)              {                byte[] buffer = new byte[4096];                int len;                int count = 0;                                requestBodyWriter.reset();                do                  {                    len = requestBodyWriter.write(buffer);                    if (len > 0)                      {                        out.write(buffer, 0, len);                      }                    count += len;                  }                while (len > -1 && count < contentLength);              }            out.flush();            // Get response            while(true)            {              response = readResponse(connection.getInputStream());              int sc = response.getCode();              if (sc == 401 && authenticator != null)                {                  if (authenticate(response, attempts++))                    {                      retry = true;                    }                }              else if (sc == 100)                {                  if (expectingContinue)                    {                      requestHeaders.remove("Expect");                      setHeader("Content-Length",                                Integer.toString(contentLength));                      expectingContinue = false;                      retry = true;                    }                  else                    {                      // A conforming server can send an unsoliceted                      // Continue response but *should* not (RFC 2616                      // sec 8.2.3).  Ignore the bogus Continue                      // response and get the real response that                      // should follow                      continue;                    }                }              break;            }          }        while (retry);      }    catch (IOException e)      {        connection.close();        throw e;      }    return response;  }      Response readResponse(InputStream in)    throws IOException  {    String line;    int len;        // Read response status line    LineInputStream lis = new LineInputStream(in);    line = lis.readLine();    if (line == null)      {        throw new ProtocolException("Peer closed connection");      }    if (!line.startsWith("HTTP/"))      {        throw new ProtocolException(line);      }    len = line.length();    int start = 5, end = 6;    while (line.charAt(end) != '.')      {        end++;      }    int majorVersion = Integer.parseInt(line.substring(start, end));    start = end + 1;    end = start + 1;    while (line.charAt(end) != ' ')      {        end++;      }    int minorVersion = Integer.parseInt(line.substring(start, end));    start = end + 1;    end = start + 3;    int code = Integer.parseInt(line.substring(start, end));    String message = line.substring(end + 1, len - 1);    // Read response headers    Headers responseHeaders = new Headers();    responseHeaders.parse(lis);    notifyHeaderHandlers(responseHeaders);    InputStream body = null;