Quadcap Embeddable Server

com/quadcap/http/server22/HttpRequest.java

Go to the documentation of this file.

package com.quadcap.http.server22;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Vector;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PushbackInputStream;

import java.net.InetAddress;

import java.text.DateFormat;

import java.security.Principal;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import com.quadcap.http.util.HeaderParser;

import com.quadcap.util.Debug;
import com.quadcap.util.Util;

import com.quadcap.io.URLDecodeInputStream;

import com.quadcap.util.text.OctetMap;
import com.quadcap.util.text.Scanner;


/**
 * This class encapsulates the information that makes up a single HTTP
 * request, including the method, URI, and the headers.
 *
 * @author Stan Bailes
 */
public class HttpRequest implements HttpServletRequest {
    WebWorker                   w;
    HttpResponse                res;
    HttpInputStream             his;
    HttpDispatcher              rd;
    HSession                    session         = null;
    BufferedReader              reader          = null;

    Scanner                     scanner;
    static OctetMap             mapM            = new OctetMap('&');
    static {
        mapM.include('\r');
        mapM.include('\n');
    }
    static OctetMap             mapE            = new OctetMap('=');
    static OctetMap             mapQuote        = new OctetMap('"');

    String                      method          = null;
    String                      uri             = null;
    String                      pathInfo        = null;
    String                      queryString     = null;
    int                         queryStringStart = 0;
    int                         queryStringLen = 0;
    String                      protocol        = null;
    byte[]                      headers         = new byte[4096];
    int[]                       hOffsets        = new int[32];
    Hashtable                   parameters      = new Hashtable();
    Hashtable                   attributes      = null;
    boolean                     getInputStreamCalled = false;
    boolean                     getReaderCalled = false;
                                                               
    static DateFormat           dateFormat      = DateFormat.getInstance();

    static final int            CR              = '\r';

    Cookie[]                    cookies         = null; 
    boolean                     badRequest      = false;

    static final String         methodGET       = "GET";
    static final String         methodHEAD      = "HEAD";
    static final String         methodPOST      = "POST";

    static final String         proto_09        = "HTTP/0.9";
    static final String         proto_10        = "HTTP/1.0";
    static final String         proto_11        = "HTTP/1.1";

    /**
     * Using the specified worker's input stream, read an HTTP request,
     * and construct a new <code>HttpRequest</code> object to represent it.
     *
     * @param w the worker
     */
    public HttpRequest(WebWorker w) {
        this.w = w;
        this.scanner = new Scanner(null);
    }

