Mercurial Hosting > luan
view src/org/eclipse/jetty/server/Request.java @ 995:0eba8f555c19
remove Server.Graceful
author | Franklin Schmidt <fschmidt@gmail.com> |
---|---|
date | Tue, 18 Oct 2016 18:38:05 -0600 |
parents | 4e9d373bf6e9 |
children | 7d28be82ab75 |
line wrap: on
line source
// // ======================================================================== // 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.BufferedReader; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import java.net.InetAddress; import java.nio.ByteBuffer; import java.security.Principal; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.TimeZone; import java.util.Collection; import java.util.Collections; import java.util.Enumeration; import java.util.EventListener; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Map.Entry; import javax.servlet.AsyncContext; import javax.servlet.AsyncEvent; import javax.servlet.AsyncListener; import javax.servlet.DispatcherType; import javax.servlet.RequestDispatcher; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.ServletInputStream; import javax.servlet.ServletRequest; import javax.servlet.ServletRequestAttributeEvent; import javax.servlet.ServletRequestAttributeListener; import javax.servlet.ServletRequestEvent; import javax.servlet.ServletRequestListener; import javax.servlet.ServletResponse; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import javax.servlet.http.Part; import org.eclipse.jetty.http.HttpCookie; import org.eclipse.jetty.http.HttpFields; 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.io.Buffer; import org.eclipse.jetty.io.BufferUtil; import org.eclipse.jetty.io.ByteArrayBuffer; import org.eclipse.jetty.io.EndPoint; import org.eclipse.jetty.io.nio.DirectNIOBuffer; import org.eclipse.jetty.io.nio.IndirectNIOBuffer; import org.eclipse.jetty.io.nio.NIOBuffer; import org.eclipse.jetty.server.handler.ContextHandler; import org.eclipse.jetty.util.Attributes; import org.eclipse.jetty.util.AttributesMap; import org.eclipse.jetty.util.IO; import org.eclipse.jetty.util.LazyList; import org.eclipse.jetty.util.MultiException; import org.eclipse.jetty.util.MultiMap; import org.eclipse.jetty.util.StringUtil; import org.eclipse.jetty.util.URIUtil; import org.eclipse.jetty.util.UrlEncoded; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /* ------------------------------------------------------------ */ /** * Jetty Request. * <p> * Implements {@link javax.servlet.http.HttpServletRequest} from the <code>javax.servlet.http</code> package. * </p> * <p> * The standard interface of mostly getters, is extended with setters so that the request is mutable by the handlers that it is passed to. This allows the * request object to be as lightweight as possible and not actually implement any significant behavior. For example * <ul> * * <li>The {@link Request#getContextPath()} method will return null, until the request has been passed to a {@link ContextHandler} which matches the * {@link Request#getPathInfo()} with a context path and calls {@link Request#setContextPath(String)} as a result.</li> * * <li>The {@link Request#getServletPath()} method will return null until the request has been passed to a <code>org.eclipse.jetty.servlet.ServletHandler</code> * and the pathInfo matched against the servlet URL patterns and {@link Request#setServletPath(String)} called as a result.</li> * </ul> * * A request instance is created for each {@link AbstractHttpConnection} accepted by the server and recycled for each HTTP request received via that connection. * An effort is made to avoid reparsing headers and cookies that are likely to be the same for requests from the same connection. * * <p> * The form content that a request can process is limited to protect from Denial of Service attacks. The size in bytes is limited by * {@link ContextHandler#getMaxFormContentSize()} or if there is no context then the "org.eclipse.jetty.server.Request.maxFormContentSize" {@link Server} * attribute. The number of parameters keys is limited by {@link ContextHandler#getMaxFormKeys()} or if there is no context then the * "org.eclipse.jetty.server.Request.maxFormKeys" {@link Server} attribute. * * */ public final class Request implements HttpServletRequest { public static final String __MULTIPART_CONFIG_ELEMENT = "org.eclipse.multipartConfig"; public static final String __MULTIPART_INPUT_STREAM = "org.eclipse.multiPartInputStream"; public static final String __MULTIPART_CONTEXT = "org.eclipse.multiPartContext"; private static final Logger LOG = LoggerFactory.getLogger(Request.class); private static final String __ASYNC_FWD = "org.eclipse.asyncfwd"; private static final Collection __defaultLocale = Collections.singleton(Locale.getDefault()); private static final int __NONE = 0, _STREAM = 1, __READER = 2; private volatile Attributes _attributes; private MultiMap<String> _baseParameters; private String _characterEncoding; protected AbstractHttpConnection _connection; public ContextHandler _contextHandler = null; private String _contextPath; private CookieCutter _cookies; private boolean _cookiesExtracted = false; private EndPoint _endp; private boolean _handled = false; private int _inputState = __NONE; private String _method; private MultiMap<String> _parameters; private boolean _paramsExtracted; private String _pathInfo; private int _port; private String _protocol = HttpVersions.HTTP_1_1; private String _queryString; private BufferedReader _reader; private String _readerEncoding; private String _remoteAddr; private String _remoteHost; private String _requestURI; private String _scheme = URIUtil.HTTP; private String _serverName; private String _servletPath; private long _timeStamp; private long _dispatchTime; private Buffer _timeStampBuffer; private HttpURI _uri; /* ------------------------------------------------------------ */ public Request() { } /* ------------------------------------------------------------ */ public Request(AbstractHttpConnection connection) { setConnection(connection); } /* ------------------------------------------------------------ */ /** * Extract Parameters from query string and/or form _content. */ public void extractParameters() { if (_baseParameters == null) _baseParameters = new MultiMap(16); if (_paramsExtracted) { if (_parameters == null) _parameters = _baseParameters; return; } _paramsExtracted = true; try { // Handle query string if (_uri != null && _uri.hasQuery()) { _uri.decodeQueryTo(_baseParameters); } // handle any _content. String encoding = getCharacterEncoding(); String content_type = getContentType(); if (content_type != null && content_type.length() > 0) { content_type = HttpFields.valueParameters(content_type,null); if (MimeTypes.FORM_ENCODED.equalsIgnoreCase(content_type) && _inputState == __NONE && (HttpMethods.POST.equals(getMethod()) || HttpMethods.PUT.equals(getMethod()))) { int content_length = getContentLength(); if (content_length != 0) { try { int maxFormContentSize = -1; int maxFormKeys = -1; if (maxFormContentSize < 0) { maxFormContentSize = 200000; } if (maxFormKeys < 0) { maxFormKeys = 1000; } if (content_length > maxFormContentSize && maxFormContentSize > 0) { throw new IllegalStateException("Form too large " + content_length + ">" + maxFormContentSize); } InputStream in = getInputStream(); // Add form params to query params UrlEncoded.decodeTo(in,_baseParameters,encoding,content_length < 0?maxFormContentSize:-1,maxFormKeys); } catch (IOException e) { if (LOG.isDebugEnabled()) LOG.warn("",e); else LOG.warn(e.toString()); } } } } if (_parameters == null) _parameters = _baseParameters; else if (_parameters != _baseParameters) { // Merge parameters (needed if parameters extracted after a forward). Iterator iter = _baseParameters.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = (Map.Entry)iter.next(); String name = (String)entry.getKey(); Object values = entry.getValue(); for (int i = 0; i < LazyList.size(values); i++) _parameters.add(name,LazyList.get(values,i)); } } if (content_type != null && content_type.length()>0 && content_type.startsWith("multipart/form-data") && getAttribute(__MULTIPART_CONFIG_ELEMENT)!=null) { try { getParts(); } catch (IOException e) { if (LOG.isDebugEnabled()) LOG.warn("",e); else LOG.warn(e.toString()); } catch (ServletException e) { if (LOG.isDebugEnabled()) LOG.warn("",e); else LOG.warn(e.toString()); } } } finally { // ensure params always set (even if empty) after extraction if (_parameters == null) _parameters = _baseParameters; } } /* ------------------------------------------------------------ */ public AsyncContext getAsyncContext() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getAttribute(java.lang.String) */ public Object getAttribute(String name) { if ("org.eclipse.jetty.io.EndPoint.maxIdleTime".equalsIgnoreCase(name)) return new Long(getConnection().getEndPoint().getMaxIdleTime()); Object attr = (_attributes == null)?null:_attributes.getAttribute(name); return attr; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getAttributeNames() */ public Enumeration getAttributeNames() { if (_attributes == null) return Collections.enumeration(Collections.EMPTY_LIST); return AttributesMap.getAttributeNamesCopy(_attributes); } /* ------------------------------------------------------------ */ /* */ public Attributes getAttributes() { if (_attributes == null) _attributes = new AttributesMap(); return _attributes; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getAuthType() */ public String getAuthType() { return null; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getCharacterEncoding() */ public String getCharacterEncoding() { return _characterEncoding; } /* ------------------------------------------------------------ */ /** * @return Returns the connection. */ public AbstractHttpConnection getConnection() { return _connection; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getContentLength() */ public int getContentLength() { return (int)_connection._requestFields.getLongField(HttpHeaders.CONTENT_LENGTH_BUFFER); } public long getContentRead() { if (_connection == null) return -1; return _connection._parser.getContentRead(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getContentType() */ public String getContentType() { return _connection._requestFields.getStringField(HttpHeaders.CONTENT_TYPE_BUFFER); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getContextPath() */ public String getContextPath() { return _contextPath; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getCookies() */ public Cookie[] getCookies() { if (_cookiesExtracted) return _cookies == null?null:_cookies.getCookies(); _cookiesExtracted = true; Enumeration enm = _connection._requestFields.getValues(HttpHeaders.COOKIE_BUFFER); // Handle no cookies if (enm != null) { if (_cookies == null) _cookies = new CookieCutter(); while (enm.hasMoreElements()) { String c = (String)enm.nextElement(); _cookies.addCookieField(c); } } return _cookies == null?null:_cookies.getCookies(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getDateHeader(java.lang.String) */ public long getDateHeader(String name) { return _connection._requestFields.getDateField(name); } @Override public DispatcherType getDispatcherType() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getHeader(java.lang.String) */ public String getHeader(String name) { return _connection._requestFields.getStringField(name); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getHeaderNames() */ public Enumeration getHeaderNames() { return _connection._requestFields.getFieldNames(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getHeaders(java.lang.String) */ public Enumeration getHeaders(String name) { Enumeration e = _connection._requestFields.getValues(name); if (e == null) return Collections.enumeration(Collections.EMPTY_LIST); return e; } /* ------------------------------------------------------------ */ /** * @return Returns the inputState. */ public int getInputState() { return _inputState; } /* ------------------------------------------------------------ */ /* * @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._requestFields.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._requestFields.getValues( "Accept-Language", ", \t" ); // 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(); if (size > 0) { String language = (String)acceptLanguage.get(0); 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._requestFields.getValues( "Accept-Language", ", \t" ); // 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 (_endp == null) return null; String local = _endp.getLocalAddr(); if (local != null && local.indexOf(':') >= 0) local = "[" + local + "]"; return local; } /* ------------------------------------------------------------ */ /* * @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() */ public Enumeration getParameterNames() { if (!_paramsExtracted) extractParameters(); return Collections.enumeration(_parameters.keySet()); } /* ------------------------------------------------------------ */ /** * @return Returns the parameters. */ public MultiMap<String> getParameters() { return _parameters; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getParameterValues(java.lang.String) */ public String[] getParameterValues(String name) { if (!_paramsExtracted) extractParameters(); List<Object> vals = _parameters.getValues(name); if (vals == null) return null; return vals.toArray(new String[vals.size()]); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getPathInfo() */ public String getPathInfo() { return _pathInfo; } @Override public String getPathTranslated() { return null; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getProtocol() */ public String getProtocol() { return _protocol; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getQueryString() */ public String getQueryString() { if (_queryString == null && _uri != null) { _queryString = _uri.getQuery(); } return _queryString; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getReader() */ public BufferedReader getReader() throws IOException { if (_inputState != __NONE && _inputState != __READER) throw new IllegalStateException("STREAMED"); if (_inputState == __READER) return _reader; String encoding = getCharacterEncoding(); if (encoding == null) encoding = StringUtil.__ISO_8859_1; if (_reader == null || !encoding.equalsIgnoreCase(_readerEncoding)) { final ServletInputStream in = getInputStream(); _readerEncoding = encoding; _reader = new BufferedReader(new InputStreamReader(in,encoding)) { @Override public void close() throws IOException { in.close(); } }; } _inputState = __READER; return _reader; } @Override public String getRealPath(String path) { return null; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getRemoteAddr() */ public String getRemoteAddr() { if (_remoteAddr != null) return _remoteAddr; return _endp == null?null:_endp.getRemoteAddr(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getRemoteHost() */ public String getRemoteHost() { return getRemoteAddr(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getRemotePort() */ public int getRemotePort() { return _endp == null?0:_endp.getRemotePort(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getRemoteUser() */ public String getRemoteUser() { Principal p = getUserPrincipal(); if (p == null) return null; return p.getName(); } @Override public RequestDispatcher getRequestDispatcher(String path) { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getRequestedSessionId() */ public String getRequestedSessionId() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getRequestURI() */ public String getRequestURI() { if (_requestURI == null && _uri != null) _requestURI = _uri.getPathAndParam(); return _requestURI; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getRequestURL() */ public StringBuffer getRequestURL() { final StringBuffer url = new StringBuffer(48); synchronized (url) { String scheme = getScheme(); int port = getServerPort(); url.append(scheme); url.append("://"); url.append(getServerName()); if (_port > 0 && ((scheme.equalsIgnoreCase(URIUtil.HTTP) && port != 80) || (scheme.equalsIgnoreCase(URIUtil.HTTPS) && port != 443))) { url.append(':'); url.append(_port); } url.append(getRequestURI()); return url; } } /* ------------------------------------------------------------ */ public Response getResponse() { return _connection._response; } /* ------------------------------------------------------------ */ /** * Reconstructs the URL the client used to make the request. The returned URL contains a protocol, server name, port number, and, but it does not include a * path. * <p> * Because this method returns a <code>StringBuffer</code>, not a string, you can modify the URL easily, for example, to append path and query parameters. * * This method is useful for creating redirect messages and for reporting errors. * * @return "scheme://host:port" */ public StringBuilder getRootURL() { StringBuilder url = new StringBuilder(48); String scheme = getScheme(); int port = getServerPort(); url.append(scheme); url.append("://"); url.append(getServerName()); if (port > 0 && ((scheme.equalsIgnoreCase("http") && port != 80) || (scheme.equalsIgnoreCase("https") && port != 443))) { url.append(':'); url.append(port); } return url; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getScheme() */ public String getScheme() { return _scheme; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getServerName() */ public String getServerName() { // Return already determined host if (_serverName != null) return _serverName; if (_uri == null) throw new IllegalStateException("No uri"); // Return host from absolute URI _serverName = _uri.getHost(); _port = _uri.getPort(); if (_serverName != null) return _serverName; // Return host from header field Buffer hostPort = _connection._requestFields.get(HttpHeaders.HOST_BUFFER); if (hostPort != null) { loop: for (int i = hostPort.putIndex(); i-- > hostPort.getIndex();) { char ch = (char)(0xff & hostPort.peek(i)); switch (ch) { case ']': break loop; case ':': _serverName = BufferUtil.to8859_1_String(hostPort.peek(hostPort.getIndex(),i - hostPort.getIndex())); try { _port = BufferUtil.toInt(hostPort.peek(i + 1,hostPort.putIndex() - i - 1)); } catch (NumberFormatException e) { try { if (_connection != null) _connection._generator.sendError(HttpStatus.BAD_REQUEST_400,"Bad Host header",null,true); } catch (IOException e1) { throw new RuntimeException(e1); } } return _serverName; } } if (_serverName == null || _port < 0) { _serverName = BufferUtil.to8859_1_String(hostPort); _port = 0; } return _serverName; } // Return host from connection if (_connection != null) { _serverName = getLocalName(); _port = getLocalPort(); if (_serverName != null && !StringUtil.ALL_INTERFACES.equals(_serverName)) return _serverName; } // Return the local host try { _serverName = InetAddress.getLocalHost().getHostAddress(); } catch (java.net.UnknownHostException e) { LOG.trace("",e); } return _serverName; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getServerPort() */ public int getServerPort() { if (_port <= 0) { if (_serverName == null) getServerName(); if (_port <= 0) { if (_serverName != null && _uri != null) _port = _uri.getPort(); else _port = _endp == null?0:_endp.getLocalPort(); } } if (_port <= 0) { if (getScheme().equalsIgnoreCase(URIUtil.HTTPS)) return 443; return 80; } return _port; } @Override public ServletContext getServletContext() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getServletPath() */ public String getServletPath() { if (_servletPath == null) _servletPath = ""; return _servletPath; } /* ------------------------------------------------------------ */ public ServletResponse getServletResponse() { return _connection.getResponse(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getSession() */ public HttpSession getSession() { return getSession(true); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getSession(boolean) */ public HttpSession getSession(boolean create) { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /** * Get Request TimeStamp * * @return The time that the request was received. */ public long getTimeStamp() { return _timeStamp; } /* ------------------------------------------------------------ */ /** * Get Request TimeStamp * * @return The time that the request was received. */ public Buffer getTimeStampBuffer() { if (_timeStampBuffer == null && _timeStamp > 0) _timeStampBuffer = formatBuffer(_timeStamp); return _timeStampBuffer; } /* ------------------------------------------------------------ */ /** * @return Returns the uri. */ public HttpURI getUri() { return _uri; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#getUserPrincipal() */ public Principal getUserPrincipal() { return null; } /* ------------------------------------------------------------ */ /** * Get timestamp of the request dispatch * * @return timestamp */ public long getDispatchTime() { return _dispatchTime; } /* ------------------------------------------------------------ */ public boolean isHandled() { return _handled; } public boolean isAsyncStarted() { return false; } public boolean isAsyncSupported() { return false; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromCookie() */ public boolean isRequestedSessionIdFromCookie() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromUrl() */ public boolean isRequestedSessionIdFromUrl() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromURL() */ public boolean isRequestedSessionIdFromURL() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdValid() */ public boolean isRequestedSessionIdValid() { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#isSecure() */ public boolean isSecure() { return _connection.getConnector().isConfidential(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.http.HttpServletRequest#isUserInRole(java.lang.String) */ public boolean isUserInRole(String role) { return false; } /* ------------------------------------------------------------ */ public HttpSession recoverNewSession(Object key) { throw new UnsupportedOperationException(); } protected void recycle() { if (_inputState == __READER) { try { int r = _reader.read(); while (r != -1) r = _reader.read(); } catch (Exception e) { LOG.trace("",e); _reader = null; } } _handled = false; if (_contextHandler != null) throw new IllegalStateException("Request in context!"); if (_attributes != null) _attributes.clearAttributes(); _characterEncoding = null; _contextPath = null; if (_cookies != null) _cookies.reset(); _cookiesExtracted = false; _serverName = null; _method = null; _pathInfo = null; _port = 0; _protocol = HttpVersions.HTTP_1_1; _queryString = null; _requestURI = null; _scheme = URIUtil.HTTP; _servletPath = null; _timeStamp = 0; _timeStampBuffer = null; _uri = null; if (_baseParameters != null) _baseParameters.clear(); _parameters = null; _paramsExtracted = false; _inputState = __NONE; } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#removeAttribute(java.lang.String) */ public void removeAttribute(String name) { if (_attributes != null) _attributes.removeAttribute(name); } /* ------------------------------------------------------------ */ /* * Set a request attribute. if the attribute name is "org.eclipse.jetty.server.server.Request.queryEncoding" then the value is also passed in a call to * {@link #setQueryEncoding}. <p> if the attribute name is "org.eclipse.jetty.server.server.ResponseBuffer", then the response buffer is flushed with @{link * #flushResponseBuffer} <p> if the attribute name is "org.eclipse.jetty.io.EndPoint.maxIdleTime", then the value is passed to the associated {@link * EndPoint#setMaxIdleTime}. * * @see javax.servlet.ServletRequest#setAttribute(java.lang.String, java.lang.Object) */ public void setAttribute(String name, Object value) { if (_attributes == null) _attributes = new AttributesMap(); _attributes.setAttribute(name,value); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#setCharacterEncoding(java.lang.String) */ public void setCharacterEncoding(String encoding) throws UnsupportedEncodingException { if (_inputState != __NONE) return; _characterEncoding = encoding; // check encoding is supported if (!StringUtil.isUTF8(encoding)) // noinspection ResultOfMethodCallIgnored "".getBytes(encoding); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#setCharacterEncoding(java.lang.String) */ public void setCharacterEncodingUnchecked(String encoding) { _characterEncoding = encoding; } /* ------------------------------------------------------------ */ // final so we can safely call this from constructor protected final void setConnection(AbstractHttpConnection connection) { _connection = connection; _endp = connection.getEndPoint(); } /* ------------------------------------------------------------ */ /* * @see javax.servlet.ServletRequest#getContentType() */ public void setContentType(String contentType) { _connection._requestFields.put(HttpHeaders.CONTENT_TYPE_BUFFER,contentType); } /* ------------------------------------------------------------ */ /** * Sets the "context path" for this request * * @see HttpServletRequest#getContextPath() */ public void setContextPath(String contextPath) { _contextPath = contextPath; } /* ------------------------------------------------------------ */ /** * @param cookies * The cookies to set. */ public void setCookies(Cookie[] cookies) { if (_cookies == null) _cookies = new CookieCutter(); _cookies.setCookies(cookies); } /* ------------------------------------------------------------ */ public void setHandled(boolean h) { _handled = h; } /* ------------------------------------------------------------ */ /** * @param method * The method to set. */ public void setMethod(String method) { _method = method; } /* ------------------------------------------------------------ */ /** * @param parameters * The parameters to set. */ public void setParameters(MultiMap<String> parameters) { _parameters = (parameters == null)?_baseParameters:parameters; if (_paramsExtracted && _parameters == null) throw new IllegalStateException(); } /* ------------------------------------------------------------ */ /** * @param pathInfo * The pathInfo to set. */ public void setPathInfo(String pathInfo) { _pathInfo = pathInfo; } /* ------------------------------------------------------------ */ /** * @param protocol * The protocol to set. */ public void setProtocol(String protocol) { _protocol = protocol; } /* ------------------------------------------------------------ */ /** * @param queryString * The queryString to set. */ public void setQueryString(String queryString) { _queryString = queryString; } /* ------------------------------------------------------------ */ /** * @param addr * The address to set. */ public void setRemoteAddr(String addr) { _remoteAddr = addr; } /* ------------------------------------------------------------ */ /** * @param host * The host to set. */ public void setRemoteHost(String host) { _remoteHost = host; } /* ------------------------------------------------------------ */ /** * @param requestURI * The requestURI to set. */ public void setRequestURI(String requestURI) { _requestURI = requestURI; } /* ------------------------------------------------------------ */ /** * @param scheme * The scheme to set. */ public void setScheme(String scheme) { _scheme = scheme; } /* ------------------------------------------------------------ */ /** * @param host * The host to set. */ public void setServerName(String host) { _serverName = host; } /* ------------------------------------------------------------ */ /** * @param port * The port to set. */ public void setServerPort(int port) { _port = port; } /* ------------------------------------------------------------ */ /** * @param servletPath * The servletPath to set. */ public void setServletPath(String servletPath) { _servletPath = servletPath; } /* ------------------------------------------------------------ */ public void setTimeStamp(long ts) { _timeStamp = ts; } /* ------------------------------------------------------------ */ /** * @param uri * The uri to set. */ public void setUri(HttpURI uri) { _uri = uri; } /* ------------------------------------------------------------ */ /** * Set timetstamp of request dispatch * * @param value * timestamp */ public void setDispatchTime(long value) { _dispatchTime = value; } /* ------------------------------------------------------------ */ public AsyncContext startAsync() throws IllegalStateException { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ @Override public String toString() { return (_handled?"[":"(") + getMethod() + " " + _uri + (_handled?"]@":")@") + hashCode() + " " + super.toString(); } /* ------------------------------------------------------------ */ public boolean authenticate(HttpServletResponse response) throws IOException, ServletException { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ public Part getPart(String name) throws IOException, ServletException { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ public Collection<Part> getParts() throws IOException, ServletException { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ public void login(String username, String password) throws ServletException { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ public void logout() throws ServletException { throw new UnsupportedOperationException(); } /* ------------------------------------------------------------ */ /** * Merge in a new query string. The query string is merged with the existing parameters and {@link #setParameters(MultiMap)} and * {@link #setQueryString(String)} are called with the result. The merge is according to the rules of the servlet dispatch forward method. * * @param query * The query string to merge into the request. */ public void mergeQueryString(String query) { // extract parameters from dispatch query MultiMap<String> parameters = new MultiMap<String>(); UrlEncoded.decodeTo(query,parameters, StringUtil.__UTF8); //have to assume UTF-8 because we can't know otherwise boolean merge_old_query = false; // Have we evaluated parameters if (!_paramsExtracted) extractParameters(); // Are there any existing parameters? if (_parameters != null && _parameters.size() > 0) { // Merge parameters; new parameters of the same name take precedence. Iterator<Entry<String, Object>> iter = _parameters.entrySet().iterator(); while (iter.hasNext()) { Map.Entry<String, Object> entry = iter.next(); String name = entry.getKey(); // If the names match, we will need to remake the query string if (parameters.containsKey(name)) merge_old_query = true; // Add the old values to the new parameter map Object values = entry.getValue(); for (int i = 0; i < LazyList.size(values); i++) parameters.add(name,LazyList.get(values,i)); } } if (_queryString != null && _queryString.length() > 0) { if (merge_old_query) { StringBuilder overridden_query_string = new StringBuilder(); MultiMap<String> overridden_old_query = new MultiMap<String>(); UrlEncoded.decodeTo(_queryString,overridden_old_query,null);//decode using any queryencoding set for the request MultiMap<String> overridden_new_query = new MultiMap<String>(); UrlEncoded.decodeTo(query,overridden_new_query,StringUtil.__UTF8); //have to assume utf8 as we cannot know otherwise Iterator<Entry<String, Object>> iter = overridden_old_query.entrySet().iterator(); while (iter.hasNext()) { Map.Entry<String, Object> entry = iter.next(); String name = entry.getKey(); if (!overridden_new_query.containsKey(name)) { Object values = entry.getValue(); for (int i = 0; i < LazyList.size(values); i++) { overridden_query_string.append("&").append(name).append("=").append((Object)LazyList.get(values,i)); } } } query = query + overridden_query_string; } else { query = query + "&" + _queryString; } } setParameters(parameters); setQueryString(query); } private static Buffer _buffer; private static String _last; private static final DateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US); static { dateFormat.setTimeZone(TimeZone.getTimeZone("GMT")); } private static Buffer formatBuffer(long date) { synchronized(dateFormat) { String d = dateFormat.format(date); if (d==_last) return _buffer; _last=d; _buffer=new ByteArrayBuffer(d); return _buffer; } } }