request.java

是离开的肌肤了卡机是离开的就富利卡及是了的开发及拉考试及的福利科技阿斯利康的肌肤莱卡及时的离开福建阿斯顿发

                    _cookiesExtracted = true;
                    return _cookies;
                }
            }

            // Get ready to parse cookies (Expensive!!!)
            Object cookies = null;
            Object lastCookies = null;

            int version = 0;

            // For each cookie header
            Enumeration enm = _connection.getRequestFields().getValues(HttpHeaders.COOKIE_BUFFER);
            while (enm.hasMoreElements())
            {
                // Save a copy of the unparsed header as cache.
                String hdr = (String)enm.nextElement();
                lastCookies = LazyList.add(lastCookies, hdr);

                // Parse the header
                String name = null;
                String value = null;

                Cookie cookie = null;

                byte state = STATE_NAME;
                for (int i = 0, tokenstart = 0, length = hdr.length(); i < length; i++)
                {
                    char c = hdr.charAt(i);
                    switch (c)
                    {
                        case ',':
                        case ';':
                            switch (state)
                            {
                                case STATE_DELIMITER:
                                    state = STATE_NAME;
                                    tokenstart = i + 1;
                                    break;
                                case STATE_UNQUOTED_VALUE:
                                    state = STATE_NAME;
                                    value = hdr.substring(tokenstart, i).trim();
                                    if(isRequestedSessionIdFromURL())
                                        value = URIUtil.decodePath(value);
                                    tokenstart = i + 1;
                                    break;
                                case STATE_NAME:
                                    name = hdr.substring(tokenstart, i);
                                    value = "";
                                    tokenstart = i + 1;
                                    break;
                                case STATE_VALUE:
                                    state = STATE_NAME;
                                    value = "";
                                    tokenstart = i + 1;
                                    break;
                            }
                            break;
                        case '=':
                            switch (state)
                            {
                                case STATE_NAME:
                                    state = STATE_VALUE;
                                    name = hdr.substring(tokenstart, i);
                                    tokenstart = i + 1;
                                    break;
                                case STATE_VALUE:
                                    state = STATE_UNQUOTED_VALUE;
                                    tokenstart = i;
                                    break;
                            }
                            break;
                        case '"':
                            switch (state)
                            {
                                case STATE_VALUE:
                                    state = STATE_QUOTED_VALUE;
                                    tokenstart = i + 1;
                                    break;
                                case STATE_QUOTED_VALUE:
                                    state = STATE_DELIMITER;
                                    value = hdr.substring(tokenstart, i);
                                    break;
                            }
                            break;
                        case ' ':
                        case '\t':
                            break;
                        default:
                            switch (state)
                            {
                                case STATE_VALUE:
                                    state = STATE_UNQUOTED_VALUE;
                                    tokenstart = i;
                                    break;
                                case STATE_DELIMITER:
                                    state = STATE_NAME;
                                    tokenstart = i;
                                    break;
                            }
                    }

                    if (i + 1 == length)
                    {
                        switch (state)
                        {
                            case STATE_UNQUOTED_VALUE:
                                value = hdr.substring(tokenstart).trim();
                                if(isRequestedSessionIdFromURL())
                                    value = URIUtil.decodePath(value);
                                break;
                            case STATE_NAME:
                                name = hdr.substring(tokenstart);
                                value = "";
                                break;
                            case STATE_VALUE:
                                value = "";
                                break;
                        }
                    }

                    if (name != null && value != null)
                    {
                        name = name.trim();

                        try
                        {
                            if (name.startsWith("$"))
                            {
                                String lowercaseName = name.toLowerCase();
                                if ("$path".equals(lowercaseName))
                                {
                                    cookie.setPath(value);
                                }
                                else if ("$domain".equals(lowercaseName))
                                {
                                    cookie.setDomain(value);
                                }
                                else if ("$version".equals(lowercaseName))
                                {
                                    version = Integer.parseInt(value);
                                }
                            }
                            else
                            {
                                cookie = new Cookie(name, value);

                                if (version > 0)
                                {
                                    cookie.setVersion(version);
                                }

                                cookies = LazyList.add(cookies, cookie);
                            }
                        }
                        catch (Exception e)
                        {
                            Log.ignore(e);
                        }

                        name = null;
                        value = null;
                    }
                }
            }

            int l = LazyList.size(cookies);
            _cookiesExtracted = true;
            if (l>0)
            {
                if (_cookies == null || _cookies.length != l) _cookies = new Cookie[l];
                for (int i = 0; i < l; i++)
                    _cookies[i] = (Cookie) LazyList.get(cookies, i);

                l = LazyList.size(lastCookies);
                _lastCookies = new String[l];
                for (int i = 0; i < l; i++)
                    _lastCookies[i] = (String) LazyList.get(lastCookies, i);
            }
        }
        catch (Exception e)
        {
            Log.warn(e);
        }

        if (_cookies==null || _cookies.length==0)
            return null;
        return _cookies;
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.http.HttpServletRequest#getDateHeader(java.lang.String)
     */
    public long getDateHeader(String name)
    {
        return _connection.getRequestFields().getDateField(name);
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.http.HttpServletRequest#getHeader(java.lang.String)
     */
    public String getHeader(String name)
    {
        return _connection.getRequestFields().getStringField(name);
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.http.HttpServletRequest#getHeaderNames()
     */
    public Enumeration getHeaderNames()
    {
        return _connection.getRequestFields().getFieldNames();
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.http.HttpServletRequest#getHeaders(java.lang.String)
     */
    public Enumeration getHeaders(String name)
    {
        Enumeration e = _connection.getRequestFields().getValues(name);
        if (e==null)
            return Collections.enumeration(Collections.EMPTY_LIST);
        return e;
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getInputStream()
     */
    public ServletInputStream getInputStream() throws IOException
    {
        if (_inputState!=__NONE && _inputState!=_STREAM)
            throw new IllegalStateException("READER");
        _inputState=_STREAM;
        return _connection.getInputStream();
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.http.HttpServletRequest#getIntHeader(java.lang.String)
     */
    public int getIntHeader(String name)
    {
        return (int)_connection.getRequestFields().getLongField(name);
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getLocalAddr()
     */
    public String getLocalAddr()
    {
        return _endp==null?null:_endp.getLocalAddr();
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getLocale()
     */
    public Locale getLocale()
    {
        Enumeration enm = _connection.getRequestFields().getValues(HttpHeaders.ACCEPT_LANGUAGE, HttpFields.__separators);
        
        // handle no locale
        if (enm == null || !enm.hasMoreElements())
            return Locale.getDefault();
        
        // sort the list in quality order
        List acceptLanguage = HttpFields.qualityList(enm);
        if (acceptLanguage.size()==0)
            return  Locale.getDefault();
        
        int size=acceptLanguage.size();
        
        // convert to locals
        for (int i=0; i<size; i++)
        {
            String language = (String)acceptLanguage.get(i);
            language=HttpFields.valueParameters(language,null);
            String country = "";
            int dash = language.indexOf('-');
            if (dash > -1)
            {
                country = language.substring(dash + 1).trim();
                language = language.substring(0,dash).trim();
            }
            return new Locale(language,country);
        }
        
        return  Locale.getDefault();
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getLocales()
     */
    public Enumeration getLocales()
    {

        Enumeration enm = _connection.getRequestFields().getValues(HttpHeaders.ACCEPT_LANGUAGE, HttpFields.__separators);
        
        // handle no locale
        if (enm == null || !enm.hasMoreElements())
            return Collections.enumeration(__defaultLocale);
        
        // sort the list in quality order
        List acceptLanguage = HttpFields.qualityList(enm);
        
        if (acceptLanguage.size()==0)
            return
            Collections.enumeration(__defaultLocale);
        
        Object langs = null;
        int size=acceptLanguage.size();
        
        // convert to locals
        for (int i=0; i<size; i++)
        {
            String language = (String)acceptLanguage.get(i);
            language=HttpFields.valueParameters(language,null);
            String country = "";
            int dash = language.indexOf('-');
            if (dash > -1)
            {
                country = language.substring(dash + 1).trim();
                language = language.substring(0,dash).trim();
            }
            langs=LazyList.ensureSize(langs,size);
            langs=LazyList.add(langs,new Locale(language,country));
        }
        
        if (LazyList.size(langs)==0)
            return Collections.enumeration(__defaultLocale);
        
        return Collections.enumeration(LazyList.getList(langs));
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getLocalName()
     */
    public String getLocalName()
    {
        if (_dns)
            return _endp==null?null:_endp.getLocalHost();
        return _endp==null?null:_endp.getLocalAddr();
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getLocalPort()
     */
    public int getLocalPort()
    {
        return _endp==null?0:_endp.getLocalPort();
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.http.HttpServletRequest#getMethod()
     */
    public String getMethod()
    {
        return _method;
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getParameter(java.lang.String)
     */
    public String getParameter(String name)
    {
        if (!_paramsExtracted) 
            extractParameters();
        return (String) _parameters.getValue(name, 0);
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getParameterMap()
     */
    public Map getParameterMap()
    {
        if (!_paramsExtracted) 
            extractParameters();
        
        return Collections.unmodifiableMap(_parameters.toStringArrayMap());
    }

    /* ------------------------------------------------------------ */
    /* 
     * @see javax.servlet.ServletRequest#getParameterNames()