    /**
     * Reset the request object and bind it to the input stream.
     */
    public void reset(HttpInputStream is) throws IOException {
        //Jni j2 = new Jni("HttpRequest");
        //j2.reset();
        this.his = is;
        parameters.clear();
        attributes = null;
        method = null;
        uri = null;
        pathInfo = null;
        queryString = null;
        protocol = null;
        reader = null;
        session = null;
        rd = null;
        cookies = null;
        queryStringStart = 0;
        getInputStreamCalled = false;
        getReaderCalled = false;

        //j2.dump("clear");
        int hsize = is.getInputStream().readHeaders(headers, hOffsets);
        //Debug.println(Util.strBytes(headers, 0, hsize));
        //j2.dump("readHeaders");
        int lim = hOffsets[1];
        int pos = 0;
        while (headers[pos] == '\r' || headers[pos] == '\n') pos++;
        int start = pos;
        while (headers[pos] != ' ' && pos < lim) pos++;

        final byte b1 = headers[start];
        if (b1 == 'G') {
            if (headers[start+1] == 'E') {
                if (headers[start+2] == 'T') {
                    method = methodGET;
                }
            }
        } else if (b1 == 'P') {
            if (headers[start+1] == 'O') {
                if (headers[start+2] == 'S') {
                    if (headers[start+3] == 'T') {
                        method = methodPOST;
                    }
                }
            }
        } else if (b1 == 'H') {
            if (headers[start+1] == 'E') {
                if (headers[start+2] == 'A') {
                    if (headers[start+3] == 'D') {
                        method = methodHEAD;
                    }
                }
            }
        }
        if (method == null) {
            method = new String(headers, start, pos - start);
            if (method.equalsIgnoreCase("get")) {
                method = methodGET;
            } else if (method.equalsIgnoreCase("post")) {
                method = methodPOST;
            } else if (method.equalsIgnoreCase("head")) {
                method = methodHEAD;
            }
        }
        
        //j2.dump("getMethod");
        while (headers[pos] == ' ' && pos < lim) pos++;
        start = pos;
        while (headers[pos] != ' ' && headers[pos] != '?' && pos < lim) pos++;
        uri = new String(headers, start, pos - start);
        //j2.dump("getUri");
        if (headers[pos] == '?') {
            start = ++pos;
            while (headers[pos] != ' ' && headers[pos] != '\r'&& pos < lim) {
                pos++;
            }
            queryStringStart = start;
            queryStringLen = pos - start;
            parseParameters(parameters,
                            new ByteArrayInputStream(headers, start,
                                                     pos-start));
            
        }
        while (headers[pos] == ' ' && pos < lim) pos++;
        start = pos;
        if (pos < lim) {
            for (byte c = headers[pos];
                 c != '\r' && c != '\n' && c != ' ';
                 c = headers[pos]) {
                if (++pos >= lim) break;
            }
        }
        protocol = proto_10;
        try {
            if (headers[pos-1] == '0') {
                protocol = proto_10;
            } else if (headers[pos-1] == '1') {
                protocol = proto_11;
            }
            if (protocol == null) {
                protocol = new String(headers, start, pos - start);
            }
        } catch (Throwable t) {}
        //j2.dump("getProto");
        
        int cl = getContentLength();
        if (cl >= 0) {
            is.setContentLength(cl);
        }        
    }

    final void maybeParsePostData() {
        if (!getReaderCalled && !getInputStreamCalled &&
            method == methodPOST) {
            String type = getContentType();
            if (type != null &&
                type.equals("application/x-www-form-urlencoded"))
            {
                scanner.reset(his);
                parseParameters(parameters, scanner);
            }
        }
    }

    boolean badRequest() { return badRequest; }

    public void setURI(String s) {
        try {
            Scanner scanner = 
                new Scanner(new ByteArrayInputStream(s.getBytes()));
            this.uri = scanner.parseWhile(OctetMap.uriChars);
            if (scanner.peek() == '?') {
                scanner.matchChar('?');
                queryString = scanner.parseWhile(OctetMap.uriChars);
                parseParameters(parameters,
                                new ByteArrayInputStream(queryString.getBytes()));
            } else {
                queryString = "";
            }
        } catch (IOException e) {}
    }

    /**
     * ----- ServletRequest methods
     */
    
    /**
     * Returns the size of the request entity data, or -1 if not known.
     * Same as the CGI variable CONTENT_LENGTH.
     */
    public int getContentLength() {
        String s = getHeader("Content-Length");
        if (s == null) return -1;
        try {
            return Integer.parseInt(s);
        } catch (Exception e) {
            return -1;
        }
    }
    
    /**
     * Returns the Internet Media Type of the request entity data, or
     * null if not known. Same as the CGI variable CONTENT_TYPE.
     */
    public String getContentType() {
        return getHeader("Content-Type");
    }

    /**
     * Returns the protocol and version of the request as a string of
     * the form <code>&lt;protocol&gt;/&lt;major version&gt;.&lt;minor
     * version&gt</code>.  Same as the CGI variable SERVER_PROTOCOL.
     */
    public String getProtocol() {
        return protocol;
    }

    /**
     * Returns the scheme of the URL used in this request, for example
     * "http", "https", or "ftp".  Different schemes have different
     * rules for constructing URLs, as noted in RFC 1738.  The URL used
     * to create a request may be reconstructed using this scheme, the
     * server name and port, and additional information such as URIs.
     */
    public String getScheme() {
        return "HTTP";
    }

    /**
     * Returns the host name of the server that received the request.
     * Same as the CGI variable SERVER_NAME.
     */
    public String getServerName() {
        return w.getHostName();
    }

    /**
     * Returns the port number on which this request was received.
     * Same as the CGI variable SERVER_PORT.
     */
    public int getServerPort() {
        return w.getPort();
    }

    /**
     * Returns the IP address of the agent that sent the request.
     * Same as the CGI variable REMOTE_ADDR.
     */
    public String getRemoteAddr() {
        return w.getRemoteAddr();
    }

    /**
     * Returns the fully qualified host name of the agent that sent the
     * request. Same as the CGI variable REMOTE_HOST.
     */
    public String getRemoteHost() {
        return w.getRemoteHost();
    }

    /**
     * Applies alias rules to the specified virtual path and returns
     * the corresponding real path, or null if the translation can not
     * be performed for any reason.  For example, an HTTP servlet would
     * resolve the path using the virtual docroot, if virtual hosting
     * is enabled, and with the default docroot otherwise.  Calling
     * this method with the string "/" as an argument returns the
     * document root.
     *
     * @param path the virtual path to be translated to a real path
     */
    public String getRealPath(String path) {
        WebApplication app = rd.getContext();
        return app.getRealPath(path);
    }

    /**
     * Returns an input stream for reading binary data in the request body.
     *
     * @exception IllegalStateException if getReader has been
     *  called on this same request.
     * @exception IOException on other I/O related errors.
     */
    public ServletInputStream getInputStream() throws IOException {
        if (getReaderCalled) {
            throw new IllegalStateException("getReader() already called");
        }
        getInputStreamCalled = true;
        return w.getHttpInputStream();
    }

    /**
     * Returns a string containing the lone value of the specified
     * parameter, or null if the parameter does not exist. For example,
     * in an HTTP servlet this method would return the value of the
     * specified query string parameter. Servlet writers should use
     * this method only when they are sure that there is only one value
     * for the parameter.  If the parameter has (or could have)
     * multiple values, servlet writers should use
     * getParameterValues. If a multiple valued parameter name is
     * passed as an argument, the return value is implementation
     * dependent.
     *
     *
     * @param name the name of the parameter whose value is required.
     */
    public String getParameter(String name) {
        maybeParsePostData();
        String[] s = (String[])parameters.get(name);
        if (s == null) return null;
        return s[0];
    }

    /**
     * Returns the values of the specified parameter for the request as
     * an array of strings, or null if the named parameter does not
     * exist. For example, in an HTTP servlet this method would return
     * the values of the specified query string or posted form as an
     * array of strings.
     *
     * @param name the name of the parameter whose value is required.
     */
    public String[] getParameterValues(String name) {
        maybeParsePostData();
        String[] ret =(String[])parameters.get(name);
        return ret;
    }

    /**
     * Returns the parameter names for this request as an enumeration
     * of strings, or an empty enumeration if there are no parameters
     * or the input stream is empty.  The input stream would be empty
     * if all the data had been read from the stream returned by the
     * method getInputStream.
     */
    public Enumeration getParameterNames() {
        maybeParsePostData();
        return parameters.keys();
    }    

    /**
     * Returns the value of the named attribute of the request, or
     * null if the attribute does not exist.
     *
     * @param name the name of the attribute whose value is required
     */
    public Object getAttribute(String name) {
        Object obj = null;
        if (attributes != null) obj = attributes.get(name);
        return obj;
    }

    /**
     * Set the value of the named attribute
     *
     * @param name the name of the attribute
     * @param obj the value
     */
    public void setAttribute(String name, Object obj) {
        if (attributes == null) attributes = new Hashtable();
        attributes.put(name, obj);
    }

    /**
     * Return an enumeration of all attribute names of this service
     */
    public Enumeration getAttributeNames() {
        if (attributes == null) return new Vector().elements();
        return attributes.keys();
    }

    /**
     * Remove an attribute from the request
     */
    public void removeAttribute(String name) {
        attributes.remove(name);
    }

    /**
     * Returns a buffered reader for reading text in the request body.
     * This translates character set encodings as appropriate. 
     *
     *
     * @exception UnsupportedEncodingException if the character set encoding
     *  is unsupported, so the text can't be correctly decoded.
     * @exception IllegalStateException if getInputStream has been
     *  called on this same request.
     * @exception IOException on other I/O related errors.
     */
    public BufferedReader getReader() throws IOException {
        if (getInputStreamCalled) {
            throw new IllegalStateException("getInputStream() already called");
        }
        if (reader == null) {
            reader =
                new BufferedReader(new InputStreamReader(getInputStream()));
        }
        getReaderCalled = true;
        return reader;
    }

    /**
     * Returns the character set encoding for the input of this request.
     */
    public String getCharacterEncoding () {
        String s = getContentType();
        if (s == null) return null;
        
        int idx = s.indexOf(';');
        while (idx > 0) {
            s = s.substring(idx+1).trim();
            idx = s.indexOf(';');
            String c = s;
            if (idx > 0) {
                c = s.substring(0, idx).trim();
            }
            if (c.startsWith("charset=")) {
                return c.substring(8);
            }
        }
        return null;
    }

    /**
     * ----- HttpServletRequest methods -----
     */

    /**
     * Gets the array of cookies found in this request.
     *
     * @return the array of cookies found in this request
     */
    public Cookie[] getCookies() {
        if (cookies == null) {
            CookieParser cp = new CookieParser(getHeader("Cookie"));
            try {
                cookies = cp.parseCookies();
            } catch (IOException e) {
                Debug.print(e);
                cookies = new Cookie[0];
            }
        }
        return cookies;
    }

    /**
     * Gets the HTTP method (for example, GET, POST, PUT) with which
     * this request was made. Same as the CGI variable REQUEST_METHOD.
     *
     * @return the HTTP method with which this request was made
     */
    public String getMethod() {
        return method;
    }

    /**
     * Gets, from the first line of the HTTP request, the part of this
     * request's URI that is to the left of any query string.
     * For example,
     *
     * <blockquote>
     * <table>
     * <tr align=left><th>First line of HTTP request<th>
     * <th>Return from <code>getRequestURI</code>
     * <tr><td>POST /some/path.html HTTP/1.1<td><td>/some/path.html
     * <tr><td>GET http://foo.bar/a.html HTTP/1.0
     * <td><td>http://foo.bar/a.html
     * <tr><td>HEAD /xyz?a=b HTTP/1.1<td><td>/xyz
     * </table>
     * </blockquote>
     * 
     * <p>To reconstruct a URL with a URL scheme and host, use the
     * method javax.servlet.http.HttpUtils.getRequestURL, which returns
     * a StringBuffer.
     *
     * @return this request's URI
     */
    public String getRequestURI() {
        return uri;
    }

    /**
     * Gets the part of this request's URI that refers to the servlet
     * being invoked. Analogous to the CGI variable SCRIPT_NAME.
     *
     * @return the servlet being invoked, as contained in this
     * request's URI
     */
    public String getServletPath() {
        return rd.getServletPath();
    }

    /**
     * Gets any optional extra path information following the servlet
     * path of this request's URI, but immediately preceding its query
     * string. Same as the CGI variable PATH_INFO.
     *
     * @return the optional path information following the servlet
     * path, but before the query string, in this request's URI; null
     * if this request's URI contains no extra path information
     */
    public String getPathInfo() {
        return rd.getPathInfo();
    }

    /**
     * Gets any optional extra path information following the servlet
     * path of this request's URI, but immediately preceding its query
     * string, and translates it to a real path.  Similar to the CGI
     * variable PATH_TRANSLATED
     *
     * @return extra path information translated to a real path or null
     * if no extra path information is in the request's URI
     */
    public String getPathTranslated() {
        return null;
    }

    /**
     * Gets any query string that is part of the HTTP request URI.
     * Same as the CGI variable QUERY_STRING.
     *
     * @return query string that is part of this request's URI, or null
     * if it contains no query string
     */
    public String getQueryString() {
        if (queryString == null) {
            if (queryStringStart > 0) {
                queryString = new String(headers, queryStringStart,
                                         (queryStringLen));
            }
        }
        return queryString;
    }

    /**
     * Gets the name of the user making this request.  The user name is
     * set with HTTP authentication.  Whether the user name will
     * continue to be sent with each subsequent communication is
     * browser-dependent.  Same as the CGI variable REMOTE_USER.
     *
     * @return the name of the user making this request, or null if not
     * known.
     */
    public String getRemoteUser() {
        return null;
    }

    /**
     * Gets the authentication scheme of this request.  Same as the CGI
     * variable AUTH_TYPE.
     *
     * @return this request's authentication scheme, or null if none.
     */
    public String getAuthType() {
        return null;
    }

    /**
     * Gets the value of the requested header field of this request.
     * The case of the header field name is ignored.
     * 
     * @param name the String containing the name of the requested
     * header field
     * @return the value of the requested header field, or null if not
     * known.
     */
    public String getHeader(String name) {
        String ret = null;
        int hcnt = hOffsets[0];
        for (int i = 1; i < hcnt; i++) {
            int off = hOffsets[i];
            int lim = hOffsets[i+1];
            int pos = off;
            while (headers[pos] != ':' && pos < lim) pos++;
            String hdr = new String(headers, off, pos - off);
            if (name.equalsIgnoreCase(hdr)) {
                ret = new String(headers, pos+1, lim-pos-1).trim();
                break;
            }   
        }
        return ret;
    }


    /**
     * Gets the value of the specified integer header field of this
     * request.  The case of the header field name is ignored.  If the
     * header can't be converted to an integer, the method throws a
     * NumberFormatException.
     * 
     * @param name the String containing the name of the requested
     * header field
     * @return the value of the requested header field, or -1 if not
     * found.
     */
    public int getIntHeader(String name) {
        int ret = -1;
        String val = getHeader(name);
        if (val != null) {
            ret = Integer.parseInt(val);
        }
        return ret;
    }

    /**
     * Gets the value of the requested date header field of this
     * request.  If the header can't be converted to a date, the method
     * throws an IllegalArgumentException.  The case of the header
     * field name is ignored.
     * 
     * @param name the String containing the name of the requested
     * header field
     * @return the value the requested date header field, or -1 if not
     * found.
     */
    public long getDateHeader(String name) {
        long ret = -1;
        String val = getHeader(name);
        if (val != null) {
            try {
                synchronized (dateFormat) {
                    Date d = dateFormat.parse(val);
                    ret = d.getTime();
                }
            } catch (Exception e) {
            }
        }
        return ret;
    }

    /**
     * Gets the header names for this request.
     *
     * @return an enumeration of strings representing the header names
     * for this request. Some server implementations do not allow
     * headers to be accessed in this way, in which case this method
     * will return null.
     */
    public Enumeration getHeaders() {
        return getHeaderNames();
    }

    public Enumeration getHeaders(String name) {
        Vector v = new Vector();
        int hcnt = hOffsets[0];
        for (int i = 1; i < hcnt; i++) {
            int off = hOffsets[i];
            int lim = hOffsets[i+1];
            int pos = off;
            while (headers[pos] != ':' && pos < lim) pos++;
            if (name.equalsIgnoreCase(new String(headers, off, pos-off))) {
                pos++;
                int len = lim - pos;
                v.addElement(new String(headers, pos, len).trim());
            }   
        }
        return v.elements();
    }

    public Enumeration getHeaderNames() {
        Vector v = new Vector();
        int hcnt = hOffsets[0];
        for (int i = 1; i < hcnt; i++) {
            int off = hOffsets[i];
            int lim = hOffsets[i+1];
            int pos = off;
            while (headers[pos] != ':' && pos < lim) pos++;
            v.addElement(new String(headers, off, pos-off));
        }
        return v.elements();
    }

    /**
     * Gets the current valid session associated with this request, if
     * create is false or, if necessary, creates a new session for the
     * request, if create is true.
     *
     * <p><b>Note</b>: to ensure the session is properly maintained,
     * the servlet developer must call this method (at least once)
     * before any output is written to the response.
     *
     * <p>Additionally, application-writers need to be aware that newly
     * created sessions (that is, sessions for which
     * <code>HttpSession.isNew</code> returns true) do not have any
     * application-specific state.
     *
     * @return the session associated with this request or null if
     * create was false and no valid session is associated
     * with this request.
     */
    public HttpSession getSession(boolean create) {
        if (session == null) {
            WebApplication app = rd.getContext();
            String sessionId = getRequestedSessionId();
            if (sessionId != null) {
                session = app.getSession(sessionId);
            } else if (create) {
                session = app.createSession();
                sessionId = session.getId();
            }
            if (sessionId != null) {
                Cookie c = new Cookie("sessionId", sessionId);
                c.setPath(getContextPath());
                res.addCookie(c);
            }
        }
        if (session != null) session.updateLastAccess();
        return session;
    }
   
    /**
     * Gets the current valid session associated with this request, and
     * if necessary, creates a new session for the request.
     *
     * @return the session associated with this request.
     */
    public HttpSession getSession() {
        return getSession(true);
    }

    /**
     * Gets the session id specified with this request.  This may
     * differ from the actual session id.  For example, if the request
     * specified an id for an invalid session, then this will get a new
     * session with a new id.
     *
     * @return the session id specified by this request, or null if the
     * request did not specify a session id
     * 
     */
    public String getRequestedSessionId() {
        String sessionId = null;
        getCookies();
        WebApplication app = rd.getContext();
        boolean foundSession = false;
        for (int i = 0; i < cookies.length; i++) {
            Cookie c = cookies[i];
            if (c.getName().equals("sessionId")) {
                sessionId = c.getValue();
                if (app.getSession(sessionId) != null) {
                    foundSession = true;
                    break;
//                  } else {
//                      Debug.println("invalid session id: " + sessionId);
                }
            }
        }
        if (sessionId != null && !foundSession) {
            sessionId = app.createSession().getId();
        }
        return sessionId;
    }

    /**
     * Checks whether this request is associated with a session that
     * is valid in the current session context.  If it is not valid,
     * the requested session will never be returned from the
     * <code>getSession</code> method.
     * 
     * @return true if this request is assocated with a session that is
     * valid in the current session context.
     *
     */
    public boolean isRequestedSessionIdValid() {
        HSession sess = null;
        String sessionId = getRequestedSessionId();
        if (sessionId != null) {
            sess = rd.getContext().getSession(sessionId);
        }
        return (sess != null && sess.isValid());
    }

    /**
     * Checks whether the session id specified by this request came in
     * as a cookie.  (The requested session may not be one returned by
     * the <code>getSession</code> method.)
     * 
     * @return true if the session id specified by this request came in
     * as a cookie; false otherwise
     *
     */
    public boolean isRequestedSessionIdFromCookie() {
        return true;
    }

    /**
     * Checks whether the session id specified by this request came in
     * as part of the URL.  (The requested session may not be the one
     * returned by the <code>getSession</code> method.)
     * 
     * @return true if the session id specified by the request for this
     * session came in as part of the URL; false otherwise
     *
     */
    public boolean isRequestedSessionIdFromURL() {
        return false;
    }
    public boolean isRequestedSessionIdFromUrl() {
        return false;
    }

    /**
     * ---- private parsing helpers
     */

    
    /**
     * Parsing helper: Get the next bytes all of which are in the
     * specified map
     *
     * @param map the octet map specifying the bytes we want
     */
    String getToken(OctetMap map) throws IOException {
        scanner.skipWhile(OctetMap.wsChars);
        return scanner.parseWhile(map);
    }

    static OctetMap versionMap = new OctetMap("HhTtPp/1.0");
    
    /**
     * Parse the http version field from the request line
     *
     * @return the http protocol and version
     *
     * @exception IOException if the version field is incorrect
     */
    String parseHttpVersion() throws IOException {      
        scanner.skipWhile(OctetMap.wsChars);
        return scanner.parseWhile(versionMap);
    }

    static final String urlDecode(String s) {
        StringBuffer sb = null;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            switch (c) {
            case '+':
                if (sb == null) sb = new StringBuffer(s.substring(0, i));
                sb.append(' ');
                break;
            case '%':
                if (sb == null) sb = new StringBuffer(s.substring(0, i));
                try {
                    sb.append((char) Integer.parseInt(s.substring(i+1, i+3), 
                                                      16));
                    i += 2;
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException();
                } catch (StringIndexOutOfBoundsException e) {
                    String rest  = s.substring(i);
                    sb.append(rest);
                    if (rest.length()==2) i++;
                }
                break;
            default:
                if (sb != null) sb.append(c);
            }
        }
        return sb == null ? s : sb.toString();
    }

    /**
     * Parse a set of parameters from the specified input stream.
     *
     * @param is the input stream
     * @return a table containing the parameters as String -> String[]
     *          entries.
     */
    public static void parseParameters(Hashtable params, InputStream is) {
        parseParameters(params, new Scanner(is));
    }

    public static void parseParameters(Hashtable params, Scanner s) {
        try {
            do {
                String name = urlDecode(s.parseUntil(mapE));
                s.matchChar('=');
                String val = urlDecode(s.parseUntil(mapM));
                String[] vals = (String[])params.get(name);
                if (vals == null) {
                    vals = new String[1];
                } else {
                    String[] oldvals = vals;
                    vals = new String[vals.length+1];
                    for (int i = 0; i < oldvals.length; i++) {
                        vals[i] = oldvals[i];
                    }
                }
                vals[vals.length-1] = val;
                params.put(name, vals);
                s.matchChar('&');
            } while (s.peek() >= 0);
        } catch (IOException e) {
        }
    }

    /**
     * Associate this request with its matching response.  We need this
     * to facilitate session management via cookies
     *
     * @param res the HttpResponse that goes with this request
     */
    void setResponse(HttpResponse res) { this.res = res; }

    /**
     * Return the portion of the request URI that specifies the context
     * for this request
     */
    public String getContextPath() {
        return rd.getContextPath();
    }

    /**
     * Returns a boolean indicating whether the authenticated user is
     * included in the indicated 'role'.
     */
    public boolean isUserInRole(String role) {
        return false;   // XXX implement me
    }

    /**
     * Return a Principal object indicating the identity of the user
     * associated with this request.
     */
    public Principal getUserPrincipal() {
        return null;    // XXX implement me
    }

    /**
     * Return the preferred Locale that the client will accept content
     * from based on the <code>Accept-Language</code> header, or the
     * server default Locale
     */
    public Locale getLocale() {
        Locale locale = null;
        String accept = getHeader("Accept-Language");
        if (accept != null) {
            int idx = accept.indexOf(',');
            if (idx > 0) {
                accept = accept.substring(0, idx).trim();
            }
            locale = makeLocale(accept);
        } else {
            locale = Locale.getDefault();
        }
        return locale;
    }

    final Locale makeLocale(String s) {
        int idx = s.indexOf(';');
        if (idx > 0) {
            s = s.substring(0, idx).trim();
        }
        idx = s.indexOf('-');
        String lang = null;
        String country = "";
        if (idx > 0) {
            lang = s.substring(0, idx);
            country = s.substring(idx+1);
        } else {
            lang = s;
        }
        return new Locale(lang, country);
    }

    final float getLangQual(String s) {
        float q = 1.0f;
        int idx = s.indexOf(';');
        if (idx > 0) {
            s = s.substring(idx+1).trim();
            idx = s.indexOf("q=");
            if (idx >= 0) {
                q =Float.parseFloat(s.substring(idx+2));
            }
        }
        return q;
    }
    
    final int compareAccept(String a, String b) {
        float aq = getLangQual(a);
        float bq = getLangQual(b);
        if (aq < bq) return -1;
        if (aq > bq) return 1;
        return 0;
    }

    public Enumeration getLocales() {
        String accept = getHeader("Accept-Language");
        if (accept == null) {
            Vector v = new Vector();
            v.addElement(Locale.getDefault());
            return v.elements();
        }
        Vector v = Util.split(accept, ',');
        Comparator c = new Comparator() {
            public int compare(Object a, Object b) {
                return compareAccept(a.toString(), b.toString());
            }
        };
        Collections.sort(v, c);
        final Enumeration e = v.elements();
        return new Enumeration() {
            public boolean hasMoreElements() {
                return e.hasMoreElements();
            }
            public Object nextElement() {
                return makeLocale(e.nextElement().toString());
            }
        };
    }
                
    public RequestDispatcher getRequestDispatcher(String path) {
        return rd.getContext().getRelativeRequestDispatcher(path, this);
    }

    public boolean isSecure() {
        return false;
    }

    final void setRequestDispatcher(HttpDispatcher rd) {
        this.rd = rd;
    }

}