init

java/javax/servlet/AsyncContext.java

@@ -0,0 +1,106 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+/**
+ * TODO SERVLET3 - Add comments
+ * @since Servlet 3.0
+ */
+public interface AsyncContext {
+    public static final String ASYNC_REQUEST_URI =
+            "javax.servlet.async.request_uri";
+    public static final String ASYNC_CONTEXT_PATH  =
+            "javax.servlet.async.context_path";
+    public static final String ASYNC_PATH_INFO =
+            "javax.servlet.async.path_info";
+    public static final String ASYNC_SERVLET_PATH =
+            "javax.servlet.async.servlet_path";
+    public static final String ASYNC_QUERY_STRING =
+            "javax.servlet.async.query_string";
+
+    ServletRequest getRequest();
+
+    ServletResponse getResponse();
+
+    boolean hasOriginalRequestAndResponse();
+
+    /**
+     * @throws IllegalStateException if this method is called when the request
+     * is not in asynchronous mode. The request is in asynchronous mode after
+     * {@link javax.servlet.http.HttpServletRequest#startAsync()} or
+     * {@link javax.servlet.http.HttpServletRequest#startAsync(ServletRequest,
+     * ServletResponse)} has been called and before {@link #complete()} or any
+     * other dispatch() method has been called.
+     */
+    void dispatch();
+
+    /**
+     * @param path The path to which the request/response should be dispatched
+     *             relative to the {@link ServletContext} from which this async
+     *             request was started.
+     *
+     * @throws IllegalStateException if this method is called when the request
+     * is not in asynchronous mode. The request is in asynchronous mode after
+     * {@link javax.servlet.http.HttpServletRequest#startAsync()} or
+     * {@link javax.servlet.http.HttpServletRequest#startAsync(ServletRequest,
+     * ServletResponse)} has been called and before {@link #complete()} or any
+     * other dispatch() method has been called.
+     */
+    void dispatch(String path);
+
+    /**
+     * @param path The path to which the request/response should be dispatched
+     *             relative to the specified {@link ServletContext}.
+     * @param context The {@link ServletContext} to which the request/response
+     *                should be dispatched.
+     *
+     * @throws IllegalStateException if this method is called when the request
+     * is not in asynchronous mode. The request is in asynchronous mode after
+     * {@link javax.servlet.http.HttpServletRequest#startAsync()} or
+     * {@link javax.servlet.http.HttpServletRequest#startAsync(ServletRequest,
+     * ServletResponse)} has been called and before {@link #complete()} or any
+     * other dispatch() method has been called.
+     */
+    void dispatch(ServletContext context, String path);
+
+    void complete();
+
+    void start(Runnable run);
+
+    void addListener(AsyncListener listener);
+
+    void addListener(AsyncListener listener, ServletRequest request,
+            ServletResponse response);
+
+    <T extends AsyncListener> T createListener(Class<T> clazz)
+    throws ServletException;
+
+    /**
+     * Set the timeout.
+     *
+     * @param timeout The timeout in milliseconds. 0 or less indicates no
+     *                timeout.
+     */
+    void setTimeout(long timeout);
+
+    /**
+     * Get the current timeout.
+     *
+     * @return The timeout in milliseconds. 0 or less indicates no timeout.
+     */
+    long getTimeout();
+}

java/javax/servlet/AsyncEvent.java

@@ -0,0 +1,74 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+/**
+ * TODO SERVLET3 - Add comments
+ * @since Servlet 3.0
+ */
+public class AsyncEvent {
+    private final AsyncContext context;
+    private final ServletRequest request;
+    private final ServletResponse response;
+    private final Throwable throwable;
+
+    public AsyncEvent(AsyncContext context) {
+        this.context = context;
+        this.request = null;
+        this.response = null;
+        this.throwable = null;
+    }
+
+    public AsyncEvent(AsyncContext context, ServletRequest request,
+            ServletResponse response) {
+        this.context = context;
+        this.request = request;
+        this.response = response;
+        this.throwable = null;
+    }
+
+    public AsyncEvent(AsyncContext context, Throwable throwable) {
+        this.context = context;
+        this.throwable = throwable;
+        this.request = null;
+        this.response = null;
+    }
+
+    public AsyncEvent(AsyncContext context, ServletRequest request,
+            ServletResponse response, Throwable throwable) {
+        this.context = context;
+        this.request = request;
+        this.response = response;
+        this.throwable = throwable;
+    }
+
+    public AsyncContext getAsyncContext() {
+        return context;
+    }
+
+    public ServletRequest getSuppliedRequest() {
+        return request;
+    }
+
+    public ServletResponse getSuppliedResponse() {
+        return response;
+    }
+
+    public Throwable getThrowable() {
+        return throwable;
+    }
+}

java/javax/servlet/AsyncListener.java

@@ -0,0 +1,31 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.io.IOException;
+import java.util.EventListener;
+
+/**
+ * TODO SERVLET3 - Add comments
+ * @since Servlet 3.0
+ */
+public interface AsyncListener extends EventListener {
+    void onComplete(AsyncEvent event) throws IOException;
+    void onTimeout(AsyncEvent event) throws IOException;
+    void onError(AsyncEvent event) throws IOException;
+    void onStartAsync(AsyncEvent event) throws IOException;
+}

java/javax/servlet/DispatcherType.java

@@ -0,0 +1,28 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+/**
+ * @since Servlet 3.0
+ */
+public enum DispatcherType {
+    FORWARD,
+    INCLUDE,
+    REQUEST,
+    ASYNC,
+    ERROR
+}

java/javax/servlet/Filter.java

@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+
+/**
+ * A filter is an object that performs filtering tasks on either the request to
+ * a resource (a servlet or static content), or on the response from a resource,
+ * or both. <br>
+ * <br>
+ * Filters perform filtering in the <code>doFilter</code> method. Every Filter
+ * has access to a FilterConfig object from which it can obtain its
+ * initialization parameters, a reference to the ServletContext which it can
+ * use, for example, to load resources needed for filtering tasks.
+ * <p>
+ * Filters are configured in the deployment descriptor of a web application
+ * <p>
+ * Examples that have been identified for this design are<br>
+ * 1) Authentication Filters <br>
+ * 2) Logging and Auditing Filters <br>
+ * 3) Image conversion Filters <br>
+ * 4) Data compression Filters <br>
+ * 5) Encryption Filters <br>
+ * 6) Tokenizing Filters <br>
+ * 7) Filters that trigger resource access events <br>
+ * 8) XSL/T filters <br>
+ * 9) Mime-type chain Filter <br>
+ *
+ * @since Servlet 2.3
+ */
+public interface Filter {
+
+    /**
+     * Called by the web container to indicate to a filter that it is being
+     * placed into service. The servlet container calls the init method exactly
+     * once after instantiating the filter. The init method must complete
+     * successfully before the filter is asked to do any filtering work.
+     * <p>
+     * The web container cannot place the filter into service if the init method
+     * either:
+     * <ul>
+     * <li>Throws a ServletException</li>
+     * <li>Does not return within a time period defined by the web
+     *     container</li>
+     * </ul>
+     *
+     * @param filterConfig The configuration information associated with the
+     *                     filter instance being initialised
+     *
+     * @throws ServletException if the initialisation fails
+     */
+    public void init(FilterConfig filterConfig) throws ServletException;
+
+    /**
+     * The <code>doFilter</code> method of the Filter is called by the container
+     * each time a request/response pair is passed through the chain due to a
+     * client request for a resource at the end of the chain. The FilterChain
+     * passed in to this method allows the Filter to pass on the request and
+     * response to the next entity in the chain.
+     * <p>
+     * A typical implementation of this method would follow the following
+     * pattern:- <br>
+     * 1. Examine the request<br>
+     * 2. Optionally wrap the request object with a custom implementation to
+     * filter content or headers for input filtering <br>
+     * 3. Optionally wrap the response object with a custom implementation to
+     * filter content or headers for output filtering <br>
+     * 4. a) <strong>Either</strong> invoke the next entity in the chain using
+     * the FilterChain object (<code>chain.doFilter()</code>), <br>
+     * 4. b) <strong>or</strong> not pass on the request/response pair to the
+     * next entity in the filter chain to block the request processing<br>
+     * 5. Directly set headers on the response after invocation of the next
+     * entity in the filter chain.
+     *
+     * @param request  The request to process
+     * @param response The response associated with the request
+     * @param chain    Provides access to the next filter in the chain for this
+     *                 filter to pass the request and response to for further
+     *                 processing
+     *
+     * @throws IOException if an I/O error occurs during this filter's
+     *                     processing of the request
+     * @throws ServletException if the processing fails for any other reason
+     */
+    public void doFilter(ServletRequest request, ServletResponse response,
+            FilterChain chain) throws IOException, ServletException;
+
+    /**
+     * Called by the web container to indicate to a filter that it is being
+     * taken out of service. This method is only called once all threads within
+     * the filter's doFilter method have exited or after a timeout period has
+     * passed. After the web container calls this method, it will not call the
+     * doFilter method again on this instance of the filter. <br>
+     * <br>
+     *
+     * This method gives the filter an opportunity to clean up any resources
+     * that are being held (for example, memory, file handles, threads) and make
+     * sure that any persistent state is synchronized with the filter's current
+     * state in memory.
+     */
+    public void destroy();
+}

java/javax/servlet/FilterChain.java

@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+
+/**
+ * A FilterChain is an object provided by the servlet container to the developer
+ * giving a view into the invocation chain of a filtered request for a resource.
+ * Filters use the FilterChain to invoke the next filter in the chain, or if the
+ * calling filter is the last filter in the chain, to invoke the resource at the
+ * end of the chain.
+ *
+ * @see Filter
+ * @since Servlet 2.3
+ **/
+
+public interface FilterChain {
+
+    /**
+     * Causes the next filter in the chain to be invoked, or if the calling
+     * filter is the last filter in the chain, causes the resource at the end of
+     * the chain to be invoked.
+     *
+     * @param request
+     *            the request to pass along the chain.
+     * @param response
+     *            the response to pass along the chain.
+     *
+     * @throws IOException if an I/O error occurs during the processing of the
+     *                     request
+     * @throws ServletException if the processing fails for any other reason
+
+     * @since 2.3
+     */
+    public void doFilter(ServletRequest request, ServletResponse response)
+            throws IOException, ServletException;
+
+}

java/javax/servlet/FilterConfig.java

@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet;
+
+import java.util.Enumeration;
+
+/**
+ *
+ * A filter configuration object used by a servlet container to pass information
+ * to a filter during initialization.
+ *
+ * @see Filter
+ * @since Servlet 2.3
+ */
+public interface FilterConfig {
+
+    /**
+     * Get the name of the filter.
+     *
+     * @return The filter-name of this filter as defined in the deployment
+     *         descriptor.
+     */
+    public String getFilterName();
+
+    /**
+     * Returns a reference to the {@link ServletContext} in which the caller is
+     * executing.
+     *
+     * @return {@link ServletContext} object, used by the caller to interact
+     *         with its servlet container
+     *
+     * @see ServletContext
+     */
+    public ServletContext getServletContext();
+
+    /**
+     * Returns a <code>String</code> containing the value of the named
+     * initialization parameter, or <code>null</code> if the parameter does not
+     * exist.
+     *
+     * @param name
+     *            <code>String</code> specifying the name of the initialization
+     *            parameter
+     *
+     * @return <code>String</code> containing the value of the initialization
+     *         parameter
+     */
+    public String getInitParameter(String name);
+
+    /**
+     * Returns the names of the filter's initialization parameters as an
+     * <code>Enumeration</code> of <code>String</code> objects, or an empty
+     * <code>Enumeration</code> if the filter has no initialization parameters.
+     *
+     * @return <code>Enumeration</code> of <code>String</code> objects
+     *         containing the names of the filter's initialization parameters
+     */
+    public Enumeration<String> getInitParameterNames();
+
+}

java/javax/servlet/FilterRegistration.java

@@ -0,0 +1,81 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.Collection;
+import java.util.EnumSet;
+
+/**
+ * @since Servlet 3.0
+ * TODO SERVLET3 - Add comments
+ */
+public interface FilterRegistration extends Registration {
+
+    /**
+     * Add a mapping for this filter to one or more named Servlets.
+     *
+     * @param dispatcherTypes The dispatch types to which this filter should
+     *                        apply
+     * @param isMatchAfter    Should this filter be applied after any mappings
+     *                        defined in the deployment descriptor
+     *                        (<code>true</code>) or before?
+     * @param servletNames    Requests mapped to these servlets will be
+     *                        processed by this filter
+     * @throws IllegalArgumentException if the list of servlet names is empty
+     *                                  or null
+     * @throws IllegalStateException if the associated ServletContext has
+     *                               already been initialised
+     */
+    public void addMappingForServletNames(
+            EnumSet<DispatcherType> dispatcherTypes,
+            boolean isMatchAfter, String... servletNames);
+    /**
+     *
+     * @return TODO
+     */
+    public Collection<String> getServletNameMappings();
+
+    /**
+     * Add a mapping for this filter to one or more URL patterns.
+     *
+     * @param dispatcherTypes The dispatch types to which this filter should
+     *                        apply
+     * @param isMatchAfter    Should this filter be applied after any mappings
+     *                        defined in the deployment descriptor
+     *                        (<code>true</code>) or before?
+     * @param urlPatterns     The URL patterns to which this filter should be
+     *                        applied
+     * @throws IllegalArgumentException if the list of URL patterns is empty or
+     *                                  null
+     * @throws IllegalStateException if the associated ServletContext has
+     *                               already been initialised
+     */
+    public void addMappingForUrlPatterns(
+            EnumSet<DispatcherType> dispatcherTypes,
+            boolean isMatchAfter, String... urlPatterns);
+
+    /**
+     *
+     * @return TODO
+     */
+    public Collection<String> getUrlPatternMappings();
+
+    public static interface Dynamic
+    extends FilterRegistration, Registration.Dynamic {
+        // No additional methods
+    }
+}

java/javax/servlet/GenericServlet.java

@@ -0,0 +1,238 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+import java.util.Enumeration;
+
+/**
+ * Defines a generic, protocol-independent servlet. To write an HTTP servlet for
+ * use on the Web, extend {@link javax.servlet.http.HttpServlet} instead.
+ * <p>
+ * <code>GenericServlet</code> implements the <code>Servlet</code> and
+ * <code>ServletConfig</code> interfaces. <code>GenericServlet</code> may be
+ * directly extended by a servlet, although it's more common to extend a
+ * protocol-specific subclass such as <code>HttpServlet</code>.
+ * <p>
+ * <code>GenericServlet</code> makes writing servlets easier. It provides simple
+ * versions of the lifecycle methods <code>init</code> and <code>destroy</code>
+ * and of the methods in the <code>ServletConfig</code> interface.
+ * <code>GenericServlet</code> also implements the <code>log</code> method,
+ * declared in the <code>ServletContext</code> interface.
+ * <p>
+ * To write a generic servlet, you need only override the abstract
+ * <code>service</code> method.
+ */
+public abstract class GenericServlet implements Servlet, ServletConfig,
+        java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private transient ServletConfig config;
+
+    /**
+     * Does nothing. All of the servlet initialization is done by one of the
+     * <code>init</code> methods.
+     */
+    public GenericServlet() {
+        // NOOP
+    }
+
+    /**
+     * Called by the servlet container to indicate to a servlet that the servlet
+     * is being taken out of service. See {@link Servlet#destroy}.
+     */
+    @Override
+    public void destroy() {
+        // NOOP by default
+    }
+
+    /**
+     * Returns a <code>String</code> containing the value of the named
+     * initialization parameter, or <code>null</code> if the parameter does not
+     * exist. See {@link ServletConfig#getInitParameter}.
+     * <p>
+     * This method is supplied for convenience. It gets the value of the named
+     * parameter from the servlet's <code>ServletConfig</code> object.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the
+     *            initialization parameter
+     * @return String a <code>String</code> containing the value of the
+     *         initialization parameter
+     */
+    @Override
+    public String getInitParameter(String name) {
+        return getServletConfig().getInitParameter(name);
+    }
+
+    /**
+     * Returns the names of the servlet's initialization parameters as an
+     * <code>Enumeration</code> of <code>String</code> objects, or an empty
+     * <code>Enumeration</code> if the servlet has no initialization parameters.
+     * See {@link ServletConfig#getInitParameterNames}.
+     * <p>
+     * This method is supplied for convenience. It gets the parameter names from
+     * the servlet's <code>ServletConfig</code> object.
+     *
+     * @return Enumeration an enumeration of <code>String</code> objects
+     *         containing the names of the servlet's initialization parameters
+     */
+    @Override
+    public Enumeration<String> getInitParameterNames() {
+        return getServletConfig().getInitParameterNames();
+    }
+
+    /**
+     * Returns this servlet's {@link ServletConfig} object.
+     *
+     * @return ServletConfig the <code>ServletConfig</code> object that
+     *         initialized this servlet
+     */
+    @Override
+    public ServletConfig getServletConfig() {
+        return config;
+    }
+
+    /**
+     * Returns a reference to the {@link ServletContext} in which this servlet
+     * is running. See {@link ServletConfig#getServletContext}.
+     * <p>
+     * This method is supplied for convenience. It gets the context from the
+     * servlet's <code>ServletConfig</code> object.
+     *
+     * @return ServletContext the <code>ServletContext</code> object passed to
+     *         this servlet by the <code>init</code> method
+     */
+    @Override
+    public ServletContext getServletContext() {
+        return getServletConfig().getServletContext();
+    }
+
+    /**
+     * Returns information about the servlet, such as author, version, and
+     * copyright. By default, this method returns an empty string. Override this
+     * method to have it return a meaningful value. See
+     * {@link Servlet#getServletInfo}.
+     *
+     * @return String information about this servlet, by default an empty string
+     */
+    @Override
+    public String getServletInfo() {
+        return "";
+    }
+
+    /**
+     * Called by the servlet container to indicate to a servlet that the servlet
+     * is being placed into service. See {@link Servlet#init}.
+     * <p>
+     * This implementation stores the {@link ServletConfig} object it receives
+     * from the servlet container for later use. When overriding this form of
+     * the method, call <code>super.init(config)</code>.
+     *
+     * @param config
+     *            the <code>ServletConfig</code> object that contains
+     *            configuration information for this servlet
+     * @exception ServletException
+     *                if an exception occurs that interrupts the servlet's
+     *                normal operation
+     * @see UnavailableException
+     */
+    @Override
+    public void init(ServletConfig config) throws ServletException {
+        this.config = config;
+        this.init();
+    }
+
+    /**
+     * A convenience method which can be overridden so that there's no need to
+     * call <code>super.init(config)</code>.
+     * <p>
+     * Instead of overriding {@link #init(ServletConfig)}, simply override this
+     * method and it will be called by
+     * <code>GenericServlet.init(ServletConfig config)</code>. The
+     * <code>ServletConfig</code> object can still be retrieved via
+     * {@link #getServletConfig}.
+     *
+     * @exception ServletException
+     *                if an exception occurs that interrupts the servlet's
+     *                normal operation
+     */
+    public void init() throws ServletException {
+        // NOOP by default
+    }
+
+    /**
+     * Writes the specified message to a servlet log file, prepended by the
+     * servlet's name. See {@link ServletContext#log(String)}.
+     *
+     * @param msg
+     *            a <code>String</code> specifying the message to be written to
+     *            the log file
+     */
+    public void log(String msg) {
+        getServletContext().log(getServletName() + ": " + msg);
+    }
+
+    /**
+     * Writes an explanatory message and a stack trace for a given
+     * <code>Throwable</code> exception to the servlet log file, prepended by
+     * the servlet's name. See {@link ServletContext#log(String, Throwable)}.
+     *
+     * @param message
+     *            a <code>String</code> that describes the error or exception
+     * @param t
+     *            the <code>java.lang.Throwable</code> error or exception
+     */
+    public void log(String message, Throwable t) {
+        getServletContext().log(getServletName() + ": " + message, t);
+    }
+
+    /**
+     * Called by the servlet container to allow the servlet to respond to a
+     * request. See {@link Servlet#service}.
+     * <p>
+     * This method is declared abstract so subclasses, such as
+     * <code>HttpServlet</code>, must override it.
+     *
+     * @param req
+     *            the <code>ServletRequest</code> object that contains the
+     *            client's request
+     * @param res
+     *            the <code>ServletResponse</code> object that will contain the
+     *            servlet's response
+     * @exception ServletException
+     *                if an exception occurs that interferes with the servlet's
+     *                normal operation occurred
+     * @exception IOException
+     *                if an input or output exception occurs
+     */
+    @Override
+    public abstract void service(ServletRequest req, ServletResponse res)
+            throws ServletException, IOException;
+
+    /**
+     * Returns the name of this servlet instance. See
+     * {@link ServletConfig#getServletName}.
+     *
+     * @return the name of this servlet instance
+     */
+    @Override
+    public String getServletName() {
+        return config.getServletName();
+    }
+}

java/javax/servlet/HttpConstraintElement.java

@@ -0,0 +1,125 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.ResourceBundle;
+
+import javax.servlet.annotation.ServletSecurity.EmptyRoleSemantic;
+import javax.servlet.annotation.ServletSecurity.TransportGuarantee;
+
+/**
+ * Equivalent of {@link javax.servlet.annotation.HttpConstraint} for
+ * programmatic configuration of security constraints.
+ *
+ * @since Servlet 3.0
+ */
+public class HttpConstraintElement {
+
+    private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
+    private static final ResourceBundle lStrings =
+        ResourceBundle.getBundle(LSTRING_FILE);
+
+    private final EmptyRoleSemantic emptyRoleSemantic;// = EmptyRoleSemantic.PERMIT;
+    private final TransportGuarantee transportGuarantee;// = TransportGuarantee.NONE;
+    private final String[] rolesAllowed;// = new String[0];
+
+    /**
+     * Default constraint is permit with no transport guarantee.
+     */
+    public HttpConstraintElement() {
+        // Default constructor
+        this.emptyRoleSemantic = EmptyRoleSemantic.PERMIT;
+        this.transportGuarantee = TransportGuarantee.NONE;
+        this.rolesAllowed = new String[0];
+    }
+
+    /**
+     * Construct a constraint with an empty role semantic. Typically used with
+     * {@link EmptyRoleSemantic#DENY}.
+     *
+     * @param emptyRoleSemantic The empty role semantic to apply to the newly
+     *                          created constraint
+     */
+    public HttpConstraintElement(EmptyRoleSemantic emptyRoleSemantic) {
+        this.emptyRoleSemantic = emptyRoleSemantic;
+        this.transportGuarantee = TransportGuarantee.NONE;
+        this.rolesAllowed = new String[0];
+    }
+
+    /**
+     * Construct a constraint with a transport guarantee and roles.
+     *
+     * @param transportGuarantee The transport guarantee to apply to the newly
+     *                           created constraint
+     * @param rolesAllowed       The roles to associate with the newly created
+     *                           constraint
+     */
+    public HttpConstraintElement(TransportGuarantee transportGuarantee,
+            String... rolesAllowed) {
+        this.emptyRoleSemantic = EmptyRoleSemantic.PERMIT;
+        this.transportGuarantee = transportGuarantee;
+        this.rolesAllowed = rolesAllowed;
+    }
+
+    /**
+     * Construct a constraint with an empty role semantic, a transport guarantee
+     * and roles.
+     *
+     * @param emptyRoleSemantic The empty role semantic to apply to the newly
+     *                          created constraint
+     * @param transportGuarantee The transport guarantee to apply to the newly
+     *                           created constraint
+     * @param rolesAllowed       The roles to associate with the newly created
+     *                           constraint
+     * @throws IllegalArgumentException if roles are specified when DENY is used
+     */
+    public HttpConstraintElement(EmptyRoleSemantic emptyRoleSemantic,
+            TransportGuarantee transportGuarantee, String... rolesAllowed) {
+        if (rolesAllowed != null && rolesAllowed.length > 0 &&
+                EmptyRoleSemantic.DENY.equals(emptyRoleSemantic)) {
+            throw new IllegalArgumentException(lStrings.getString(
+                    "httpConstraintElement.invalidRolesDeny"));
+        }
+        this.emptyRoleSemantic = emptyRoleSemantic;
+        this.transportGuarantee = transportGuarantee;
+        this.rolesAllowed = rolesAllowed;
+    }
+
+    /**
+     * TODO
+     * @return TODO
+     */
+    public EmptyRoleSemantic getEmptyRoleSemantic() {
+        return emptyRoleSemantic;
+    }
+
+    /**
+     * TODO
+     * @return TODO
+     */
+    public TransportGuarantee getTransportGuarantee() {
+        return transportGuarantee;
+    }
+
+    /**
+     * TODO
+     * @return TODO
+     */
+    public String[] getRolesAllowed() {
+        return rolesAllowed;
+    }
+}

java/javax/servlet/HttpMethodConstraintElement.java

@@ -0,0 +1,57 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.ResourceBundle;
+
+/**
+ * @since Servlet 3.0
+ * TODO SERVLET3 - Add comments
+ */
+public class HttpMethodConstraintElement extends HttpConstraintElement {
+
+    // Can't inherit from HttpConstraintElement as API does not allow it
+    private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
+    private static final ResourceBundle lStrings =
+        ResourceBundle.getBundle(LSTRING_FILE);
+
+    private final String methodName;
+
+    public HttpMethodConstraintElement(String methodName) {
+        if (methodName == null || methodName.length() == 0) {
+            throw new IllegalArgumentException(lStrings.getString(
+                    "httpMethodConstraintElement.invalidMethod"));
+        }
+        this.methodName = methodName;
+    }
+
+    public HttpMethodConstraintElement(String methodName,
+            HttpConstraintElement constraint) {
+        super(constraint.getEmptyRoleSemantic(),
+                constraint.getTransportGuarantee(),
+                constraint.getRolesAllowed());
+        if (methodName == null || methodName.length() == 0) {
+            throw new IllegalArgumentException(lStrings.getString(
+                    "httpMethodConstraintElement.invalidMethod"));
+        }
+        this.methodName = methodName;
+    }
+
+    public String getMethodName() {
+        return methodName;
+    }
+}

java/javax/servlet/LocalStrings.properties

@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.not_iso8859_1=Not an ISO 8859-1 character: [{0}]
+
+httpConstraintElement.invalidRolesDeny=Roles may not be specified when using DENY
+
+httpMethodConstraintElement.invalidMethod=Invalid HTTP method
+
+value.false=false
+value.true=true

java/javax/servlet/LocalStrings_de.properties

@@ -0,0 +1,20 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.not_iso8859_1=Kein ISO 8859-1 Zeichen: [{0}]
+
+httpMethodConstraintElement.invalidMethod=Ungültige HTTP-Methode
+
+value.true=wahr

java/javax/servlet/LocalStrings_es.properties

@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.not_iso8859_1=No es un carácter ISO 8859-1: [{0}]
+
+httpConstraintElement.invalidRolesDeny=No se pueden especificar Roles al utilizar DENY (DENEGAR)
+
+httpMethodConstraintElement.invalidMethod=Método HTTP inválido
+
+value.false=false
+value.true=true

java/javax/servlet/LocalStrings_fr.properties

@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.not_iso8859_1=[{0}] n''est pas un caractère ISO 8859-1
+
+httpConstraintElement.invalidRolesDeny=Des rôles ne peuvent pas être spécifiés lorsque DENY est utilisé
+
+httpMethodConstraintElement.invalidMethod=Méthode HTTP invalide
+
+value.false=false
+value.true=true

java/javax/servlet/LocalStrings_ja.properties

@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.not_iso8859_1=ISO 8859-1 の文字ではありません: [{0}]
+
+httpConstraintElement.invalidRolesDeny=DENYを使用する場合、Roleを指定することはできません。
+
+httpMethodConstraintElement.invalidMethod=無効なHTTPメソッド
+
+value.false=false
+value.true=true

java/javax/servlet/LocalStrings_ko.properties

@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.not_iso8859_1=ISO 8859-1 문자가 아닙니다: [{0}]
+
+httpConstraintElement.invalidRolesDeny=DENY를 사용할 때에는 역할들이 지정될 수 없습니다.
+
+httpMethodConstraintElement.invalidMethod=유효하지 않은 HTTP 메소드
+
+value.false=false
+value.true=true

java/javax/servlet/LocalStrings_zh_CN.properties

@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.not_iso8859_1=不是ISO 8859-1字符：[{0}]
+
+httpConstraintElement.invalidRolesDeny=使用 DENY 时可能未指定角色
+
+httpMethodConstraintElement.invalidMethod=无效的HTTP.方法
+
+value.true=true

java/javax/servlet/MultipartConfigElement.java

@@ -0,0 +1,85 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import javax.servlet.annotation.MultipartConfig;
+
+/**
+ * @since Servlet 3.0
+ * TODO SERVLET3 - Add comments
+ */
+public class MultipartConfigElement {
+
+    private final String location;// = "";
+    private final long maxFileSize;// = -1;
+    private final long maxRequestSize;// = -1;
+    private final int fileSizeThreshold;// = 0;
+
+    public MultipartConfigElement(String location) {
+        // Keep empty string default if location is null
+        if (location != null) {
+            this.location = location;
+        } else {
+            this.location = "";
+        }
+        this.maxFileSize = -1;
+        this.maxRequestSize = -1;
+        this.fileSizeThreshold = 0;
+    }
+
+    public MultipartConfigElement(String location, long maxFileSize,
+            long maxRequestSize, int fileSizeThreshold) {
+        // Keep empty string default if location is null
+        if (location != null) {
+            this.location = location;
+        } else {
+            this.location = "";
+        }
+        this.maxFileSize = maxFileSize;
+        this.maxRequestSize = maxRequestSize;
+        // Avoid threshold values of less than zero as they cause trigger NPEs
+        // in the Commons FileUpload port for fields that have no data.
+        if (fileSizeThreshold > 0) {
+            this.fileSizeThreshold = fileSizeThreshold;
+        } else {
+            this.fileSizeThreshold = 0;
+        }
+    }
+
+    public MultipartConfigElement(MultipartConfig annotation) {
+        location = annotation.location();
+        maxFileSize = annotation.maxFileSize();
+        maxRequestSize = annotation.maxRequestSize();
+        fileSizeThreshold = annotation.fileSizeThreshold();
+    }
+
+    public String getLocation() {
+        return location;
+    }
+
+    public long getMaxFileSize() {
+        return maxFileSize;
+    }
+
+    public long getMaxRequestSize() {
+        return maxRequestSize;
+    }
+
+    public int getFileSizeThreshold() {
+        return fileSizeThreshold;
+    }
+}

java/javax/servlet/ReadListener.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+
+/**
+ * Receives notification of read events when using non-blocking IO.
+ *
+ * @since Servlet 3.1
+ */
+public interface ReadListener extends java.util.EventListener{
+
+    /**
+     * Invoked when data is available to read. The container will invoke this
+     * method the first time for a request as soon as there is data to read.
+     * Subsequent invocations will only occur if a call to
+     * {@link ServletInputStream#isReady()} has returned false and data has
+     * subsequently become available to read.
+     *
+     * @throws IOException id an I/O error occurs while processing the event
+     */
+    public abstract void onDataAvailable() throws IOException;
+
+    /**
+     * Invoked when the request body has been fully read.
+     *
+     * @throws IOException id an I/O error occurs while processing the event
+     */
+    public abstract void onAllDataRead() throws IOException;
+
+    /**
+     * Invoked if an error occurs while reading the request body.
+     *
+     * @param throwable The exception that occurred
+     */
+    public abstract void onError(java.lang.Throwable throwable);
+}

java/javax/servlet/Registration.java

@@ -0,0 +1,94 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Common interface for the registration of Filters and Servlets.
+ * @since Servlet 3.0
+ */
+public interface Registration {
+
+    public String getName();
+
+    public String getClassName();
+
+    /**
+     * Add an initialisation parameter if not already added.
+     *
+     * @param name  Name of initialisation parameter
+     * @param value Value of initialisation parameter
+     * @return <code>true</code> if the initialisation parameter was set,
+     *         <code>false</code> if the initialisation parameter was not set
+     *         because an initialisation parameter of the same name already
+     *         existed
+     * @throws IllegalArgumentException if name or value is <code>null</code>
+     * @throws IllegalStateException if the ServletContext associated with this
+     *         registration has already been initialised
+     */
+    public boolean setInitParameter(String name, String value);
+
+    /**
+     * Get the value of an initialisation parameter.
+     *
+     * @param name  The initialisation parameter whose value is required
+     *
+     * @return The value of the named initialisation parameter
+     */
+    public String getInitParameter(String name);
+
+    /**
+     * Add multiple initialisation parameters. If any of the supplied
+     * initialisation parameter conflicts with an existing initialisation
+     * parameter, no updates will be performed.
+     *
+     * @param initParameters The initialisation parameters to add
+     *
+     * @return The set of initialisation parameter names that conflicted with
+     *         existing initialisation parameter. If there are no conflicts,
+     *         this Set will be empty.
+     * @throws IllegalArgumentException if any of the supplied initialisation
+     *         parameters have a null name or value
+     * @throws IllegalStateException if the ServletContext associated with this
+     *         registration has already been initialised
+     */
+    public Set<String> setInitParameters(Map<String,String> initParameters);
+
+    /**
+     * Get the names and values of all the initialisation parameters.
+     *
+     * @return A Map of initialisation parameter names and associated values
+     *         keyed by name
+     */
+    public Map<String, String> getInitParameters();
+
+    public interface Dynamic extends Registration {
+
+        /**
+         * Mark this Servlet/Filter as supported asynchronous processing.
+         *
+         * @param isAsyncSupported  Should this Servlet/Filter support
+         *                          asynchronous processing
+         *
+         * @throws IllegalStateException if the ServletContext associated with
+         *         this registration has already been initialised
+         */
+        public void setAsyncSupported(boolean isAsyncSupported);
+    }
+}

java/javax/servlet/RequestDispatcher.java

@@ -0,0 +1,293 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+
+/**
+ * Defines an object that receives requests from the client and sends them to
+ * any resource (such as a servlet, HTML file, or JSP file) on the server. The
+ * servlet container creates the <code>RequestDispatcher</code> object, which is
+ * used as a wrapper around a server resource located at a particular path or
+ * given by a particular name.
+ *
+ * <p>
+ * This interface is intended to wrap servlets, but a servlet container can
+ * create <code>RequestDispatcher</code> objects to wrap any type of resource.
+ *
+ * @see ServletContext#getRequestDispatcher(java.lang.String)
+ * @see ServletContext#getNamedDispatcher(java.lang.String)
+ * @see ServletRequest#getRequestDispatcher(java.lang.String)
+ *
+ */
+public interface RequestDispatcher {
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #forward(ServletRequest, ServletResponse)} method is
+     * called. It provides the original value of a path-related property of the
+     * request. See the chapter "Forwarded Request Parameters" in the Servlet
+     * Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String FORWARD_REQUEST_URI = "javax.servlet.forward.request_uri";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #forward(ServletRequest, ServletResponse)} method is
+     * called. It provides the original value of a path-related property of the
+     * request. See the chapter "Forwarded Request Parameters" in the Servlet
+     * Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String FORWARD_CONTEXT_PATH = "javax.servlet.forward.context_path";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #forward(ServletRequest, ServletResponse)} method is
+     * called. It provides the original value of a path-related property of the
+     * request. See the chapter "Forwarded Request Parameters" in the Servlet
+     * Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String FORWARD_PATH_INFO = "javax.servlet.forward.path_info";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #forward(ServletRequest, ServletResponse)} method is
+     * called. It provides the original value of a path-related property of the
+     * request. See the chapter "Forwarded Request Parameters" in the Servlet
+     * Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String FORWARD_SERVLET_PATH = "javax.servlet.forward.servlet_path";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #forward(ServletRequest, ServletResponse)} method is
+     * called. It provides the original value of a path-related property of the
+     * request. See the chapter "Forwarded Request Parameters" in the Servlet
+     * Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String FORWARD_QUERY_STRING = "javax.servlet.forward.query_string";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #include(ServletRequest, ServletResponse)} method is
+     * called on the {@code RequestDispatcher} obtained by a path and not by a
+     * name. It provides information on the path that was used to obtain the
+     * {@code RequestDispatcher} instance for this include call. See the chapter
+     * "Included Request Parameters" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String INCLUDE_REQUEST_URI = "javax.servlet.include.request_uri";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #include(ServletRequest, ServletResponse)} method is
+     * called on the {@code RequestDispatcher} obtained by a path and not by a
+     * name. It provides information on the path that was used to obtain the
+     * {@code RequestDispatcher} instance for this include call. See the chapter
+     * "Included Request Parameters" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String INCLUDE_CONTEXT_PATH = "javax.servlet.include.context_path";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #include(ServletRequest, ServletResponse)} method is
+     * called on the {@code RequestDispatcher} obtained by a path and not by a
+     * name. It provides information on the path that was used to obtain the
+     * {@code RequestDispatcher} instance for this include call. See the chapter
+     * "Included Request Parameters" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String INCLUDE_PATH_INFO = "javax.servlet.include.path_info";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #include(ServletRequest, ServletResponse)} method is
+     * called on the {@code RequestDispatcher} obtained by a path and not by a
+     * name. It provides information on the path that was used to obtain the
+     * {@code RequestDispatcher} instance for this include call. See the chapter
+     * "Included Request Parameters" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String INCLUDE_SERVLET_PATH = "javax.servlet.include.servlet_path";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when the {@link #include(ServletRequest, ServletResponse)} method is
+     * called on the {@code RequestDispatcher} obtained by a path and not by a
+     * name. It provides information on the path that was used to obtain the
+     * {@code RequestDispatcher} instance for this include call. See the chapter
+     * "Included Request Parameters" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    static final String INCLUDE_QUERY_STRING = "javax.servlet.include.query_string";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when custom error-handling servlet or JSP page is invoked. The value of
+     * the attribute is of type {@code java.lang.Throwable}. See the chapter
+     * "Error Handling" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    public static final String ERROR_EXCEPTION = "javax.servlet.error.exception";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when custom error-handling servlet or JSP page is invoked. The value of
+     * the attribute is of type {@code java.lang.Class}. See the chapter
+     * "Error Handling" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    public static final String ERROR_EXCEPTION_TYPE = "javax.servlet.error.exception_type";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when custom error-handling servlet or JSP page is invoked. The value of
+     * the attribute is of type {@code java.lang.String}. See the chapter
+     * "Error Handling" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    public static final String ERROR_MESSAGE = "javax.servlet.error.message";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when custom error-handling servlet or JSP page is invoked. The value of
+     * the attribute is of type {@code java.lang.String}. See the chapter
+     * "Error Handling" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    public static final String ERROR_REQUEST_URI = "javax.servlet.error.request_uri";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when custom error-handling servlet or JSP page is invoked. The value of
+     * the attribute is of type {@code java.lang.String}. See the chapter
+     * "Error Handling" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    public static final String ERROR_SERVLET_NAME = "javax.servlet.error.servlet_name";
+
+    /**
+     * The name of the request attribute that should be set by the container
+     * when custom error-handling servlet or JSP page is invoked. The value of
+     * the attribute is of type {@code java.lang.Integer}. See the chapter
+     * "Error Handling" in the Servlet Specification for details.
+     *
+     * @since Servlet 3.0
+     */
+    public static final String ERROR_STATUS_CODE = "javax.servlet.error.status_code";
+
+    /**
+     * Forwards a request from a servlet to another resource (servlet, JSP file,
+     * or HTML file) on the server. This method allows one servlet to do
+     * preliminary processing of a request and another resource to generate the
+     * response.
+     *
+     * <p>
+     * For a <code>RequestDispatcher</code> obtained via
+     * <code>getRequestDispatcher()</code>, the <code>ServletRequest</code>
+     * object has its path elements and parameters adjusted to match the path of
+     * the target resource.
+     *
+     * <p>
+     * <code>forward</code> should be called before the response has been
+     * committed to the client (before response body output has been flushed).
+     * If the response already has been committed, this method throws an
+     * <code>IllegalStateException</code>. Uncommitted output in the response
+     * buffer is automatically cleared before the forward.
+     *
+     * <p>
+     * The request and response parameters must be either the same objects as
+     * were passed to the calling servlet's service method or be subclasses of
+     * the {@link ServletRequestWrapper} or {@link ServletResponseWrapper}
+     * classes that wrap them.
+     *
+     *
+     * @param request
+     *            a {@link ServletRequest} object that represents the request
+     *            the client makes of the servlet
+     *
+     * @param response
+     *            a {@link ServletResponse} object that represents the response
+     *            the servlet returns to the client
+     *
+     * @exception ServletException
+     *                if the target resource throws this exception
+     *
+     * @exception IOException
+     *                if the target resource throws this exception
+     *
+     * @exception IllegalStateException
+     *                if the response was already committed
+     */
+    public void forward(ServletRequest request, ServletResponse response)
+            throws ServletException, IOException;
+
+    /**
+     * Includes the content of a resource (servlet, JSP page, HTML file) in the
+     * response. In essence, this method enables programmatic server-side
+     * includes.
+     *
+     * <p>
+     * The {@link ServletResponse} object has its path elements and parameters
+     * remain unchanged from the caller's. The included servlet cannot change
+     * the response status code or set headers; any attempt to make a change is
+     * ignored.
+     *
+     * <p>
+     * The request and response parameters must be either the same objects as
+     * were passed to the calling servlet's service method or be subclasses of
+     * the {@link ServletRequestWrapper} or {@link ServletResponseWrapper}
+     * classes that wrap them.
+     *
+     * @param request
+     *            a {@link ServletRequest} object that contains the client's
+     *            request
+     *
+     * @param response
+     *            a {@link ServletResponse} object that contains the servlet's
+     *            response
+     *
+     * @exception ServletException
+     *                if the included resource throws this exception
+     *
+     * @exception IOException
+     *                if the included resource throws this exception
+     */
+    public void include(ServletRequest request, ServletResponse response)
+            throws ServletException, IOException;
+}

java/javax/servlet/Servlet.java

@@ -0,0 +1,178 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet;
+
+import java.io.IOException;
+
+/**
+ * Defines methods that all servlets must implement.
+ *
+ * <p>
+ * A servlet is a small Java program that runs within a Web server. Servlets
+ * receive and respond to requests from Web clients, usually across HTTP, the
+ * HyperText Transfer Protocol.
+ *
+ * <p>
+ * To implement this interface, you can write a generic servlet that extends
+ * <code>javax.servlet.GenericServlet</code> or an HTTP servlet that extends
+ * <code>javax.servlet.http.HttpServlet</code>.
+ *
+ * <p>
+ * This interface defines methods to initialize a servlet, to service requests,
+ * and to remove a servlet from the server. These are known as life-cycle
+ * methods and are called in the following sequence:
+ * <ol>
+ * <li>The servlet is constructed, then initialized with the <code>init</code>
+ * method.
+ * <li>Any calls from clients to the <code>service</code> method are handled.
+ * <li>The servlet is taken out of service, then destroyed with the
+ * <code>destroy</code> method, then garbage collected and finalized.
+ * </ol>
+ *
+ * <p>
+ * In addition to the life-cycle methods, this interface provides the
+ * <code>getServletConfig</code> method, which the servlet can use to get any
+ * startup information, and the <code>getServletInfo</code> method, which allows
+ * the servlet to return basic information about itself, such as author,
+ * version, and copyright.
+ *
+ * @see GenericServlet
+ * @see javax.servlet.http.HttpServlet
+ */
+public interface Servlet {
+
+    /**
+     * Called by the servlet container to indicate to a servlet that the servlet
+     * is being placed into service.
+     *
+     * <p>
+     * The servlet container calls the <code>init</code> method exactly once
+     * after instantiating the servlet. The <code>init</code> method must
+     * complete successfully before the servlet can receive any requests.
+     *
+     * <p>
+     * The servlet container cannot place the servlet into service if the
+     * <code>init</code> method
+     * <ol>
+     * <li>Throws a <code>ServletException</code>
+     * <li>Does not return within a time period defined by the Web server
+     * </ol>
+     *
+     *
+     * @param config
+     *            a <code>ServletConfig</code> object containing the servlet's
+     *            configuration and initialization parameters
+     *
+     * @exception ServletException
+     *                if an exception has occurred that interferes with the
+     *                servlet's normal operation
+     *
+     * @see UnavailableException
+     * @see #getServletConfig
+     */
+    public void init(ServletConfig config) throws ServletException;
+
+    /**
+     *
+     * Returns a {@link ServletConfig} object, which contains initialization and
+     * startup parameters for this servlet. The <code>ServletConfig</code>
+     * object returned is the one passed to the <code>init</code> method.
+     *
+     * <p>
+     * Implementations of this interface are responsible for storing the
+     * <code>ServletConfig</code> object so that this method can return it. The
+     * {@link GenericServlet} class, which implements this interface, already
+     * does this.
+     *
+     * @return the <code>ServletConfig</code> object that initializes this
+     *         servlet
+     *
+     * @see #init
+     */
+    public ServletConfig getServletConfig();
+
+    /**
+     * Called by the servlet container to allow the servlet to respond to a
+     * request.
+     *
+     * <p>
+     * This method is only called after the servlet's <code>init()</code> method
+     * has completed successfully.
+     *
+     * <p>
+     * The status code of the response always should be set for a servlet that
+     * throws or sends an error.
+     *
+     *
+     * <p>
+     * Servlets typically run inside multithreaded servlet containers that can
+     * handle multiple requests concurrently. Developers must be aware to
+     * synchronize access to any shared resources such as files, network
+     * connections, and as well as the servlet's class and instance variables.
+     * More information on multithreaded programming in Java is available in <a
+     * href
+     * ="http://java.sun.com/Series/Tutorial/java/threads/multithreaded.html">
+     * the Java tutorial on multi-threaded programming</a>.
+     *
+     *
+     * @param req
+     *            the <code>ServletRequest</code> object that contains the
+     *            client's request
+     *
+     * @param res
+     *            the <code>ServletResponse</code> object that contains the
+     *            servlet's response
+     *
+     * @exception ServletException
+     *                if an exception occurs that interferes with the servlet's
+     *                normal operation
+     *
+     * @exception IOException
+     *                if an input or output exception occurs
+     */
+    public void service(ServletRequest req, ServletResponse res)
+            throws ServletException, IOException;
+
+    /**
+     * Returns information about the servlet, such as author, version, and
+     * copyright.
+     *
+     * <p>
+     * The string that this method returns should be plain text and not markup
+     * of any kind (such as HTML, XML, etc.).
+     *
+     * @return a <code>String</code> containing servlet information
+     */
+    public String getServletInfo();
+
+    /**
+     * Called by the servlet container to indicate to a servlet that the servlet
+     * is being taken out of service. This method is only called once all
+     * threads within the servlet's <code>service</code> method have exited or
+     * after a timeout period has passed. After the servlet container calls this
+     * method, it will not call the <code>service</code> method again on this
+     * servlet.
+     *
+     * <p>
+     * This method gives the servlet an opportunity to clean up any resources
+     * that are being held (for example, memory, file handles, threads) and make
+     * sure that any persistent state is synchronized with the servlet's current
+     * state in memory.
+     */
+    public void destroy();
+}

java/javax/servlet/ServletConfig.java

@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.util.Enumeration;
+
+/**
+ * A servlet configuration object used by a servlet container to pass
+ * information to a servlet during initialization.
+ */
+public interface ServletConfig {
+
+    /**
+     * Returns the name of this servlet instance. The name may be provided via
+     * server administration, assigned in the web application deployment
+     * descriptor, or for an unregistered (and thus unnamed) servlet instance it
+     * will be the servlet's class name.
+     *
+     * @return the name of the servlet instance
+     */
+    public String getServletName();
+
+    /**
+     * Returns a reference to the {@link ServletContext} in which the caller is
+     * executing.
+     *
+     * @return a {@link ServletContext} object, used by the caller to interact
+     *         with its servlet container
+     * @see ServletContext
+     */
+    public ServletContext getServletContext();
+
+    /**
+     * Returns a <code>String</code> containing the value of the named
+     * initialization parameter, or <code>null</code> if the parameter does not
+     * exist.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the
+     *            initialization parameter
+     * @return a <code>String</code> containing the value of the initialization
+     *         parameter
+     */
+    public String getInitParameter(String name);
+
+    /**
+     * Returns the names of the servlet's initialization parameters as an
+     * <code>Enumeration</code> of <code>String</code> objects, or an empty
+     * <code>Enumeration</code> if the servlet has no initialization parameters.
+     *
+     * @return an <code>Enumeration</code> of <code>String</code> objects
+     *         containing the names of the servlet's initialization parameters
+     */
+    public Enumeration<String> getInitParameterNames();
+}

java/javax/servlet/ServletContainerInitializer.java

@@ -0,0 +1,53 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.Set;
+
+/**
+ * ServletContainerInitializers (SCIs) are registered via an entry in the
+ * file META-INF/services/javax.servlet.ServletContainerInitializer that must be
+ * included in the JAR file that contains the SCI implementation.
+ * <p>
+ * SCI processing is performed regardless of the setting of metadata-complete.
+ * SCI processing can be controlled per JAR file via fragment ordering. If
+ * absolute ordering is defined, then only the JARs included in the ordering
+ * will be processed for SCIs. To disable SCI processing completely, an empty
+ * absolute ordering may be defined.
+ * <p>
+ * SCIs register an interest in annotations (class, method or field) and/or
+ * types via the {@link javax.servlet.annotation.HandlesTypes} annotation which
+ * is added to the class.
+ *
+ * @since Servlet 3.0
+ */
+public interface ServletContainerInitializer {
+
+    /**
+     * Receives notification during startup of a web application of the classes
+     * within the web application that matched the criteria defined via the
+     * {@link javax.servlet.annotation.HandlesTypes} annotation.
+     *
+     * @param c     The (possibly null) set of classes that met the specified
+     *              criteria
+     * @param ctx   The ServletContext of the web application in which the
+     *              classes were discovered
+     *
+     * @throws ServletException If an error occurs
+     */
+    void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException;
+}

java/javax/servlet/ServletContext.java

@@ -0,0 +1,969 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.EventListener;
+import java.util.Map;
+import java.util.Set;
+
+import javax.servlet.descriptor.JspConfigDescriptor;
+
+/**
+ * Defines a set of methods that a servlet uses to communicate with its servlet
+ * container, for example, to get the MIME type of a file, dispatch requests, or
+ * write to a log file.
+ * <p>
+ * There is one context per "web application" per Java Virtual Machine. (A
+ * "web application" is a collection of servlets and content installed under a
+ * specific subset of the server's URL namespace such as <code>/catalog</code>
+ * and possibly installed via a <code>.war</code> file.)
+ * <p>
+ * In the case of a web application marked "distributed" in its deployment
+ * descriptor, there will be one context instance for each virtual machine. In
+ * this situation, the context cannot be used as a location to share global
+ * information (because the information won't be truly global). Use an external
+ * resource like a database instead.
+ * <p>
+ * The <code>ServletContext</code> object is contained within the
+ * {@link ServletConfig} object, which the Web server provides the servlet when
+ * the servlet is initialized.
+ *
+ * @see Servlet#getServletConfig
+ * @see ServletConfig#getServletContext
+ */
+public interface ServletContext {
+
+    public static final String TEMPDIR = "javax.servlet.context.tempdir";
+
+    /**
+     * @since Servlet 3.0
+     */
+    public static final String ORDERED_LIBS = "javax.servlet.context.orderedLibs";
+
+    /**
+     * Return the main path associated with this context.
+     *
+     * @return The main context path
+     *
+     * @since Servlet 2.5
+     */
+    public String getContextPath();
+
+    /**
+     * Returns a <code>ServletContext</code> object that corresponds to a
+     * specified URL on the server.
+     * <p>
+     * This method allows servlets to gain access to the context for various
+     * parts of the server, and as needed obtain {@link RequestDispatcher}
+     * objects from the context. The given path must be begin with "/", is
+     * interpreted relative to the server's document root and is matched against
+     * the context roots of other web applications hosted on this container.
+     * <p>
+     * In a security conscious environment, the servlet container may return
+     * <code>null</code> for a given URL.
+     *
+     * @param uripath
+     *            a <code>String</code> specifying the context path of another
+     *            web application in the container.
+     * @return the <code>ServletContext</code> object that corresponds to the
+     *         named URL, or null if either none exists or the container wishes
+     *         to restrict this access.
+     * @see RequestDispatcher
+     */
+    public ServletContext getContext(String uripath);
+
+    /**
+     * Returns the major version of the Java Servlet API that this servlet
+     * container supports. All implementations that comply with Version 3.1 must
+     * have this method return the integer 3.
+     *
+     * @return 3
+     */
+    public int getMajorVersion();
+
+    /**
+     * Returns the minor version of the Servlet API that this servlet container
+     * supports. All implementations that comply with Version 3.1 must have this
+     * method return the integer 1.
+     *
+     * @return 1
+     */
+    public int getMinorVersion();
+
+    /**
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     *
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public int getEffectiveMajorVersion();
+
+    /**
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public int getEffectiveMinorVersion();
+
+    /**
+     * Returns the MIME type of the specified file, or <code>null</code> if the
+     * MIME type is not known. The MIME type is determined by the configuration
+     * of the servlet container, and may be specified in a web application
+     * deployment descriptor. Common MIME types are <code>"text/html"</code> and
+     * <code>"image/gif"</code>.
+     *
+     * @param file
+     *            a <code>String</code> specifying the name of a file
+     * @return a <code>String</code> specifying the file's MIME type
+     */
+    public String getMimeType(String file);
+
+    /**
+     * Returns a directory-like listing of all the paths to resources within the
+     * web application whose longest sub-path matches the supplied path
+     * argument. Paths indicating subdirectory paths end with a '/'. The
+     * returned paths are all relative to the root of the web application and
+     * have a leading '/'. For example, for a web application containing<br>
+     * <br>
+     * /welcome.html<br>
+     * /catalog/index.html<br>
+     * /catalog/products.html<br>
+     * /catalog/offers/books.html<br>
+     * /catalog/offers/music.html<br>
+     * /customer/login.jsp<br>
+     * /WEB-INF/web.xml<br>
+     * /WEB-INF/classes/com.acme.OrderServlet.class,<br>
+     * <br>
+     * getResourcePaths("/") returns {"/welcome.html", "/catalog/",
+     * "/customer/", "/WEB-INF/"}<br>
+     * getResourcePaths("/catalog/") returns {"/catalog/index.html",
+     * "/catalog/products.html", "/catalog/offers/"}.<br>
+     *
+     * @param path
+     *            the partial path used to match the resources, which must start
+     *            with a /
+     * @return a Set containing the directory listing, or null if there are no
+     *         resources in the web application whose path begins with the
+     *         supplied path.
+     * @since Servlet 2.3
+     */
+    public Set<String> getResourcePaths(String path);
+
+    /**
+     * Returns a URL to the resource that is mapped to a specified path. The
+     * path must begin with a "/" and is interpreted as relative to the current
+     * context root.
+     * <p>
+     * This method allows the servlet container to make a resource available to
+     * servlets from any source. Resources can be located on a local or remote
+     * file system, in a database, or in a <code>.war</code> file.
+     * <p>
+     * The servlet container must implement the URL handlers and
+     * <code>URLConnection</code> objects that are necessary to access the
+     * resource.
+     * <p>
+     * This method returns <code>null</code> if no resource is mapped to the
+     * pathname.
+     * <p>
+     * Some containers may allow writing to the URL returned by this method
+     * using the methods of the URL class.
+     * <p>
+     * The resource content is returned directly, so be aware that requesting a
+     * <code>.jsp</code> page returns the JSP source code. Use a
+     * <code>RequestDispatcher</code> instead to include results of an
+     * execution.
+     * <p>
+     * This method has a different purpose than
+     * <code>java.lang.Class.getResource</code>, which looks up resources based
+     * on a class loader. This method does not use class loaders.
+     *
+     * @param path
+     *            a <code>String</code> specifying the path to the resource
+     * @return the resource located at the named path, or <code>null</code> if
+     *         there is no resource at that path
+     * @exception MalformedURLException
+     *                if the pathname is not given in the correct form
+     */
+    public URL getResource(String path) throws MalformedURLException;
+
+    /**
+     * Returns the resource located at the named path as an
+     * <code>InputStream</code> object.
+     * <p>
+     * The data in the <code>InputStream</code> can be of any type or length.
+     * The path must be specified according to the rules given in
+     * <code>getResource</code>. This method returns <code>null</code> if no
+     * resource exists at the specified path.
+     * <p>
+     * Meta-information such as content length and content type that is
+     * available via <code>getResource</code> method is lost when using this
+     * method.
+     * <p>
+     * The servlet container must implement the URL handlers and
+     * <code>URLConnection</code> objects necessary to access the resource.
+     * <p>
+     * This method is different from
+     * <code>java.lang.Class.getResourceAsStream</code>, which uses a class
+     * loader. This method allows servlet containers to make a resource
+     * available to a servlet from any location, without using a class loader.
+     *
+     * @param path
+     *            a <code>String</code> specifying the path to the resource
+     * @return the <code>InputStream</code> returned to the servlet, or
+     *         <code>null</code> if no resource exists at the specified path
+     */
+    public InputStream getResourceAsStream(String path);
+
+    /**
+     * Returns a {@link RequestDispatcher} object that acts as a wrapper for the
+     * resource located at the given path. A <code>RequestDispatcher</code>
+     * object can be used to forward a request to the resource or to include the
+     * resource in a response. The resource can be dynamic or static.
+     * <p>
+     * The pathname must begin with a "/" and is interpreted as relative to the
+     * current context root. Use <code>getContext</code> to obtain a
+     * <code>RequestDispatcher</code> for resources in foreign contexts. This
+     * method returns <code>null</code> if the <code>ServletContext</code>
+     * cannot return a <code>RequestDispatcher</code>.
+     *
+     * @param path
+     *            a <code>String</code> specifying the pathname to the resource
+     * @return a <code>RequestDispatcher</code> object that acts as a wrapper for
+     *         the resource at the specified path, or <code>null</code> if the
+     *         <code>ServletContext</code> cannot return a
+     *         <code>RequestDispatcher</code>
+     * @see RequestDispatcher
+     * @see ServletContext#getContext
+     */
+    public RequestDispatcher getRequestDispatcher(String path);
+
+    /**
+     * Returns a {@link RequestDispatcher} object that acts as a wrapper for the
+     * named servlet.
+     * <p>
+     * Servlets (and JSP pages also) may be given names via server
+     * administration or via a web application deployment descriptor. A servlet
+     * instance can determine its name using
+     * {@link ServletConfig#getServletName}.
+     * <p>
+     * This method returns <code>null</code> if the <code>ServletContext</code>
+     * cannot return a <code>RequestDispatcher</code> for any reason.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of a servlet to wrap
+     * @return a <code>RequestDispatcher</code> object that acts as a wrapper for
+     *         the named servlet, or <code>null</code> if the
+     *         <code>ServletContext</code> cannot return a
+     *         <code>RequestDispatcher</code>
+     * @see RequestDispatcher
+     * @see ServletContext#getContext
+     * @see ServletConfig#getServletName
+     */
+    public RequestDispatcher getNamedDispatcher(String name);
+
+    /**
+     * Do not use. This method was originally defined to retrieve a servlet from
+     * a <code>ServletContext</code>. In this version, this method always
+     * returns <code>null</code> and remains only to preserve binary
+     * compatibility. This method will be permanently removed in a future
+     * version of the Java Servlet API.
+     * <p>
+     * In lieu of this method, servlets can share information using the
+     * <code>ServletContext</code> class and can perform shared business logic
+     * by invoking methods on common non-servlet classes.
+     *
+     * @param name Not used
+     *
+     * @return Always <code>null</code>
+     *
+     * @throws ServletException never
+     *
+     * @deprecated As of Java Servlet API 2.1, with no direct replacement.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public Servlet getServlet(String name) throws ServletException;
+
+    /**
+     * Do not use. This method was originally defined to return an
+     * <code>Enumeration</code> of all the servlets known to this servlet
+     * context. In this version, this method always returns an empty enumeration
+     * and remains only to preserve binary compatibility. This method will be
+     * permanently removed in a future version of the Java Servlet API.
+     *
+     * @return Always and empty Enumeration
+     *
+     * @deprecated As of Java Servlet API 2.0, with no replacement.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public Enumeration<Servlet> getServlets();
+
+    /**
+     * Do not use. This method was originally defined to return an
+     * <code>Enumeration</code> of all the servlet names known to this context.
+     * In this version, this method always returns an empty
+     * <code>Enumeration</code> and remains only to preserve binary
+     * compatibility. This method will be permanently removed in a future
+     * version of the Java Servlet API.
+     *
+     * @return Always and empty Enumeration
+     *
+     * @deprecated As of Java Servlet API 2.1, with no replacement.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public Enumeration<String> getServletNames();
+
+    /**
+     * Writes the specified message to a servlet log file, usually an event log.
+     * The name and type of the servlet log file is specific to the servlet
+     * container.
+     *
+     * @param msg
+     *            a <code>String</code> specifying the message to be written to
+     *            the log file
+     */
+    public void log(String msg);
+
+    /**
+     * Do not use.
+     * @param exception The exception to log
+     * @param msg       The message to log with the exception
+     * @deprecated As of Java Servlet API 2.1, use
+     *             {@link #log(String message, Throwable throwable)} instead.
+     *             <p>
+     *             This method was originally defined to write an exception's
+     *             stack trace and an explanatory error message to the servlet
+     *             log file.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public void log(Exception exception, String msg);
+
+    /**
+     * Writes an explanatory message and a stack trace for a given
+     * <code>Throwable</code> exception to the servlet log file. The name and
+     * type of the servlet log file is specific to the servlet container,
+     * usually an event log.
+     *
+     * @param message
+     *            a <code>String</code> that describes the error or exception
+     * @param throwable
+     *            the <code>Throwable</code> error or exception
+     */
+    public void log(String message, Throwable throwable);
+
+    /**
+     * Returns a <code>String</code> containing the real path for a given
+     * virtual path. For example, the path "/index.html" returns the absolute
+     * file path on the server's filesystem would be served by a request for
+     * "http://host/contextPath/index.html", where contextPath is the context
+     * path of this ServletContext..
+     * <p>
+     * The real path returned will be in a form appropriate to the computer and
+     * operating system on which the servlet container is running, including the
+     * proper path separators. This method returns <code>null</code> if the
+     * servlet container cannot translate the virtual path to a real path for
+     * any reason (such as when the content is being made available from a
+     * <code>.war</code> archive).
+     *
+     * @param path
+     *            a <code>String</code> specifying a virtual path
+     * @return a <code>String</code> specifying the real path, or null if the
+     *         translation cannot be performed
+     */
+    public String getRealPath(String path);
+
+    /**
+     * Returns the name and version of the servlet container on which the
+     * servlet is running.
+     * <p>
+     * The form of the returned string is
+     * <i>servername</i>/<i>versionnumber</i>. For example, the JavaServer Web
+     * Development Kit may return the string
+     * <code>JavaServer Web Dev Kit/1.0</code>.
+     * <p>
+     * The servlet container may return other optional information after the
+     * primary string in parentheses, for example,
+     * <code>JavaServer Web Dev Kit/1.0 (JDK 1.1.6; Windows NT 4.0 x86)</code>.
+     *
+     * @return a <code>String</code> containing at least the servlet container
+     *         name and version number
+     */
+    public String getServerInfo();
+
+    /**
+     * Returns a <code>String</code> containing the value of the named
+     * context-wide initialization parameter, or <code>null</code> if the
+     * parameter does not exist.
+     * <p>
+     * This method can make available configuration information useful to an
+     * entire "web application". For example, it can provide a webmaster's email
+     * address or the name of a system that holds critical data.
+     *
+     * @param name
+     *            a <code>String</code> containing the name of the parameter
+     *            whose value is requested
+     * @return a <code>String</code> containing the value of the initialization
+     *         parameter
+     * @throws NullPointerException If the provided parameter name is
+     *         <code>null</code>
+     * @see ServletConfig#getInitParameter
+     */
+    public String getInitParameter(String name);
+
+    /**
+     * Returns the names of the context's initialization parameters as an
+     * <code>Enumeration</code> of <code>String</code> objects, or an empty
+     * <code>Enumeration</code> if the context has no initialization parameters.
+     *
+     * @return an <code>Enumeration</code> of <code>String</code> objects
+     *         containing the names of the context's initialization parameters
+     * @see ServletConfig#getInitParameter
+     */
+
+    public Enumeration<String> getInitParameterNames();
+
+    /**
+     * Set the given initialisation parameter to the given value.
+     * @param name  Name of initialisation parameter
+     * @param value Value for initialisation parameter
+     * @return <code>true</code> if the call succeeds or <code>false</code> if
+     *         the call fails because an initialisation parameter with the same
+     *         name has already been set
+     * @throws IllegalStateException If initialisation of this ServletContext
+     *         has already completed
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @throws NullPointerException If the provided parameter name is
+     *         <code>null</code>
+     * @since Servlet 3.0
+     */
+    public boolean setInitParameter(String name, String value);
+
+    /**
+     * Returns the servlet container attribute with the given name, or
+     * <code>null</code> if there is no attribute by that name. An attribute
+     * allows a servlet container to give the servlet additional information not
+     * already provided by this interface. See your server documentation for
+     * information about its attributes. A list of supported attributes can be
+     * retrieved using <code>getAttributeNames</code>.
+     * <p>
+     * The attribute is returned as a <code>java.lang.Object</code> or some
+     * subclass. Attribute names should follow the same convention as package
+     * names. The Java Servlet API specification reserves names matching
+     * <code>java.*</code>, <code>javax.*</code>, and <code>sun.*</code>.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the attribute
+     * @return an <code>Object</code> containing the value of the attribute, or
+     *         <code>null</code> if no attribute exists matching the given name
+     * @throws NullPointerException If the provided attribute name is
+     *         <code>null</code>
+     * @see ServletContext#getAttributeNames
+     */
+    public Object getAttribute(String name);
+
+    /**
+     * Returns an <code>Enumeration</code> containing the attribute names
+     * available within this servlet context. Use the {@link #getAttribute}
+     * method with an attribute name to get the value of an attribute.
+     *
+     * @return an <code>Enumeration</code> of attribute names
+     * @see #getAttribute
+     */
+    public Enumeration<String> getAttributeNames();
+
+    /**
+     * Binds an object to a given attribute name in this servlet context. If the
+     * name specified is already used for an attribute, this method will replace
+     * the attribute with the new to the new attribute.
+     * <p>
+     * If listeners are configured on the <code>ServletContext</code> the
+     * container notifies them accordingly.
+     * <p>
+     * If a null value is passed, the effect is the same as calling
+     * <code>removeAttribute()</code>.
+     * <p>
+     * Attribute names should follow the same convention as package names. The
+     * Java Servlet API specification reserves names matching
+     * <code>java.*</code>, <code>javax.*</code>, and <code>sun.*</code>.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the attribute
+     * @param object
+     *            an <code>Object</code> representing the attribute to be bound
+     * @throws NullPointerException If the provided attribute name is
+     *         <code>null</code>
+     */
+    public void setAttribute(String name, Object object);
+
+    /**
+     * Removes the attribute with the given name from the servlet context. After
+     * removal, subsequent calls to {@link #getAttribute} to retrieve the
+     * attribute's value will return <code>null</code>.
+     * <p>
+     * If listeners are configured on the <code>ServletContext</code> the
+     * container notifies them accordingly.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the attribute to
+     *            be removed
+     */
+    public void removeAttribute(String name);
+
+    /**
+     * Returns the name of this web application corresponding to this
+     * ServletContext as specified in the deployment descriptor for this web
+     * application by the display-name element.
+     *
+     * @return The name of the web application or null if no name has been
+     *         declared in the deployment descriptor.
+     * @since Servlet 2.3
+     */
+    public String getServletContextName();
+
+    /**
+     * Register a servlet implementation for use in this ServletContext.
+     * @param servletName The name of the servlet to register
+     * @param className   The implementation class for the servlet
+     * @return The registration object that enables further configuration
+     * @throws IllegalStateException
+     *             If the context has already been initialised
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public ServletRegistration.Dynamic addServlet(String servletName, String className);
+
+    /**
+     * Register a servlet instance for use in this ServletContext.
+     * @param servletName The name of the servlet to register
+     * @param servlet     The Servlet instance to register
+     * @return The registration object that enables further configuration
+     * @throws IllegalStateException
+     *             If the context has already been initialised
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet);
+
+    /**
+     * Add servlet to context.
+     * @param   servletName  Name of servlet to add
+     * @param   servletClass Class of servlet to add
+     * @return  <code>null</code> if the servlet has already been fully defined,
+     *          else a {@link javax.servlet.ServletRegistration.Dynamic} object
+     *          that can be used to further configure the servlet
+     * @throws IllegalStateException
+     *             If the context has already been initialised
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public ServletRegistration.Dynamic addServlet(String servletName,
+            Class<? extends Servlet> servletClass);
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param <T> TODO
+     * @param c   TODO
+     * @return TODO
+     * @throws ServletException TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public <T extends Servlet> T createServlet(Class<T> c)
+            throws ServletException;
+
+    /**
+     * Obtain the details of the named servlet.
+     *
+     * @param servletName   The name of the Servlet of interest
+     *
+     * @return  The registration details for the named Servlet or
+     *          <code>null</code> if no Servlet has been registered with the
+     *          given name
+     *
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     *
+     * @since Servlet 3.0
+     */
+    public ServletRegistration getServletRegistration(String servletName);
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public Map<String, ? extends ServletRegistration> getServletRegistrations();
+
+    /**
+     * Add filter to context.
+     * @param   filterName  Name of filter to add
+     * @param   className Name of filter class
+     * @return  <code>null</code> if the filter has already been fully defined,
+     *          else a {@link javax.servlet.FilterRegistration.Dynamic} object
+     *          that can be used to further configure the filter
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @throws IllegalStateException
+     *             If the context has already been initialised
+     * @since Servlet 3.0
+     */
+    public FilterRegistration.Dynamic addFilter(String filterName, String className);
+
+    /**
+     * Add filter to context.
+     * @param   filterName  Name of filter to add
+     * @param   filter      Filter to add
+     * @return  <code>null</code> if the filter has already been fully defined,
+     *          else a {@link javax.servlet.FilterRegistration.Dynamic} object
+     *          that can be used to further configure the filter
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @throws IllegalStateException
+     *             If the context has already been initialised
+     * @since Servlet 3.0
+     */
+    public FilterRegistration.Dynamic addFilter(String filterName, Filter filter);
+
+    /**
+     * Add filter to context.
+     * @param   filterName  Name of filter to add
+     * @param   filterClass Class of filter to add
+     * @return  <code>null</code> if the filter has already been fully defined,
+     *          else a {@link javax.servlet.FilterRegistration.Dynamic} object
+     *          that can be used to further configure the filter
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @throws IllegalStateException
+     *             If the context has already been initialised
+     * @since Servlet 3.0
+     */
+    public FilterRegistration.Dynamic addFilter(String filterName,
+            Class<? extends Filter> filterClass);
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param <T> TODO
+     * @param c   TODO
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @throws ServletException TODO
+     * @since Servlet 3.
+     */
+    public <T extends Filter> T createFilter(Class<T> c) throws ServletException;
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param filterName TODO
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public FilterRegistration getFilterRegistration(String filterName);
+
+    /**
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public Map<String, ? extends FilterRegistration> getFilterRegistrations();
+
+    /**
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public SessionCookieConfig getSessionCookieConfig();
+
+    /**
+     * Configures the available session tracking modes for this web application.
+     * @param sessionTrackingModes The session tracking modes to use for this
+     *        web application
+     * @throws IllegalArgumentException
+     *             If sessionTrackingModes specifies
+     *             {@link SessionTrackingMode#SSL} in combination with any other
+     *             {@link SessionTrackingMode}
+     * @throws IllegalStateException
+     *             If the context has already been initialised
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public void setSessionTrackingModes(
+            Set<SessionTrackingMode> sessionTrackingModes);
+
+    /**
+     * Obtains the default session tracking modes for this web application.
+     * By default {@link SessionTrackingMode#URL} is always supported, {@link
+     * SessionTrackingMode#COOKIE} is supported unless the <code>cookies</code>
+     * attribute has been set to <code>false</code> for the context and {@link
+     * SessionTrackingMode#SSL} is supported if at least one of the connectors
+     * used by this context has the attribute <code>secure</code> set to
+     * <code>true</code>.
+     * @return The set of default session tracking modes for this web
+     *         application
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public Set<SessionTrackingMode> getDefaultSessionTrackingModes();
+
+    /**
+     * Obtains the currently enabled session tracking modes for this web
+     * application.
+     * @return The value supplied via {@link #setSessionTrackingModes(Set)} if
+     *         one was previously set, else return the defaults
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public Set<SessionTrackingMode> getEffectiveSessionTrackingModes();
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param className TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public void addListener(String className);
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param <T> TODO
+     * @param t   TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public <T extends EventListener> void addListener(T t);
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param listenerClass TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public void addListener(Class<? extends EventListener> listenerClass);
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param <T> TODO
+     * @param c TODO
+     * @return TODO
+     * @throws ServletException TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0
+     */
+    public <T extends EventListener> T createListener(Class<T> c)
+            throws ServletException;
+
+    /**
+     * @return TODO
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public JspConfigDescriptor getJspConfigDescriptor();
+
+    /**
+     * Get the web application class loader associated with this ServletContext.
+     *
+     * @return The associated web application class loader
+     *
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @throws SecurityException if access to the class loader is prevented by a
+     *         SecurityManager
+     * @since Servlet 3.0
+     */
+    public ClassLoader getClassLoader();
+
+    /**
+     * Add to the declared roles for this ServletContext.
+     * @param roleNames The roles to add
+     * @throws UnsupportedOperationException    If called from a
+     *    {@link ServletContextListener#contextInitialized(ServletContextEvent)}
+     *    method of a {@link ServletContextListener} that was not defined in a
+     *    web.xml file, a web-fragment.xml file nor annotated with
+     *    {@link javax.servlet.annotation.WebListener}. For example, a
+     *    {@link ServletContextListener} defined in a TLD would not be able to
+     *    use this method.
+     * @throws IllegalArgumentException If the list of roleNames is null or
+     *         empty
+     * @throws IllegalStateException If the ServletContext has already been
+     *         initialised
+     * @since Servlet 3.0
+     */
+    public void declareRoles(String... roleNames);
+
+    /**
+     * Get the primary name of the virtual host on which this context is
+     * deployed. The name may or may not be a valid host name.
+     *
+     * @return The primary name of the virtual host on which this context is
+     *         deployed
+     * @since Servlet 3.1
+     */
+    public String getVirtualServerName();
+}

java/javax/servlet/ServletContextAttributeEvent.java

@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+/**
+ * This is the event class for notifications about changes to the attributes of
+ * the servlet context of a web application.
+ *
+ * @see ServletContextAttributeListener
+ * @since v 2.3
+ */
+public class ServletContextAttributeEvent extends ServletContextEvent {
+    private static final long serialVersionUID = 1L;
+
+    private final String name;
+    private final Object value;
+
+    /**
+     * Construct a ServletContextAttributeEvent from the given context for the
+     * given attribute name and attribute value.
+     *
+     * @param source The ServletContext associated with this attribute event
+     * @param name   The name of the servlet context attribute
+     * @param value  The value of the servlet context attribute
+     */
+    public ServletContextAttributeEvent(ServletContext source, String name,
+            Object value) {
+        super(source);
+        this.name = name;
+        this.value = value;
+    }
+
+    /**
+     * Return the name of the attribute that changed on the ServletContext.
+     *
+     * @return The name of the attribute that changed
+     */
+    public String getName() {
+        return this.name;
+    }
+
+    /**
+     * Returns the value of the attribute that has been added, removed, or
+     * replaced.
+     *
+     * @return If the attribute was added, this is the value of the attribute.
+     *         If the attribute was removed, this is the value of the removed
+     *         attribute. If the attribute was replaced, this is the old value
+     *         of the attribute.
+     */
+    public Object getValue() {
+        return this.value;
+    }
+}

java/javax/servlet/ServletContextAttributeListener.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.util.EventListener;
+
+/**
+ * Implementations of this interface receive notifications of changes to the
+ * attribute list on the servlet context of a web application. To receive
+ * notification events, the implementation class must be configured in the
+ * deployment descriptor for the web application.
+ *
+ * @see ServletContextAttributeEvent
+ * @since v 2.3
+ */
+
+public interface ServletContextAttributeListener extends EventListener {
+    /**
+     * Notification that a new attribute was added to the servlet context.
+     * Called after the attribute is added.
+     * @param scae Information about the new attribute
+     */
+    public void attributeAdded(ServletContextAttributeEvent scae);
+
+    /**
+     * Notification that an existing attribute has been removed from the servlet
+     * context. Called after the attribute is removed.
+     * @param scae Information about the removed attribute
+     */
+    public void attributeRemoved(ServletContextAttributeEvent scae);
+
+    /**
+     * Notification that an attribute on the servlet context has been replaced.
+     * Called after the attribute is replaced.
+     * @param scae Information about the replaced attribute
+     */
+    public void attributeReplaced(ServletContextAttributeEvent scae);
+}

java/javax/servlet/ServletContextEvent.java

@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+/**
+ * This is the event class for notifications about changes to the servlet
+ * context of a web application.
+ *
+ * @see ServletContextListener
+ * @since v 2.3
+ */
+public class ServletContextEvent extends java.util.EventObject {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Construct a ServletContextEvent from the given context.
+     *
+     * @param source
+     *            - the ServletContext that is sending the event.
+     */
+    public ServletContextEvent(ServletContext source) {
+        super(source);
+    }
+
+    /**
+     * Return the ServletContext that changed.
+     *
+     * @return the ServletContext that sent the event.
+     */
+    public ServletContext getServletContext() {
+        return (ServletContext) super.getSource();
+    }
+}

java/javax/servlet/ServletContextListener.java

@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.util.EventListener;
+
+/**
+ * Implementations of this interface receive notifications about changes to the
+ * servlet context of the web application they are part of. To receive
+ * notification events, the implementation class must be configured in the
+ * deployment descriptor for the web application.
+ *
+ * @see ServletContextEvent
+ * @since v 2.3
+ */
+
+public interface ServletContextListener extends EventListener {
+
+    /**
+     ** Notification that the web application initialization process is starting.
+     * All ServletContextListeners are notified of context initialization before
+     * any filter or servlet in the web application is initialized.
+     * @param sce Information about the ServletContext that was initialized
+     */
+    public void contextInitialized(ServletContextEvent sce);
+
+    /**
+     ** Notification that the servlet context is about to be shut down. All
+     * servlets and filters have been destroy()ed before any
+     * ServletContextListeners are notified of context destruction.
+     * @param sce Information about the ServletContext that was destroyed
+     */
+    public void contextDestroyed(ServletContextEvent sce);
+}

java/javax/servlet/ServletException.java

@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+/**
+ * Defines a general exception a servlet can throw when it encounters
+ * difficulty.
+ */
+public class ServletException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Constructs a new servlet exception.
+     */
+    public ServletException() {
+        super();
+    }
+
+    /**
+     * Constructs a new servlet exception with the specified message. The
+     * message can be written to the server log and/or displayed for the user.
+     *
+     * @param message
+     *            a <code>String</code> specifying the text of the exception
+     *            message
+     */
+    public ServletException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new servlet exception when the servlet needs to throw an
+     * exception and include a message about the "root cause" exception that
+     * interfered with its normal operation, including a description message.
+     *
+     * @param message
+     *            a <code>String</code> containing the text of the exception
+     *            message
+     * @param rootCause
+     *            the <code>Throwable</code> exception that interfered with the
+     *            servlet's normal operation, making this servlet exception
+     *            necessary
+     */
+    public ServletException(String message, Throwable rootCause) {
+        super(message, rootCause);
+    }
+
+    /**
+     * Constructs a new servlet exception when the servlet needs to throw an
+     * exception and include a message about the "root cause" exception that
+     * interfered with its normal operation. The exception's message is based on
+     * the localized message of the underlying exception.
+     * <p>
+     * This method calls the <code>getLocalizedMessage</code> method on the
+     * <code>Throwable</code> exception to get a localized exception message.
+     * When subclassing <code>ServletException</code>, this method can be
+     * overridden to create an exception message designed for a specific locale.
+     *
+     * @param rootCause
+     *            the <code>Throwable</code> exception that interfered with the
+     *            servlet's normal operation, making the servlet exception
+     *            necessary
+     */
+    public ServletException(Throwable rootCause) {
+        super(rootCause);
+    }
+
+    /**
+     * Returns the exception that caused this servlet exception.
+     *
+     * @return the <code>Throwable</code> that caused this servlet exception
+     */
+    public Throwable getRootCause() {
+        return getCause();
+    }
+}

java/javax/servlet/ServletInputStream.java

@@ -0,0 +1,121 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Provides an input stream for reading binary data from a client request,
+ * including an efficient <code>readLine</code> method for reading data one line
+ * at a time. With some protocols, such as HTTP POST and PUT, a
+ * <code>ServletInputStream</code> object can be used to read data sent from the
+ * client.
+ * <p>
+ * A <code>ServletInputStream</code> object is normally retrieved via the
+ * {@link ServletRequest#getInputStream} method.
+ * <p>
+ * This is an abstract class that a servlet container implements. Subclasses of
+ * this class must implement the <code>java.io.InputStream.read()</code> method.
+ *
+ * @see ServletRequest
+ */
+public abstract class ServletInputStream extends InputStream {
+
+    /**
+     * Does nothing, because this is an abstract class.
+     */
+    protected ServletInputStream() {
+        // NOOP
+    }
+
+    /**
+     * Reads the input stream, one line at a time. Starting at an offset, reads
+     * bytes into an array, until it reads a certain number of bytes or reaches
+     * a newline character, which it reads into the array as well.
+     * <p>
+     * This method returns -1 if it reaches the end of the input stream before
+     * reading the maximum number of bytes.
+     *
+     * @param b
+     *            an array of bytes into which data is read
+     * @param off
+     *            an integer specifying the character at which this method
+     *            begins reading
+     * @param len
+     *            an integer specifying the maximum number of bytes to read
+     * @return an integer specifying the actual number of bytes read, or -1 if
+     *         the end of the stream is reached
+     * @exception IOException
+     *                if an input or output exception has occurred
+     */
+    public int readLine(byte[] b, int off, int len) throws IOException {
+
+        if (len <= 0) {
+            return 0;
+        }
+        int count = 0, c;
+
+        while ((c = read()) != -1) {
+            b[off++] = (byte) c;
+            count++;
+            if (c == '\n' || count == len) {
+                break;
+            }
+        }
+        return count > 0 ? count : -1;
+    }
+
+    /**
+     * Has the end of this InputStream been reached?
+     *
+     * @return <code>true</code> if all the data has been read from the stream,
+     * else <code>false</code>
+     *
+     * @since Servlet 3.1
+     */
+    public abstract boolean isFinished();
+
+    /**
+     * Can data be read from this InputStream without blocking?
+     * Returns  If this method is called and returns false, the container will
+     * invoke {@link ReadListener#onDataAvailable()} when data is available.
+     *
+     * @return <code>true</code> if data can be read without blocking, else
+     * <code>false</code>
+     *
+     * @since Servlet 3.1
+     */
+    public abstract boolean isReady();
+
+    /**
+     * Sets the {@link ReadListener} for this {@link ServletInputStream} and
+     * thereby switches to non-blocking IO. It is only valid to switch to
+     * non-blocking IO within async processing or HTTP upgrade processing.
+     *
+     * @param listener  The non-blocking IO read listener
+     *
+     * @throws IllegalStateException    If this method is called if neither
+     *                                  async nor HTTP upgrade is in progress or
+     *                                  if the {@link ReadListener} has already
+     *                                  been set
+     * @throws NullPointerException     If listener is null
+     *
+     * @since Servlet 3.1
+     */
+    public abstract void setReadListener(ReadListener listener);
+}

java/javax/servlet/ServletOutputStream.java

@@ -0,0 +1,309 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.CharConversionException;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.text.MessageFormat;
+import java.util.ResourceBundle;
+
+/**
+ * Provides an output stream for sending binary data to the client. A
+ * <code>ServletOutputStream</code> object is normally retrieved via the
+ * {@link ServletResponse#getOutputStream} method.
+ * <p>
+ * This is an abstract class that the servlet container implements. Subclasses
+ * of this class must implement the <code>java.io.OutputStream.write(int)</code>
+ * method.
+ *
+ * @see ServletResponse
+ */
+public abstract class ServletOutputStream extends OutputStream {
+
+    private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
+    private static final ResourceBundle lStrings = ResourceBundle.getBundle(LSTRING_FILE);
+
+    /**
+     * Does nothing, because this is an abstract class.
+     */
+    protected ServletOutputStream() {
+        // NOOP
+    }
+
+    /**
+     * Writes a <code>String</code> to the client, without a carriage
+     * return-line feed (CRLF) character at the end.
+     *
+     * @param s
+     *            the <code>String</code> to send to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void print(String s) throws IOException {
+        if (s == null) {
+            s = "null";
+        }
+        int len = s.length();
+        byte[] buffer = new byte[len];
+
+        for (int i = 0; i < len; i++) {
+            char c = s.charAt(i);
+
+            //
+            // XXX NOTE: This is clearly incorrect for many strings,
+            // but is the only consistent approach within the current
+            // servlet framework. It must suffice until servlet output
+            // streams properly encode their output.
+            //
+            if ((c & 0xff00) != 0) { // high order byte must be zero
+                String errMsg = lStrings.getString("err.not_iso8859_1");
+                Object[] errArgs = new Object[1];
+                errArgs[0] = Character.valueOf(c);
+                errMsg = MessageFormat.format(errMsg, errArgs);
+                throw new CharConversionException(errMsg);
+            }
+            buffer[i] = (byte) (c & 0xFF);
+        }
+        write(buffer);
+    }
+
+    /**
+     * Writes a <code>boolean</code> value to the client, with no carriage
+     * return-line feed (CRLF) character at the end.
+     *
+     * @param b
+     *            the <code>boolean</code> value to send to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void print(boolean b) throws IOException {
+        String msg;
+        if (b) {
+            msg = lStrings.getString("value.true");
+        } else {
+            msg = lStrings.getString("value.false");
+        }
+        print(msg);
+    }
+
+    /**
+     * Writes a character to the client, with no carriage return-line feed
+     * (CRLF) at the end.
+     *
+     * @param c
+     *            the character to send to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void print(char c) throws IOException {
+        print(String.valueOf(c));
+    }
+
+    /**
+     * Writes an int to the client, with no carriage return-line feed (CRLF) at
+     * the end.
+     *
+     * @param i
+     *            the int to send to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void print(int i) throws IOException {
+        print(String.valueOf(i));
+    }
+
+    /**
+     * Writes a <code>long</code> value to the client, with no carriage
+     * return-line feed (CRLF) at the end.
+     *
+     * @param l
+     *            the <code>long</code> value to send to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void print(long l) throws IOException {
+        print(String.valueOf(l));
+    }
+
+    /**
+     * Writes a <code>float</code> value to the client, with no carriage
+     * return-line feed (CRLF) at the end.
+     *
+     * @param f
+     *            the <code>float</code> value to send to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void print(float f) throws IOException {
+        print(String.valueOf(f));
+    }
+
+    /**
+     * Writes a <code>double</code> value to the client, with no carriage
+     * return-line feed (CRLF) at the end.
+     *
+     * @param d
+     *            the <code>double</code> value to send to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void print(double d) throws IOException {
+        print(String.valueOf(d));
+    }
+
+    /**
+     * Writes a carriage return-line feed (CRLF) to the client.
+     *
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println() throws IOException {
+        print("\r\n");
+    }
+
+    /**
+     * Writes a <code>String</code> to the client, followed by a carriage
+     * return-line feed (CRLF).
+     *
+     * @param s
+     *            the <code>String</code> to write to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println(String s) throws IOException {
+        StringBuilder sb = new StringBuilder();
+        sb.append(s);
+        sb.append("\r\n");
+        print(sb.toString());
+    }
+
+    /**
+     * Writes a <code>boolean</code> value to the client, followed by a carriage
+     * return-line feed (CRLF).
+     *
+     * @param b
+     *            the <code>boolean</code> value to write to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println(boolean b) throws IOException {
+        StringBuilder sb = new StringBuilder();
+        if (b) {
+            sb.append(lStrings.getString("value.true"));
+        } else {
+            sb.append(lStrings.getString("value.false"));
+        }
+        sb.append("\r\n");
+        print(sb.toString());
+    }
+
+    /**
+     * Writes a character to the client, followed by a carriage return-line feed
+     * (CRLF).
+     *
+     * @param c
+     *            the character to write to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println(char c) throws IOException {
+        println(String.valueOf(c));
+    }
+
+    /**
+     * Writes an int to the client, followed by a carriage return-line feed
+     * (CRLF) character.
+     *
+     * @param i
+     *            the int to write to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println(int i) throws IOException {
+        println(String.valueOf(i));
+    }
+
+    /**
+     * Writes a <code>long</code> value to the client, followed by a carriage
+     * return-line feed (CRLF).
+     *
+     * @param l
+     *            the <code>long</code> value to write to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println(long l) throws IOException {
+        println(String.valueOf(l));
+    }
+
+    /**
+     * Writes a <code>float</code> value to the client, followed by a carriage
+     * return-line feed (CRLF).
+     *
+     * @param f
+     *            the <code>float</code> value to write to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println(float f) throws IOException {
+        println(String.valueOf(f));
+    }
+
+    /**
+     * Writes a <code>double</code> value to the client, followed by a carriage
+     * return-line feed (CRLF).
+     *
+     * @param d
+     *            the <code>double</code> value to write to the client
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public void println(double d) throws IOException {
+        println(String.valueOf(d));
+    }
+
+    /**
+     * Checks if a non-blocking write will succeed. If this returns
+     * <code>false</code>, it will cause a callback to
+     * {@link WriteListener#onWritePossible()} when the buffer has emptied. If
+     * this method returns <code>false</code> no further data must be written
+     * until the contain calls {@link WriteListener#onWritePossible()}.
+     *
+     * @return <code>true</code> if data can be written, else <code>false</code>
+     *
+     * @since Servlet 3.1
+     */
+    public abstract boolean isReady();
+
+    /**
+     * Sets the {@link WriteListener} for this {@link ServletOutputStream} and
+     * thereby switches to non-blocking IO. It is only valid to switch to
+     * non-blocking IO within async processing or HTTP upgrade processing.
+     *
+     * @param listener  The non-blocking IO write listener
+     *
+     * @throws IllegalStateException    If this method is called if neither
+     *                                  async nor HTTP upgrade is in progress or
+     *                                  if the {@link WriteListener} has already
+     *                                  been set
+     * @throws NullPointerException     If listener is null
+     *
+     * @since Servlet 3.1
+     */
+    public abstract void setWriteListener(javax.servlet.WriteListener listener);
+}

java/javax/servlet/ServletRegistration.java

@@ -0,0 +1,49 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * TODO SERVLET3 - Add comments
+ * @since Servlet 3.0
+ */
+public interface ServletRegistration extends Registration {
+
+    /**
+     * TODO
+     * @param urlPatterns The URL patterns that this Servlet should be mapped to
+     * @return TODO
+     * @throws IllegalArgumentException if urlPattern is null or empty
+     * @throws IllegalStateException if the associated ServletContext has
+     *                                  already been initialised
+     */
+    public Set<String> addMapping(String... urlPatterns);
+
+    public Collection<String> getMappings();
+
+    public String getRunAsRole();
+
+    public static interface Dynamic
+    extends ServletRegistration, Registration.Dynamic {
+        public void setLoadOnStartup(int loadOnStartup);
+        public void setMultipartConfig(MultipartConfigElement multipartConfig);
+        public void setRunAsRole(String roleName);
+        public Set<String> setServletSecurity(ServletSecurityElement constraint);
+    }
+}

java/javax/servlet/ServletRequest.java

@@ -0,0 +1,501 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Defines an object to provide client request information to a servlet. The
+ * servlet container creates a <code>ServletRequest</code> object and passes it
+ * as an argument to the servlet's <code>service</code> method.
+ * <p>
+ * A <code>ServletRequest</code> object provides data including parameter name
+ * and values, attributes, and an input stream. Interfaces that extend
+ * <code>ServletRequest</code> can provide additional protocol-specific data
+ * (for example, HTTP data is provided by
+ * {@link javax.servlet.http.HttpServletRequest}.
+ *
+ * @see javax.servlet.http.HttpServletRequest
+ */
+public interface ServletRequest {
+
+    /**
+     * Returns the value of the named attribute as an <code>Object</code>, or
+     * <code>null</code> if no attribute of the given name exists.
+     * <p>
+     * Attributes can be set two ways. The servlet container may set attributes
+     * to make available custom information about a request. For example, for
+     * requests made using HTTPS, the attribute
+     * <code>javax.servlet.request.X509Certificate</code> can be used to
+     * retrieve information on the certificate of the client. Attributes can
+     * also be set programmatically using {@link ServletRequest#setAttribute}.
+     * This allows information to be embedded into a request before a
+     * {@link RequestDispatcher} call.
+     * <p>
+     * Attribute names should follow the same conventions as package names.
+     * Names beginning with <code>java.*</code> and <code>javax.*</code> are
+     * reserved for use by the Servlet specification. Names beginning with
+     * <code>sun.*</code>, <code>com.sun.*</code>, <code>oracle.*</code> and
+     * <code>com.oracle.*</code>) are reserved for use by Oracle Corporation.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the attribute
+     * @return an <code>Object</code> containing the value of the attribute, or
+     *         <code>null</code> if the attribute does not exist
+     */
+    public Object getAttribute(String name);
+
+    /**
+     * Returns an <code>Enumeration</code> containing the names of the
+     * attributes available to this request. This method returns an empty
+     * <code>Enumeration</code> if the request has no attributes available to
+     * it.
+     *
+     * @return an <code>Enumeration</code> of strings containing the names of the
+     *         request's attributes
+     */
+    public Enumeration<String> getAttributeNames();
+
+    /**
+     * Returns the name of the character encoding used in the body of this
+     * request. This method returns <code>null</code> if the request does not
+     * specify a character encoding
+     *
+     * @return a <code>String</code> containing the name of the character
+     *         encoding, or <code>null</code> if the request does not specify a
+     *         character encoding
+     */
+    public String getCharacterEncoding();
+
+    /**
+     * Overrides the name of the character encoding used in the body of this
+     * request. This method must be called prior to reading request parameters
+     * or reading input using getReader().
+     *
+     * @param env
+     *            a <code>String</code> containing the name of the character
+     *            encoding.
+     * @throws java.io.UnsupportedEncodingException
+     *             if this is not a valid encoding
+     */
+    public void setCharacterEncoding(String env)
+            throws java.io.UnsupportedEncodingException;
+
+    /**
+     * Returns the length, in bytes, of the request body and made available by
+     * the input stream, or -1 if the length is not known. For HTTP servlets,
+     * same as the value of the CGI variable CONTENT_LENGTH.
+     *
+     * @return an integer containing the length of the request body or -1 if the
+     *         length is not known or is greater than {@link Integer#MAX_VALUE}
+     */
+    public int getContentLength();
+
+    /**
+     * Returns the length, in bytes, of the request body and made available by
+     * the input stream, or -1 if the length is not known. For HTTP servlets,
+     * same as the value of the CGI variable CONTENT_LENGTH.
+     *
+     * @return a long integer containing the length of the request body or -1 if
+     *         the length is not known
+     * @since Servlet 3.1
+     */
+    public long getContentLengthLong();
+
+    /**
+     * Returns the MIME type of the body of the request, or <code>null</code> if
+     * the type is not known. For HTTP servlets, same as the value of the CGI
+     * variable CONTENT_TYPE.
+     *
+     * @return a <code>String</code> containing the name of the MIME type of the
+     *         request, or null if the type is not known
+     */
+    public String getContentType();
+
+    /**
+     * Retrieves the body of the request as binary data using a
+     * {@link ServletInputStream}. Either this method or {@link #getReader} may
+     * be called to read the body, not both.
+     *
+     * @return a {@link ServletInputStream} object containing the body of the
+     *         request
+     * @exception IllegalStateException
+     *                if the {@link #getReader} method has already been called
+     *                for this request
+     * @exception IOException
+     *                if an input or output exception occurred
+     */
+    public ServletInputStream getInputStream() throws IOException;
+
+    /**
+     * Returns the value of a request parameter as a <code>String</code>, or
+     * <code>null</code> if the parameter does not exist. Request parameters are
+     * extra information sent with the request. For HTTP servlets, parameters
+     * are contained in the query string or posted form data.
+     * <p>
+     * You should only use this method when you are sure the parameter has only
+     * one value. If the parameter might have more than one value, use
+     * {@link #getParameterValues}.
+     * <p>
+     * If you use this method with a multivalued parameter, the value returned
+     * is equal to the first value in the array returned by
+     * <code>getParameterValues</code>.
+     * <p>
+     * If the parameter data was sent in the request body, such as occurs with
+     * an HTTP POST request, then reading the body directly via
+     * {@link #getInputStream} or {@link #getReader} can interfere with the
+     * execution of this method.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the parameter
+     * @return a <code>String</code> representing the single value of the
+     *         parameter
+     * @see #getParameterValues
+     */
+    public String getParameter(String name);
+
+    /**
+     * Returns an <code>Enumeration</code> of <code>String</code> objects
+     * containing the names of the parameters contained in this request. If the
+     * request has no parameters, the method returns an empty
+     * <code>Enumeration</code>.
+     *
+     * @return an <code>Enumeration</code> of <code>String</code> objects, each
+     *         <code>String</code> containing the name of a request parameter;
+     *         or an empty <code>Enumeration</code> if the request has no
+     *         parameters
+     */
+    public Enumeration<String> getParameterNames();
+
+    /**
+     * Returns an array of <code>String</code> objects containing all of the
+     * values the given request parameter has, or <code>null</code> if the
+     * parameter does not exist.
+     * <p>
+     * If the parameter has a single value, the array has a length of 1.
+     *
+     * @param name
+     *            a <code>String</code> containing the name of the parameter
+     *            whose value is requested
+     * @return an array of <code>String</code> objects containing the parameter's
+     *         values
+     * @see #getParameter
+     */
+    public String[] getParameterValues(String name);
+
+    /**
+     * Returns a java.util.Map of the parameters of this request. Request
+     * parameters are extra information sent with the request. For HTTP
+     * servlets, parameters are contained in the query string or posted form
+     * data.
+     *
+     * @return an immutable java.util.Map containing parameter names as keys and
+     *         parameter values as map values. The keys in the parameter map are
+     *         of type String. The values in the parameter map are of type
+     *         String array.
+     */
+    public Map<String, String[]> getParameterMap();
+
+    /**
+     * Returns the name and version of the protocol the request uses in the form
+     * <i>protocol/majorVersion.minorVersion</i>, for example, HTTP/1.1. For
+     * HTTP servlets, the value returned is the same as the value of the CGI
+     * variable <code>SERVER_PROTOCOL</code>.
+     *
+     * @return a <code>String</code> containing the protocol name and version
+     *         number
+     */
+    public String getProtocol();
+
+    /**
+     * Returns the name of the scheme used to make this request, for example,
+     * <code>http</code>, <code>https</code>, or <code>ftp</code>. Different
+     * schemes have different rules for constructing URLs, as noted in RFC 1738.
+     *
+     * @return a <code>String</code> containing the name of the scheme used to
+     *         make this request
+     */
+    public String getScheme();
+
+    /**
+     * Returns the host name of the server to which the request was sent. It is
+     * the value of the part before ":" in the <code>Host</code> header value,
+     * if any, or the resolved server name, or the server IP address.
+     *
+     * @return a <code>String</code> containing the name of the server
+     */
+    public String getServerName();
+
+    /**
+     * Returns the port number to which the request was sent. It is the value of
+     * the part after ":" in the <code>Host</code> header value, if any, or the
+     * server port where the client connection was accepted on.
+     *
+     * @return an integer specifying the port number
+     */
+    public int getServerPort();
+
+    /**
+     * Retrieves the body of the request as character data using a
+     * <code>BufferedReader</code>. The reader translates the character data
+     * according to the character encoding used on the body. Either this method
+     * or {@link #getInputStream} may be called to read the body, not both.
+     *
+     * @return a <code>BufferedReader</code> containing the body of the request
+     * @exception java.io.UnsupportedEncodingException
+     *                if the character set encoding used is not supported and
+     *                the text cannot be decoded
+     * @exception IllegalStateException
+     *                if {@link #getInputStream} method has been called on this
+     *                request
+     * @exception IOException
+     *                if an input or output exception occurred
+     * @see #getInputStream
+     */
+    public BufferedReader getReader() throws IOException;
+
+    /**
+     * Returns the Internet Protocol (IP) address of the client or last proxy
+     * that sent the request. For HTTP servlets, same as the value of the CGI
+     * variable <code>REMOTE_ADDR</code>.
+     *
+     * @return a <code>String</code> containing the IP address of the client
+     *         that sent the request
+     */
+    public String getRemoteAddr();
+
+    /**
+     * Returns the fully qualified name of the client or the last proxy that
+     * sent the request. If the engine cannot or chooses not to resolve the
+     * hostname (to improve performance), this method returns the dotted-string
+     * form of the IP address. For HTTP servlets, same as the value of the CGI
+     * variable <code>REMOTE_HOST</code>.
+     *
+     * @return a <code>String</code> containing the fully qualified name of the
+     *         client
+     */
+    public String getRemoteHost();
+
+    /**
+     * Stores an attribute in this request. Attributes are reset between
+     * requests. This method is most often used in conjunction with
+     * {@link RequestDispatcher}.
+     * <p>
+     * Attribute names should follow the same conventions as package names.
+     * Names beginning with <code>java.*</code> and <code>javax.*</code> are
+     * reserved for use by the Servlet specification. Names beginning with
+     * <code>sun.*</code>, <code>com.sun.*</code>, <code>oracle.*</code> and
+     * <code>com.oracle.*</code>) are reserved for use by Oracle Corporation.
+     * <br>
+     * If the object passed in is null, the effect is the same as calling
+     * {@link #removeAttribute}. <br>
+     * It is warned that when the request is dispatched from the servlet resides
+     * in a different web application by <code>RequestDispatcher</code>, the
+     * object set by this method may not be correctly retrieved in the caller
+     * servlet.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the attribute
+     * @param o
+     *            the <code>Object</code> to be stored
+     */
+    public void setAttribute(String name, Object o);
+
+    /**
+     * Removes an attribute from this request. This method is not generally
+     * needed as attributes only persist as long as the request is being
+     * handled.
+     * <p>
+     * Attribute names should follow the same conventions as package names.
+     * Names beginning with <code>java.*</code> and <code>javax.*</code> are
+     * reserved for use by the Servlet specification. Names beginning with
+     * <code>sun.*</code>, <code>com.sun.*</code>, <code>oracle.*</code> and
+     * <code>com.oracle.*</code>) are reserved for use by Oracle Corporation.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the attribute to
+     *            remove
+     */
+    public void removeAttribute(String name);
+
+    /**
+     * Returns the preferred <code>Locale</code> that the client will accept
+     * content in, based on the Accept-Language header. If the client request
+     * doesn't provide an Accept-Language header, this method returns the
+     * default locale for the server.
+     *
+     * @return the preferred <code>Locale</code> for the client
+     */
+    public Locale getLocale();
+
+    /**
+     * Returns an <code>Enumeration</code> of <code>Locale</code> objects
+     * indicating, in decreasing order starting with the preferred locale, the
+     * locales that are acceptable to the client based on the Accept-Language
+     * header. If the client request doesn't provide an Accept-Language header,
+     * this method returns an <code>Enumeration</code> containing one
+     * <code>Locale</code>, the default locale for the server.
+     *
+     * @return an <code>Enumeration</code> of preferred <code>Locale</code>
+     *         objects for the client
+     */
+    public Enumeration<Locale> getLocales();
+
+    /**
+     * Returns a boolean indicating whether this request was made using a secure
+     * channel, such as HTTPS.
+     *
+     * @return a boolean indicating if the request was made using a secure
+     *         channel
+     */
+    public boolean isSecure();
+
+    /**
+     * Returns a {@link RequestDispatcher} object that acts as a wrapper for the
+     * resource located at the given path. A <code>RequestDispatcher</code>
+     * object can be used to forward a request to the resource or to include the
+     * resource in a response. The resource can be dynamic or static.
+     * <p>
+     * The pathname specified may be relative, although it cannot extend outside
+     * the current servlet context. If the path begins with a "/" it is
+     * interpreted as relative to the current context root. This method returns
+     * <code>null</code> if the servlet container cannot return a
+     * <code>RequestDispatcher</code>.
+     * <p>
+     * The difference between this method and
+     * {@link ServletContext#getRequestDispatcher} is that this method can take
+     * a relative path.
+     *
+     * @param path
+     *            a <code>String</code> specifying the pathname to the resource.
+     *            If it is relative, it must be relative against the current
+     *            servlet.
+     * @return a <code>RequestDispatcher</code> object that acts as a wrapper for
+     *         the resource at the specified path, or <code>null</code> if the
+     *         servlet container cannot return a <code>RequestDispatcher</code>
+     * @see RequestDispatcher
+     * @see ServletContext#getRequestDispatcher
+     */
+    public RequestDispatcher getRequestDispatcher(String path);
+
+    /**
+     * @param path The virtual path to be converted to a real path
+     * @return {@link ServletContext#getRealPath(String)}
+     * @deprecated As of Version 2.1 of the Java Servlet API, use
+     *             {@link ServletContext#getRealPath} instead.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public String getRealPath(String path);
+
+    /**
+     * Returns the Internet Protocol (IP) source port of the client or last
+     * proxy that sent the request.
+     *
+     * @return an integer specifying the port number
+     * @since Servlet 2.4
+     */
+    public int getRemotePort();
+
+    /**
+     * Returns the host name of the Internet Protocol (IP) interface on which
+     * the request was received.
+     *
+     * @return a <code>String</code> containing the host name of the IP on which
+     *         the request was received.
+     * @since Servlet 2.4
+     */
+    public String getLocalName();
+
+    /**
+     * Returns the Internet Protocol (IP) address of the interface on which the
+     * request was received.
+     *
+     * @return a <code>String</code> containing the IP address on which the
+     *         request was received.
+     * @since Servlet 2.4
+     */
+    public String getLocalAddr();
+
+    /**
+     * Returns the Internet Protocol (IP) port number of the interface on which
+     * the request was received.
+     *
+     * @return an integer specifying the port number
+     * @since Servlet 2.4
+     */
+    public int getLocalPort();
+
+    /**
+     * @return TODO
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public ServletContext getServletContext();
+
+    /**
+     * @return TODO
+     * @throws IllegalStateException If async is not supported for this request
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public AsyncContext startAsync() throws IllegalStateException;
+
+    /**
+     * @param servletRequest    The ServletRequest with which to initialise the
+     *                          asynchronous context
+     * @param servletResponse   The ServletResponse with which to initialise the
+     *                          asynchronous context
+     * @return TODO
+     * @throws IllegalStateException If async is not supported for this request
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public AsyncContext startAsync(ServletRequest servletRequest,
+            ServletResponse servletResponse) throws IllegalStateException;
+
+    /**
+     * @return TODO
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public boolean isAsyncStarted();
+
+    /**
+     * @return TODO
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public boolean isAsyncSupported();
+
+    /**
+     * Get the current AsyncContext.
+     *
+     * @return The current AsyncContext
+     *
+     * @throws IllegalStateException if the request is not in asynchronous mode
+     *         (i.e. @link #isAsyncStarted() is {@code false})
+     *
+     * @since Servlet 3.0
+     */
+    public AsyncContext getAsyncContext();
+
+    /**
+     * @return TODO
+     * @since Servlet 3.0 TODO SERVLET3 - Add comments
+     */
+    public DispatcherType getDispatcherType();
+}

java/javax/servlet/ServletRequestAttributeEvent.java

@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+/**
+ * This is the event class for notifications of changes to the attributes of the
+ * servlet request in an application.
+ *
+ * @see ServletRequestAttributeListener
+ * @since Servlet 2.4
+ */
+public class ServletRequestAttributeEvent extends ServletRequestEvent {
+    private static final long serialVersionUID = 1L;
+
+    private final String name;
+    private final Object value;
+
+    /**
+     * Construct a ServletRequestAttributeEvent giving the servlet context of
+     * this web application, the ServletRequest whose attributes are changing
+     * and the name and value of the attribute.
+     *
+     * @param sc
+     *            the ServletContext that is sending the event.
+     * @param request
+     *            the ServletRequest that is sending the event.
+     * @param name
+     *            the name of the request attribute.
+     * @param value
+     *            the value of the request attribute.
+     */
+    public ServletRequestAttributeEvent(ServletContext sc,
+            ServletRequest request, String name, Object value) {
+        super(sc, request);
+        this.name = name;
+        this.value = value;
+    }
+
+    /**
+     * Return the name of the attribute that changed on the ServletRequest.
+     *
+     * @return the name of the changed request attribute
+     */
+    public String getName() {
+        return this.name;
+    }
+
+    /**
+     * Returns the value of the attribute that has been added, removed or
+     * replaced. If the attribute was added, this is the value of the attribute.
+     * If the attribute was removed, this is the value of the removed attribute.
+     * If the attribute was replaced, this is the old value of the attribute.
+     *
+     * @return the value of the changed request attribute
+     */
+    public Object getValue() {
+        return this.value;
+    }
+}

java/javax/servlet/ServletRequestAttributeListener.java

@@ -0,0 +1,55 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.EventListener;
+
+/**
+ * A ServletRequestAttributeListener can be implemented by the
+ * developer interested in being notified of request attribute
+ * changes. Notifications will be generated while the request
+ * is within the scope of the web application in which the listener
+ * is registered. A request is defined as coming into scope when
+ * it is about to enter the first servlet or filter in each web
+ * application, as going out of scope when it exits the last servlet
+ * or the first filter in the chain.
+ *
+ * @since Servlet 2.4
+ */
+public interface ServletRequestAttributeListener extends EventListener {
+    /**
+     * Notification that a new attribute was added to the
+     * servlet request. Called after the attribute is added.
+     * @param srae Information about the new request attribute
+     */
+    public void attributeAdded(ServletRequestAttributeEvent srae);
+
+    /**
+     * Notification that an existing attribute has been removed from the
+     * servlet request. Called after the attribute is removed.
+     * @param srae Information about the removed request attribute
+     */
+    public void attributeRemoved(ServletRequestAttributeEvent srae);
+
+    /**
+     * Notification that an attribute was replaced on the
+     * servlet request. Called after the attribute is replaced.
+     * @param srae Information about the replaced request attribute
+     */
+    public void attributeReplaced(ServletRequestAttributeEvent srae);
+}
+

java/javax/servlet/ServletRequestEvent.java

@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+/**
+ * Events of this kind indicate lifecycle events for a ServletRequest. The
+ * source of the event is the ServletContext of this web application.
+ *
+ * @see ServletRequestListener
+ * @since Servlet 2.4
+ */
+public class ServletRequestEvent extends java.util.EventObject {
+    private static final long serialVersionUID = 1L;
+
+    private final transient ServletRequest request;
+
+    /**
+     * Construct a ServletRequestEvent for the given ServletContext and
+     * ServletRequest.
+     *
+     * @param sc
+     *            the ServletContext of the web application.
+     * @param request
+     *            the ServletRequest that is sending the event.
+     */
+    public ServletRequestEvent(ServletContext sc, ServletRequest request) {
+        super(sc);
+        this.request = request;
+    }
+
+    /**
+     * Get the associated ServletRequest.
+     * @return the ServletRequest that is changing.
+     */
+    public ServletRequest getServletRequest() {
+        return this.request;
+    }
+
+    /**
+     * Get the associated ServletContext.
+     * @return the ServletContext that is changing.
+     */
+    public ServletContext getServletContext() {
+        return (ServletContext) super.getSource();
+    }
+}

java/javax/servlet/ServletRequestListener.java

@@ -0,0 +1,44 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+import java.util.EventListener;
+
+/**
+ * A ServletRequestListener can be implemented by the developer
+ * interested in being notified of requests coming in and out of
+ * scope in a web component. A request is defined as coming into
+ * scope when it is about to enter the first servlet or filter
+ * in each web application, as going out of scope when it exits
+ * the last servlet or the first filter in the chain.
+ *
+ * @since Servlet 2.4
+ */
+public interface ServletRequestListener extends EventListener {
+
+    /**
+     * The request is about to go out of scope of the web application.
+     * @param sre Information about the request
+     */
+    public void requestDestroyed (ServletRequestEvent sre);
+
+    /**
+     * The request is about to come into scope of the web application.
+     * @param sre Information about the request
+     */
+    public void requestInitialized (ServletRequestEvent sre);
+}

java/javax/servlet/ServletRequestWrapper.java

@@ -0,0 +1,481 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Provides a convenient implementation of the ServletRequest interface that can
+ * be subclassed by developers wishing to adapt the request to a Servlet. This
+ * class implements the Wrapper or Decorator pattern. Methods default to calling
+ * through to the wrapped request object.
+ *
+ * @since Servlet 2.3
+ * @see javax.servlet.ServletRequest
+ */
+public class ServletRequestWrapper implements ServletRequest {
+    private ServletRequest request;
+
+    /**
+     * Creates a ServletRequest adaptor wrapping the given request object.
+     *
+     * @param request The request to wrap
+     *
+     * @throws IllegalArgumentException if the request is null
+     */
+    public ServletRequestWrapper(ServletRequest request) {
+        if (request == null) {
+            throw new IllegalArgumentException("Request cannot be null");
+        }
+        this.request = request;
+    }
+
+    /**
+     * Get the wrapped request.
+     * @return the wrapped request object
+     */
+    public ServletRequest getRequest() {
+        return this.request;
+    }
+
+    /**
+     * Sets the request object being wrapped.
+     * @param request The new wrapped request.
+     *
+     * @throws IllegalArgumentException if the request is null.
+     */
+    public void setRequest(ServletRequest request) {
+        if (request == null) {
+            throw new IllegalArgumentException("Request cannot be null");
+        }
+        this.request = request;
+    }
+
+    /**
+     * The default behavior of this method is to call getAttribute(String name)
+     * on the wrapped request object.
+     */
+    @Override
+    public Object getAttribute(String name) {
+        return this.request.getAttribute(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getAttributeNames() on
+     * the wrapped request object.
+     */
+    @Override
+    public Enumeration<String> getAttributeNames() {
+        return this.request.getAttributeNames();
+    }
+
+    /**
+     * The default behavior of this method is to return getCharacterEncoding()
+     * on the wrapped request object.
+     */
+    @Override
+    public String getCharacterEncoding() {
+        return this.request.getCharacterEncoding();
+    }
+
+    /**
+     * The default behavior of this method is to set the character encoding on
+     * the wrapped request object.
+     */
+    @Override
+    public void setCharacterEncoding(String enc)
+            throws java.io.UnsupportedEncodingException {
+        this.request.setCharacterEncoding(enc);
+    }
+
+    /**
+     * The default behavior of this method is to return getContentLength() on
+     * the wrapped request object.
+     */
+    @Override
+    public int getContentLength() {
+        return this.request.getContentLength();
+    }
+
+    /**
+     * The default behavior of this method is to return getContentLengthLong()
+     * on the wrapped request object.
+     *
+     * @since Servlet 3.1
+     */
+    @Override
+    public long getContentLengthLong() {
+        return this.request.getContentLengthLong();
+    }
+
+    /**
+     * The default behavior of this method is to return getContentType() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getContentType() {
+        return this.request.getContentType();
+    }
+
+    /**
+     * The default behavior of this method is to return getInputStream() on the
+     * wrapped request object.
+     */
+    @Override
+    public ServletInputStream getInputStream() throws IOException {
+        return this.request.getInputStream();
+    }
+
+    /**
+     * The default behavior of this method is to return getParameter(String
+     * name) on the wrapped request object.
+     */
+    @Override
+    public String getParameter(String name) {
+        return this.request.getParameter(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getParameterMap() on the
+     * wrapped request object.
+     */
+    @Override
+    public Map<String, String[]> getParameterMap() {
+        return this.request.getParameterMap();
+    }
+
+    /**
+     * The default behavior of this method is to return getParameterNames() on
+     * the wrapped request object.
+     */
+    @Override
+    public Enumeration<String> getParameterNames() {
+        return this.request.getParameterNames();
+    }
+
+    /**
+     * The default behavior of this method is to return
+     * getParameterValues(String name) on the wrapped request object.
+     */
+    @Override
+    public String[] getParameterValues(String name) {
+        return this.request.getParameterValues(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getProtocol() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getProtocol() {
+        return this.request.getProtocol();
+    }
+
+    /**
+     * The default behavior of this method is to return getScheme() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getScheme() {
+        return this.request.getScheme();
+    }
+
+    /**
+     * The default behavior of this method is to return getServerName() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getServerName() {
+        return this.request.getServerName();
+    }
+
+    /**
+     * The default behavior of this method is to return getServerPort() on the
+     * wrapped request object.
+     */
+    @Override
+    public int getServerPort() {
+        return this.request.getServerPort();
+    }
+
+    /**
+     * The default behavior of this method is to return getReader() on the
+     * wrapped request object.
+     */
+    @Override
+    public BufferedReader getReader() throws IOException {
+        return this.request.getReader();
+    }
+
+    /**
+     * The default behavior of this method is to return getRemoteAddr() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getRemoteAddr() {
+        return this.request.getRemoteAddr();
+    }
+
+    /**
+     * The default behavior of this method is to return getRemoteHost() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getRemoteHost() {
+        return this.request.getRemoteHost();
+    }
+
+    /**
+     * The default behavior of this method is to return setAttribute(String
+     * name, Object o) on the wrapped request object.
+     */
+    @Override
+    public void setAttribute(String name, Object o) {
+        this.request.setAttribute(name, o);
+    }
+
+    /**
+     * The default behavior of this method is to call removeAttribute(String
+     * name) on the wrapped request object.
+     */
+    @Override
+    public void removeAttribute(String name) {
+        this.request.removeAttribute(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getLocale() on the
+     * wrapped request object.
+     */
+    @Override
+    public Locale getLocale() {
+        return this.request.getLocale();
+    }
+
+    /**
+     * The default behavior of this method is to return getLocales() on the
+     * wrapped request object.
+     */
+    @Override
+    public Enumeration<Locale> getLocales() {
+        return this.request.getLocales();
+    }
+
+    /**
+     * The default behavior of this method is to return isSecure() on the
+     * wrapped request object.
+     */
+    @Override
+    public boolean isSecure() {
+        return this.request.isSecure();
+    }
+
+    /**
+     * The default behavior of this method is to return
+     * getRequestDispatcher(String path) on the wrapped request object.
+     */
+    @Override
+    public RequestDispatcher getRequestDispatcher(String path) {
+        return this.request.getRequestDispatcher(path);
+    }
+
+    /**
+     * The default behavior of this method is to return getRealPath(String path)
+     * on the wrapped request object.
+     *
+     * @deprecated As of Version 3.0 of the Java Servlet API
+     */
+    @Override
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public String getRealPath(String path) {
+        return this.request.getRealPath(path);
+    }
+
+    /**
+     * The default behavior of this method is to return getRemotePort() on the
+     * wrapped request object.
+     *
+     * @since Servlet 2.4
+     */
+    @Override
+    public int getRemotePort() {
+        return this.request.getRemotePort();
+    }
+
+    /**
+     * The default behavior of this method is to return getLocalName() on the
+     * wrapped request object.
+     *
+     * @since Servlet 2.4
+     */
+    @Override
+    public String getLocalName() {
+        return this.request.getLocalName();
+    }
+
+    /**
+     * The default behavior of this method is to return getLocalAddr() on the
+     * wrapped request object.
+     *
+     * @since Servlet 2.4
+     */
+    @Override
+    public String getLocalAddr() {
+        return this.request.getLocalAddr();
+    }
+
+    /**
+     * The default behavior of this method is to return getLocalPort() on the
+     * wrapped request object.
+     *
+     * @since Servlet 2.4
+     */
+    @Override
+    public int getLocalPort() {
+        return this.request.getLocalPort();
+    }
+
+    /**
+     * The default behavior of this method is to return getServletContext() on
+     * the wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public ServletContext getServletContext() {
+        return request.getServletContext();
+    }
+
+    /**
+     * The default behavior of this method is to return startAsync() on the
+     * wrapped request object.
+     *
+     * @throws IllegalStateException If asynchronous processing is not supported
+     *         for this request or if the request is already in asynchronous
+     *         mode
+     * @since Servlet 3.0
+     */
+    @Override
+    public AsyncContext startAsync() throws IllegalStateException {
+        return request.startAsync();
+    }
+
+    /**
+     * The default behavior of this method is to return startAsync(Runnable) on
+     * the wrapped request object.
+     *
+     * @param servletRequest    The ServletRequest with which to initialise the
+     *                          asynchronous context
+     * @param servletResponse   The ServletResponse with which to initialise the
+     *                          asynchronous context
+     * @throws IllegalStateException If asynchronous processing is not supported
+     *         for this request or if the request is already in asynchronous
+     *         mode
+     * @since Servlet 3.0
+     */
+    @Override
+    public AsyncContext startAsync(ServletRequest servletRequest,
+            ServletResponse servletResponse) throws IllegalStateException {
+        return request.startAsync(servletRequest, servletResponse);
+    }
+
+    /**
+     * The default behavior of this method is to return isAsyncStarted() on the
+     * wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public boolean isAsyncStarted() {
+        return request.isAsyncStarted();
+    }
+
+    /**
+     * The default behavior of this method is to return isAsyncSupported() on
+     * the wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public boolean isAsyncSupported() {
+        return request.isAsyncSupported();
+    }
+
+    /**
+     * The default behavior of this method is to return getAsyncContext() on the
+     * wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public AsyncContext getAsyncContext() {
+        return request.getAsyncContext();
+    }
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param wrapped The request to compare to the wrapped request
+     * @return <code>true</code> if the request wrapped by this wrapper (or
+     *         series of wrappers) is the same as the supplied request,
+     *         otherwise <code>false</code>
+     * @since Servlet 3.0
+     */
+    public boolean isWrapperFor(ServletRequest wrapped) {
+        if (request == wrapped) {
+            return true;
+        }
+        if (request instanceof ServletRequestWrapper) {
+            return ((ServletRequestWrapper) request).isWrapperFor(wrapped);
+        }
+        return false;
+    }
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param wrappedType The class to compare to the class of the wrapped
+     *                    request
+     * @return <code>true</code> if the request wrapped by this wrapper (or
+     *         series of wrappers) is the same type as the supplied type,
+     *         otherwise <code>false</code>
+     * @since Servlet 3.0
+     */
+    public boolean isWrapperFor(Class<?> wrappedType) {
+        if (wrappedType.isAssignableFrom(request.getClass())) {
+            return true;
+        }
+        if (request instanceof ServletRequestWrapper) {
+            return ((ServletRequestWrapper) request).isWrapperFor(wrappedType);
+        }
+        return false;
+    }
+
+    /**
+     * The default behavior of this method is to call getDispatcherType() on the
+     * wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public DispatcherType getDispatcherType() {
+        return this.request.getDispatcherType();
+    }
+}

java/javax/servlet/ServletResponse.java

@@ -0,0 +1,354 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Locale;
+
+/**
+ * Defines an object to assist a servlet in sending a response to the client.
+ * The servlet container creates a <code>ServletResponse</code> object and
+ * passes it as an argument to the servlet's <code>service</code> method.
+ * <p>
+ * To send binary data in a MIME body response, use the
+ * {@link ServletOutputStream} returned by {@link #getOutputStream}. To send
+ * character data, use the <code>PrintWriter</code> object returned by
+ * {@link #getWriter}. To mix binary and text data, for example, to create a
+ * multipart response, use a <code>ServletOutputStream</code> and manage the
+ * character sections manually.
+ * <p>
+ * The charset for the MIME body response can be specified explicitly using the
+ * {@link #setCharacterEncoding} and {@link #setContentType} methods, or
+ * implicitly using the {@link #setLocale} method. Explicit specifications take
+ * precedence over implicit specifications. If no charset is specified,
+ * ISO-8859-1 will be used. The <code>setCharacterEncoding</code>,
+ * <code>setContentType</code>, or <code>setLocale</code> method must be called
+ * before <code>getWriter</code> and before committing the response for the
+ * character encoding to be used.
+ * <p>
+ * See the Internet RFCs such as <a href="http://www.ietf.org/rfc/rfc2045.txt">
+ * RFC 2045</a> for more information on MIME. Protocols such as SMTP and HTTP
+ * define profiles of MIME, and those standards are still evolving.
+ *
+ * @see ServletOutputStream
+ */
+public interface ServletResponse {
+
+    /**
+     * Returns the name of the character encoding (MIME charset) used for the
+     * body sent in this response. The character encoding may have been
+     * specified explicitly using the {@link #setCharacterEncoding} or
+     * {@link #setContentType} methods, or implicitly using the
+     * {@link #setLocale} method. Explicit specifications take precedence over
+     * implicit specifications. Calls made to these methods after
+     * <code>getWriter</code> has been called or after the response has been
+     * committed have no effect on the character encoding. If no character
+     * encoding has been specified, <code>ISO-8859-1</code> is returned.
+     * <p>
+     * See RFC 2047 (http://www.ietf.org/rfc/rfc2047.txt) for more information
+     * about character encoding and MIME.
+     *
+     * @return a <code>String</code> specifying the name of the character
+     *         encoding, for example, <code>UTF-8</code>
+     */
+    public String getCharacterEncoding();
+
+    /**
+     * Returns the content type used for the MIME body sent in this response.
+     * The content type proper must have been specified using
+     * {@link #setContentType} before the response is committed. If no content
+     * type has been specified, this method returns null. If a content type has
+     * been specified and a character encoding has been explicitly or implicitly
+     * specified as described in {@link #getCharacterEncoding}, the charset
+     * parameter is included in the string returned. If no character encoding
+     * has been specified, the charset parameter is omitted.
+     *
+     * @return a <code>String</code> specifying the content type, for example,
+     *         <code>text/html; charset=UTF-8</code>, or null
+     * @since 2.4
+     */
+    public String getContentType();
+
+    /**
+     * Returns a {@link ServletOutputStream} suitable for writing binary data in
+     * the response. The servlet container does not encode the binary data.
+     * <p>
+     * Calling flush() on the ServletOutputStream commits the response. Either
+     * this method or {@link #getWriter} may be called to write the body, not
+     * both.
+     *
+     * @return a {@link ServletOutputStream} for writing binary data
+     * @exception IllegalStateException
+     *                if the <code>getWriter</code> method has been called on
+     *                this response
+     * @exception IOException
+     *                if an input or output exception occurred
+     * @see #getWriter
+     */
+    public ServletOutputStream getOutputStream() throws IOException;
+
+    /**
+     * Returns a <code>PrintWriter</code> object that can send character text to
+     * the client. The <code>PrintWriter</code> uses the character encoding
+     * returned by {@link #getCharacterEncoding}. If the response's character
+     * encoding has not been specified as described in
+     * <code>getCharacterEncoding</code> (i.e., the method just returns the
+     * default value <code>ISO-8859-1</code>), <code>getWriter</code> updates it
+     * to <code>ISO-8859-1</code>.
+     * <p>
+     * Calling flush() on the <code>PrintWriter</code> commits the response.
+     * <p>
+     * Either this method or {@link #getOutputStream} may be called to write the
+     * body, not both.
+     *
+     * @return a <code>PrintWriter</code> object that can return character data
+     *         to the client
+     * @exception java.io.UnsupportedEncodingException
+     *                if the character encoding returned by
+     *                <code>getCharacterEncoding</code> cannot be used
+     * @exception IllegalStateException
+     *                if the <code>getOutputStream</code> method has already
+     *                been called for this response object
+     * @exception IOException
+     *                if an input or output exception occurred
+     * @see #getOutputStream
+     * @see #setCharacterEncoding
+     */
+    public PrintWriter getWriter() throws IOException;
+
+    /**
+     * Sets the character encoding (MIME charset) of the response being sent to
+     * the client, for example, to UTF-8. If the character encoding has already
+     * been set by {@link #setContentType} or {@link #setLocale}, this method
+     * overrides it. Calling {@link #setContentType} with the
+     * <code>String</code> of <code>text/html</code> and calling this method
+     * with the <code>String</code> of <code>UTF-8</code> is equivalent with
+     * calling <code>setContentType</code> with the <code>String</code> of
+     * <code>text/html; charset=UTF-8</code>.
+     * <p>
+     * This method can be called repeatedly to change the character encoding.
+     * This method has no effect if it is called after <code>getWriter</code>
+     * has been called or after the response has been committed.
+     * <p>
+     * Containers must communicate the character encoding used for the servlet
+     * response's writer to the client if the protocol provides a way for doing
+     * so. In the case of HTTP, the character encoding is communicated as part
+     * of the <code>Content-Type</code> header for text media types. Note that
+     * the character encoding cannot be communicated via HTTP headers if the
+     * servlet does not specify a content type; however, it is still used to
+     * encode text written via the servlet response's writer.
+     *
+     * @param charset
+     *            a String specifying only the character set defined by IANA
+     *            Character Sets
+     *            (http://www.iana.org/assignments/character-sets)
+     * @see #setContentType #setLocale
+     * @since 2.4
+     */
+    public void setCharacterEncoding(String charset);
+
+    /**
+     * Sets the length of the content body in the response In HTTP servlets,
+     * this method sets the HTTP Content-Length header.
+     *
+     * @param len
+     *            an integer specifying the length of the content being returned
+     *            to the client; sets the Content-Length header
+     */
+    public void setContentLength(int len);
+
+    /**
+     * Sets the length of the content body in the response In HTTP servlets,
+     * this method sets the HTTP Content-Length header.
+     *
+     * @param length
+     *            an integer specifying the length of the content being returned
+     *            to the client; sets the Content-Length header
+     *
+     * @since Servlet 3.1
+     */
+    public void setContentLengthLong(long length);
+
+    /**
+     * Sets the content type of the response being sent to the client, if the
+     * response has not been committed yet. The given content type may include a
+     * character encoding specification, for example,
+     * <code>text/html;charset=UTF-8</code>. The response's character encoding
+     * is only set from the given content type if this method is called before
+     * <code>getWriter</code> is called.
+     * <p>
+     * This method may be called repeatedly to change content type and character
+     * encoding. This method has no effect if called after the response has been
+     * committed. It does not set the response's character encoding if it is
+     * called after <code>getWriter</code> has been called or after the response
+     * has been committed.
+     * <p>
+     * Containers must communicate the content type and the character encoding
+     * used for the servlet response's writer to the client if the protocol
+     * provides a way for doing so. In the case of HTTP, the
+     * <code>Content-Type</code> header is used.
+     *
+     * @param type
+     *            a <code>String</code> specifying the MIME type of the content
+     * @see #setLocale
+     * @see #setCharacterEncoding
+     * @see #getOutputStream
+     * @see #getWriter
+     */
+    public void setContentType(String type);
+
+    /**
+     * Sets the preferred buffer size for the body of the response. The servlet
+     * container will use a buffer at least as large as the size requested. The
+     * actual buffer size used can be found using <code>getBufferSize</code>.
+     * <p>
+     * A larger buffer allows more content to be written before anything is
+     * actually sent, thus providing the servlet with more time to set
+     * appropriate status codes and headers. A smaller buffer decreases server
+     * memory load and allows the client to start receiving data more quickly.
+     * <p>
+     * This method must be called before any response body content is written;
+     * if content has been written or the response object has been committed,
+     * this method throws an <code>IllegalStateException</code>.
+     *
+     * @param size
+     *            the preferred buffer size
+     * @exception IllegalStateException
+     *                if this method is called after content has been written
+     * @see #getBufferSize
+     * @see #flushBuffer
+     * @see #isCommitted
+     * @see #reset
+     */
+    public void setBufferSize(int size);
+
+    /**
+     * Returns the actual buffer size used for the response. If no buffering is
+     * used, this method returns 0.
+     *
+     * @return the actual buffer size used
+     * @see #setBufferSize
+     * @see #flushBuffer
+     * @see #isCommitted
+     * @see #reset
+     */
+    public int getBufferSize();
+
+    /**
+     * Forces any content in the buffer to be written to the client. A call to
+     * this method automatically commits the response, meaning the status code
+     * and headers will be written.
+     *
+     * @throws IOException if an I/O occurs during the flushing of the response
+     *
+     * @see #setBufferSize
+     * @see #getBufferSize
+     * @see #isCommitted
+     * @see #reset
+     */
+    public void flushBuffer() throws IOException;
+
+    /**
+     * Clears the content of the underlying buffer in the response without
+     * clearing headers or status code. If the response has been committed, this
+     * method throws an <code>IllegalStateException</code>.
+     *
+     * @see #setBufferSize
+     * @see #getBufferSize
+     * @see #isCommitted
+     * @see #reset
+     * @since 2.3
+     */
+    public void resetBuffer();
+
+    /**
+     * Returns a boolean indicating if the response has been committed. A
+     * committed response has already had its status code and headers written.
+     *
+     * @return a boolean indicating if the response has been committed
+     * @see #setBufferSize
+     * @see #getBufferSize
+     * @see #flushBuffer
+     * @see #reset
+     */
+    public boolean isCommitted();
+
+    /**
+     * Clears any data that exists in the buffer as well as the status code and
+     * headers. If the response has been committed, this method throws an
+     * <code>IllegalStateException</code>.
+     *
+     * @exception IllegalStateException
+     *                if the response has already been committed
+     * @see #setBufferSize
+     * @see #getBufferSize
+     * @see #flushBuffer
+     * @see #isCommitted
+     */
+    public void reset();
+
+    /**
+     * Sets the locale of the response, if the response has not been committed
+     * yet. It also sets the response's character encoding appropriately for the
+     * locale, if the character encoding has not been explicitly set using
+     * {@link #setContentType} or {@link #setCharacterEncoding},
+     * <code>getWriter</code> hasn't been called yet, and the response hasn't
+     * been committed yet. If the deployment descriptor contains a
+     * <code>locale-encoding-mapping-list</code> element, and that element
+     * provides a mapping for the given locale, that mapping is used. Otherwise,
+     * the mapping from locale to character encoding is container dependent.
+     * <p>
+     * This method may be called repeatedly to change locale and character
+     * encoding. The method has no effect if called after the response has been
+     * committed. It does not set the response's character encoding if it is
+     * called after {@link #setContentType} has been called with a charset
+     * specification, after {@link #setCharacterEncoding} has been called, after
+     * <code>getWriter</code> has been called, or after the response has been
+     * committed.
+     * <p>
+     * Containers must communicate the locale and the character encoding used
+     * for the servlet response's writer to the client if the protocol provides
+     * a way for doing so. In the case of HTTP, the locale is communicated via
+     * the <code>Content-Language</code> header, the character encoding as part
+     * of the <code>Content-Type</code> header for text media types. Note that
+     * the character encoding cannot be communicated via HTTP headers if the
+     * servlet does not specify a content type; however, it is still used to
+     * encode text written via the servlet response's writer.
+     *
+     * @param loc
+     *            the locale of the response
+     * @see #getLocale
+     * @see #setContentType
+     * @see #setCharacterEncoding
+     */
+    public void setLocale(Locale loc);
+
+    /**
+     * Returns the locale specified for this response using the
+     * {@link #setLocale} method. Calls made to <code>setLocale</code> after the
+     * response is committed have no effect.
+     *
+     * @return The locale specified for this response using the
+     *          {@link #setLocale} method. If no locale has been specified, the
+     *          container's default locale is returned.
+     *
+     * @see #setLocale
+     */
+    public Locale getLocale();
+
+}

java/javax/servlet/ServletResponseWrapper.java

@@ -0,0 +1,261 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Locale;
+
+/**
+ * Provides a convenient implementation of the ServletResponse interface that
+ * can be subclassed by developers wishing to adapt the response from a Servlet.
+ * This class implements the Wrapper or Decorator pattern. Methods default to
+ * calling through to the wrapped response object.
+ *
+ * @since v 2.3
+ * @see javax.servlet.ServletResponse
+ */
+public class ServletResponseWrapper implements ServletResponse {
+    private ServletResponse response;
+
+    /**
+     * Creates a ServletResponse adaptor wrapping the given response object.
+     *
+     * @param response The response to wrap
+     *
+     * @throws java.lang.IllegalArgumentException
+     *             if the response is null.
+     */
+    public ServletResponseWrapper(ServletResponse response) {
+        if (response == null) {
+            throw new IllegalArgumentException("Response cannot be null");
+        }
+        this.response = response;
+    }
+
+    /**
+     * Return the wrapped ServletResponse object.
+     *
+     * @return The wrapped ServletResponse object.
+     */
+    public ServletResponse getResponse() {
+        return this.response;
+    }
+
+    /**
+     * Sets the response being wrapped.
+     *
+     * @param response The new response to wrap
+     *
+     * @throws java.lang.IllegalArgumentException
+     *             if the response is null.
+     */
+    public void setResponse(ServletResponse response) {
+        if (response == null) {
+            throw new IllegalArgumentException("Response cannot be null");
+        }
+        this.response = response;
+    }
+
+    /**
+     * The default behavior of this method is to call
+     * setCharacterEncoding(String charset) on the wrapped response object.
+     *
+     * @since 2.4
+     */
+    @Override
+    public void setCharacterEncoding(String charset) {
+        this.response.setCharacterEncoding(charset);
+    }
+
+    /**
+     * The default behavior of this method is to return getCharacterEncoding()
+     * on the wrapped response object.
+     */
+    @Override
+    public String getCharacterEncoding() {
+        return this.response.getCharacterEncoding();
+    }
+
+    /**
+     * The default behavior of this method is to return getOutputStream() on the
+     * wrapped response object.
+     */
+    @Override
+    public ServletOutputStream getOutputStream() throws IOException {
+        return this.response.getOutputStream();
+    }
+
+    /**
+     * The default behavior of this method is to return getWriter() on the
+     * wrapped response object.
+     */
+    @Override
+    public PrintWriter getWriter() throws IOException {
+        return this.response.getWriter();
+    }
+
+    /**
+     * The default behavior of this method is to call setContentLength(int len)
+     * on the wrapped response object.
+     */
+    @Override
+    public void setContentLength(int len) {
+        this.response.setContentLength(len);
+    }
+
+    /**
+     * The default behavior of this method is to call setContentLengthLong(long len)
+     * on the wrapped response object.
+     *
+     * @since Servlet 3.1
+     */
+    @Override
+    public void setContentLengthLong(long length) {
+        this.response.setContentLengthLong(length);
+    }
+
+    /**
+     * The default behavior of this method is to call setContentType(String
+     * type) on the wrapped response object.
+     */
+    @Override
+    public void setContentType(String type) {
+        this.response.setContentType(type);
+    }
+
+    /**
+     * The default behavior of this method is to return getContentType() on the
+     * wrapped response object.
+     *
+     * @since 2.4
+     */
+    @Override
+    public String getContentType() {
+        return this.response.getContentType();
+    }
+
+    /**
+     * The default behavior of this method is to call setBufferSize(int size) on
+     * the wrapped response object.
+     */
+    @Override
+    public void setBufferSize(int size) {
+        this.response.setBufferSize(size);
+    }
+
+    /**
+     * The default behavior of this method is to return getBufferSize() on the
+     * wrapped response object.
+     */
+    @Override
+    public int getBufferSize() {
+        return this.response.getBufferSize();
+    }
+
+    /**
+     * The default behavior of this method is to call flushBuffer() on the
+     * wrapped response object.
+     */
+    @Override
+    public void flushBuffer() throws IOException {
+        this.response.flushBuffer();
+    }
+
+    /**
+     * The default behavior of this method is to return isCommitted() on the
+     * wrapped response object.
+     */
+    @Override
+    public boolean isCommitted() {
+        return this.response.isCommitted();
+    }
+
+    /**
+     * The default behavior of this method is to call reset() on the wrapped
+     * response object.
+     */
+    @Override
+    public void reset() {
+        this.response.reset();
+    }
+
+    /**
+     * The default behavior of this method is to call resetBuffer() on the
+     * wrapped response object.
+     */
+    @Override
+    public void resetBuffer() {
+        this.response.resetBuffer();
+    }
+
+    /**
+     * The default behavior of this method is to call setLocale(Locale loc) on
+     * the wrapped response object.
+     */
+    @Override
+    public void setLocale(Locale loc) {
+        this.response.setLocale(loc);
+    }
+
+    /**
+     * The default behavior of this method is to return getLocale() on the
+     * wrapped response object.
+     */
+    @Override
+    public Locale getLocale() {
+        return this.response.getLocale();
+    }
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param wrapped The response to compare to the wrapped response
+     * @return <code>true</code> if the response wrapped by this wrapper (or
+     *         series of wrappers) is the same as the supplied response,
+     *         otherwise <code>false</code>
+     * @since Servlet 3.0
+     */
+    public boolean isWrapperFor(ServletResponse wrapped) {
+        if (response == wrapped) {
+            return true;
+        }
+        if (response instanceof ServletResponseWrapper) {
+            return ((ServletResponseWrapper) response).isWrapperFor(wrapped);
+        }
+        return false;
+    }
+
+    /**
+     * TODO SERVLET3 - Add comments
+     * @param wrappedType The class to compare to the class of the wrapped
+     *                    response
+     * @return <code>true</code> if the response wrapped by this wrapper (or
+     *         series of wrappers) is the same type as the supplied type,
+     *         otherwise <code>false</code>
+     * @since Servlet 3.0
+     */
+    public boolean isWrapperFor(Class<?> wrappedType) {
+        if (wrappedType.isAssignableFrom(response.getClass())) {
+            return true;
+        }
+        if (response instanceof ServletResponseWrapper) {
+            return ((ServletResponseWrapper) response).isWrapperFor(wrappedType);
+        }
+        return false;
+    }
+
+}

java/javax/servlet/ServletSecurityElement.java

@@ -0,0 +1,135 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.annotation.HttpMethodConstraint;
+import javax.servlet.annotation.ServletSecurity;
+
+/**
+ *
+ * @since Servlet 3.0
+ * TODO SERVLET3 - Add comments
+ */
+public class ServletSecurityElement extends HttpConstraintElement {
+
+    private final Map<String,HttpMethodConstraintElement> methodConstraints =
+        new HashMap<>();
+
+    /**
+     * Use default HttpConstraint.
+     */
+    public ServletSecurityElement() {
+        super();
+    }
+
+    /**
+     * Use specified HttpConstraintElement.
+     * @param httpConstraintElement The constraint
+     */
+    public ServletSecurityElement(HttpConstraintElement httpConstraintElement) {
+        this (httpConstraintElement, null);
+    }
+
+    /**
+     * Use specific constraints for specified methods and default
+     * HttpConstraintElement for all other methods.
+     * @param httpMethodConstraints Method constraints
+     * @throws IllegalArgumentException if a method name is specified more than
+     * once
+     */
+    public ServletSecurityElement(
+            Collection<HttpMethodConstraintElement> httpMethodConstraints) {
+        super();
+        addHttpMethodConstraints(httpMethodConstraints);
+    }
+
+
+    /**
+     * Use specified HttpConstraintElement as default and specific constraints
+     * for specified methods.
+     * @param httpConstraintElement Default constraint
+     * @param httpMethodConstraints Method constraints
+     * @throws IllegalArgumentException if a method name is specified more than
+     */
+    public ServletSecurityElement(HttpConstraintElement httpConstraintElement,
+            Collection<HttpMethodConstraintElement> httpMethodConstraints) {
+        super(httpConstraintElement.getEmptyRoleSemantic(),
+                httpConstraintElement.getTransportGuarantee(),
+                httpConstraintElement.getRolesAllowed());
+        addHttpMethodConstraints(httpMethodConstraints);
+    }
+
+    /**
+     * Create from an annotation.
+     * @param annotation Annotation to use as the basis for the new instance
+     * @throws IllegalArgumentException if a method name is specified more than
+     */
+    public ServletSecurityElement(ServletSecurity annotation) {
+        this(new HttpConstraintElement(annotation.value().value(),
+                annotation.value().transportGuarantee(),
+                annotation.value().rolesAllowed()));
+
+        List<HttpMethodConstraintElement> l = new ArrayList<>();
+        HttpMethodConstraint[] constraints = annotation.httpMethodConstraints();
+        if (constraints != null) {
+            for (int i = 0; i < constraints.length; i++) {
+                HttpMethodConstraintElement e =
+                    new HttpMethodConstraintElement(constraints[i].value(),
+                            new HttpConstraintElement(
+                                    constraints[i].emptyRoleSemantic(),
+                                    constraints[i].transportGuarantee(),
+                                    constraints[i].rolesAllowed()));
+                l.add(e);
+            }
+        }
+        addHttpMethodConstraints(l);
+    }
+
+    public Collection<HttpMethodConstraintElement> getHttpMethodConstraints() {
+        Collection<HttpMethodConstraintElement> result = new HashSet<>();
+        result.addAll(methodConstraints.values());
+        return result;
+    }
+
+    public Collection<String> getMethodNames() {
+        Collection<String> result = new HashSet<>();
+        result.addAll(methodConstraints.keySet());
+        return result;
+    }
+
+    private void addHttpMethodConstraints(
+            Collection<HttpMethodConstraintElement> httpMethodConstraints) {
+        if (httpMethodConstraints == null) {
+            return;
+        }
+        for (HttpMethodConstraintElement constraint : httpMethodConstraints) {
+            String method = constraint.getMethodName();
+            if (methodConstraints.containsKey(method)) {
+                throw new IllegalArgumentException(
+                        "Duplicate method name: " + method);
+            }
+            methodConstraints.put(method, constraint);
+        }
+    }
+}

java/javax/servlet/SessionCookieConfig.java

@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+/**
+ * Configures the session cookies used by the web application associated with
+ * the ServletContext from which this SessionCookieConfig was obtained.
+ *
+ * @since Servlet 3.0
+ */
+public interface SessionCookieConfig {
+
+    /**
+     * Sets the session cookie name.
+     *
+     * @param name The name of the session cookie
+     *
+     * @throws IllegalStateException if the associated ServletContext has
+     *         already been initialised
+     */
+    public void setName(String name);
+
+    public String getName();
+
+    /**
+     * Sets the domain for the session cookie
+     *
+     * @param domain The session cookie domain
+     *
+     * @throws IllegalStateException if the associated ServletContext has
+     *         already been initialised
+     */
+    public void setDomain(String domain);
+
+    public String getDomain();
+
+    /**
+     * Sets the path of the session cookie.
+     *
+     * @param path The session cookie path
+     *
+     * @throws IllegalStateException if the associated ServletContext has
+     *         already been initialised
+     */
+    public void setPath(String path);
+
+    public String getPath();
+
+    /**
+     * Sets the comment for the session cookie
+     *
+     * @param comment The session cookie comment
+     *
+     * @throws IllegalStateException if the associated ServletContext has
+     *         already been initialised
+     */
+    public void setComment(String comment);
+
+    public String getComment();
+
+    /**
+     * Sets the httpOnly flag for the session cookie.
+     *
+     * @param httpOnly The httpOnly setting to use for session cookies
+     *
+     * @throws IllegalStateException if the associated ServletContext has
+     *         already been initialised
+     */
+    public void setHttpOnly(boolean httpOnly);
+
+    public boolean isHttpOnly();
+
+    /**
+     * Sets the secure flag for the session cookie.
+     *
+     * @param secure The secure setting to use for session cookies
+     *
+     * @throws IllegalStateException if the associated ServletContext has
+     *         already been initialised
+     */
+    public void setSecure(boolean secure);
+
+    public boolean isSecure();
+
+    /**
+     * Sets the maximum age.
+     *
+     * @param MaxAge the maximum age to set
+     * @throws IllegalStateException if the associated ServletContext has
+     *         already been initialised
+     */
+    public void setMaxAge(int MaxAge);
+
+    public int getMaxAge();
+
+}

java/javax/servlet/SessionTrackingMode.java

@@ -0,0 +1,26 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet;
+
+/**
+ * @since Servlet 3.0
+ */
+public enum SessionTrackingMode {
+    COOKIE,
+    URL,
+    SSL
+}

java/javax/servlet/SingleThreadModel.java

@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+/**
+ * Ensures that servlets handle only one request at a time. This interface has
+ * no methods.
+ * <p>
+ * If a servlet implements this interface, you are <i>guaranteed</i> that no two
+ * threads will execute concurrently in the servlet's <code>service</code>
+ * method. The servlet container can make this guarantee by synchronizing access
+ * to a single instance of the servlet, or by maintaining a pool of servlet
+ * instances and dispatching each new request to a free servlet.
+ * <p>
+ * Note that SingleThreadModel does not solve all thread safety issues. For
+ * example, session attributes and static variables can still be accessed by
+ * multiple requests on multiple threads at the same time, even when
+ * SingleThreadModel servlets are used. It is recommended that a developer take
+ * other means to resolve those issues instead of implementing this interface,
+ * such as avoiding the usage of an instance variable or synchronizing the block
+ * of the code accessing those resources. This interface is deprecated in
+ * Servlet API version 2.4.
+ *
+ * @deprecated As of Java Servlet API 2.4, with no direct replacement.
+ */
+@SuppressWarnings("dep-ann")
+// Spec API does not use @Deprecated
+public interface SingleThreadModel {
+    // No methods
+}

java/javax/servlet/UnavailableException.java

@@ -0,0 +1,178 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet;
+
+/**
+ * Defines an exception that a servlet or filter throws to indicate that it is
+ * permanently or temporarily unavailable.
+ * <p>
+ * When a servlet or filter is permanently unavailable, something is wrong with
+ * it, and it cannot handle requests until some action is taken. For example, a
+ * servlet might be configured incorrectly, or a filter's state may be
+ * corrupted. The component should log both the error and the corrective action
+ * that is needed.
+ * <p>
+ * A servlet or filter is temporarily unavailable if it cannot handle requests
+ * momentarily due to some system-wide problem. For example, a third-tier server
+ * might not be accessible, or there may be insufficient memory or disk storage
+ * to handle requests. A system administrator may need to take corrective
+ * action.
+ * <p>
+ * Servlet containers can safely treat both types of unavailable exceptions in
+ * the same way. However, treating temporary unavailability effectively makes
+ * the servlet container more robust. Specifically, the servlet container might
+ * block requests to the servlet or filter for a period of time suggested by the
+ * exception, rather than rejecting them until the servlet container restarts.
+ */
+public class UnavailableException extends ServletException {
+
+    private static final long serialVersionUID = 1L;
+
+    private final Servlet servlet; // what's unavailable
+    private final boolean permanent; // needs admin action?
+    private final int seconds; // unavailability estimate
+
+    /**
+     * @param servlet
+     *            the <code>Servlet</code> instance that is unavailable
+     * @param msg
+     *            a <code>String</code> specifying the descriptive message
+     * @deprecated As of Java Servlet API 2.2, use
+     *             {@link #UnavailableException(String)} instead.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public UnavailableException(Servlet servlet, String msg) {
+        super(msg);
+        this.servlet = servlet;
+        permanent = true;
+        this.seconds = 0;
+    }
+
+    /**
+     * @param seconds
+     *            an integer specifying the number of seconds the servlet
+     *            expects to be unavailable; if zero or negative, indicates that
+     *            the servlet can't make an estimate
+     * @param servlet
+     *            the <code>Servlet</code> that is unavailable
+     * @param msg
+     *            a <code>String</code> specifying the descriptive message,
+     *            which can be written to a log file or displayed for the user.
+     * @deprecated As of Java Servlet API 2.2, use
+     *             {@link #UnavailableException(String, int)} instead.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public UnavailableException(int seconds, Servlet servlet, String msg) {
+        super(msg);
+        this.servlet = servlet;
+        if (seconds <= 0)
+            this.seconds = -1;
+        else
+            this.seconds = seconds;
+        permanent = false;
+    }
+
+    /**
+     * Constructs a new exception with a descriptive message indicating that the
+     * servlet is permanently unavailable.
+     *
+     * @param msg
+     *            a <code>String</code> specifying the descriptive message
+     */
+    public UnavailableException(String msg) {
+        super(msg);
+        seconds = 0;
+        servlet = null;
+        permanent = true;
+    }
+
+    /**
+     * Constructs a new exception with a descriptive message indicating that the
+     * servlet is temporarily unavailable and giving an estimate of how long it
+     * will be unavailable.
+     * <p>
+     * In some cases, the servlet cannot make an estimate. For example, the
+     * servlet might know that a server it needs is not running, but not be able
+     * to report how long it will take to be restored to functionality. This can
+     * be indicated with a negative or zero value for the <code>seconds</code>
+     * argument.
+     *
+     * @param msg
+     *            a <code>String</code> specifying the descriptive message,
+     *            which can be written to a log file or displayed for the user.
+     * @param seconds
+     *            an integer specifying the number of seconds the servlet
+     *            expects to be unavailable; if zero or negative, indicates that
+     *            the servlet can't make an estimate
+     */
+    public UnavailableException(String msg, int seconds) {
+        super(msg);
+
+        if (seconds <= 0)
+            this.seconds = -1;
+        else
+            this.seconds = seconds;
+        servlet = null;
+        permanent = false;
+    }
+
+    /**
+     * Returns a <code>boolean</code> indicating whether the servlet is
+     * permanently unavailable. If so, something is wrong with the servlet, and
+     * the system administrator must take some corrective action.
+     *
+     * @return <code>true</code> if the servlet is permanently unavailable;
+     *         <code>false</code> if the servlet is available or temporarily
+     *         unavailable
+     */
+    public boolean isPermanent() {
+        return permanent;
+    }
+
+    /**
+     * Returns the servlet that is reporting its unavailability.
+     *
+     * @return the <code>Servlet</code> object that is throwing the
+     *         <code>UnavailableException</code>
+     * @deprecated As of Java Servlet API 2.2, with no replacement.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public Servlet getServlet() {
+        return servlet;
+    }
+
+    /**
+     * Returns the number of seconds the servlet expects to be temporarily
+     * unavailable.
+     * <p>
+     * If this method returns a negative number, the servlet is permanently
+     * unavailable or cannot provide an estimate of how long it will be
+     * unavailable. No effort is made to correct for the time elapsed since the
+     * exception was first reported.
+     *
+     * @return an integer specifying the number of seconds the servlet will be
+     *         temporarily unavailable, or a negative number if the servlet is
+     *         permanently unavailable or cannot make an estimate
+     */
+    public int getUnavailableSeconds() {
+        return permanent ? -1 : seconds;
+    }
+}

java/javax/servlet/WriteListener.java

@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet;
+
+import java.io.IOException;
+
+/**
+ * Receives notification of write events when using non-blocking IO.
+ *
+ * @since Servlet 3.1
+ */
+public interface WriteListener extends java.util.EventListener{
+
+    /**
+     * Invoked when it it possible to write data without blocking. The container
+     * will invoke this method the first time for a request as soon as data can
+     * be written. Subsequent invocations will only occur if a call to
+     * {@link ServletOutputStream#isReady()} has returned false and it has since
+     * become possible to write data.
+     *
+     * @throws IOException if an I/O error occurs while processing this event
+     */
+    public void onWritePossible() throws IOException;
+
+    /**
+     * Invoked if an error occurs while writing the response.
+     *
+     * @param throwable The throwable that represents the error that occurred
+     */
+    public void onError(java.lang.Throwable throwable);
+}

java/javax/servlet/annotation/HandlesTypes.java

@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to declare an array of application classes which are
+ * passed to a {@link javax.servlet.ServletContainerInitializer}.
+ *
+ * @since Servlet 3.0
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface HandlesTypes {
+
+    /**
+     * @return array of classes
+     */
+    Class<?>[] value();
+
+}

java/javax/servlet/annotation/HttpConstraint.java

@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.servlet.annotation.ServletSecurity.EmptyRoleSemantic;
+import javax.servlet.annotation.ServletSecurity.TransportGuarantee;
+
+/**
+ * This annotation represents the security constraints that are applied to all
+ * requests with HTTP protocol method types that are not otherwise represented
+ * by a corresponding {@link javax.servlet.annotation.HttpMethodConstraint} in a
+ * {@link javax.servlet.annotation.ServletSecurity} annotation.
+ *
+ * @since Servlet 3.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface HttpConstraint {
+
+    /**
+     * The EmptyRoleSemantic determines the behaviour when the rolesAllowed list
+     * is empty.
+     *
+     * @return empty role semantic
+     */
+    EmptyRoleSemantic value() default EmptyRoleSemantic.PERMIT;
+
+    /**
+     * Determines whether SSL/TLS is required to process the current request.
+     *
+     * @return transport guarantee
+     */
+    TransportGuarantee transportGuarantee() default TransportGuarantee.NONE;
+
+    /**
+     * The authorized roles' names. The container may discard duplicate role
+     * names during processing of the annotation. N.B. The String "*" does not
+     * have a special meaning if it occurs as a role name.
+     *
+     * @return array of names. The array may be of zero length, in which case
+     *         the EmptyRoleSemantic applies; the returned value determines
+     *         whether access is to be permitted or denied regardless of the
+     *         identity and authentication state in either case, PERMIT or DENY.<br>
+     *         Otherwise, when the array contains one or more role names access
+     *         is permitted if the user a member of at least one of the named
+     *         roles. The EmptyRoleSemantic is not applied in this case.
+     *
+     */
+    String[] rolesAllowed() default {};
+
+}

java/javax/servlet/annotation/HttpMethodConstraint.java

@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.servlet.annotation.ServletSecurity.EmptyRoleSemantic;
+import javax.servlet.annotation.ServletSecurity.TransportGuarantee;
+
+/**
+ * Specific security constraints can be applied to different types of request,
+ * differentiated by the HTTP protocol method type by using this annotation
+ * inside the {@link javax.servlet.annotation.ServletSecurity} annotation.
+ *
+ * @since Servlet 3.0
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface HttpMethodConstraint {
+
+    /**
+     * HTTP Protocol method name (e.g. POST, PUT)
+     *
+     * @return method name
+     */
+    String value();
+
+    /**
+     * The EmptyRoleSemantic determines the behaviour when the rolesAllowed list
+     * is empty.
+     *
+     * @return empty role semantic
+     */
+    EmptyRoleSemantic emptyRoleSemantic() default EmptyRoleSemantic.PERMIT;
+
+    /**
+     * Determines whether SSL/TLS is required to process the current request.
+     *
+     * @return transport guarantee
+     */
+    TransportGuarantee transportGuarantee() default TransportGuarantee.NONE;
+
+    /**
+     * The authorized roles' names. The container may discard duplicate role
+     * names during processing of the annotation. N.B. The String "*" does not
+     * have a special meaning if it occurs as a role name.
+     *
+     * @return array of names. The array may be of zero length, in which case
+     *         the EmptyRoleSemantic applies; the returned value determines
+     *         whether access is to be permitted or denied regardless of the
+     *         identity and authentication state in either case, PERMIT or DENY.<br>
+     *         Otherwise, when the array contains one or more role names access
+     *         is permitted if the user a member of at least one of the named
+     *         roles. The EmptyRoleSemantic is not applied in this case.
+     */
+    String[] rolesAllowed() default {};
+}

java/javax/servlet/annotation/MultipartConfig.java

@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to indicate that the {@link javax.servlet.Servlet} on
+ * which it is declared expects requests to made using the {@code
+ * multipart/form-data} MIME type. <br>
+ * <br>
+ *
+ * {@link javax.servlet.http.Part} components of a given {@code
+ * multipart/form-data} request are retrieved by a Servlet annotated with
+ * {@code MultipartConfig} by calling
+ * {@link javax.servlet.http.HttpServletRequest#getPart} or
+ * {@link javax.servlet.http.HttpServletRequest#getParts}.<br>
+ * <br>
+ *
+ * E.g. <code>@WebServlet("/upload")}</code><br>
+ *
+ * <code>@MultipartConfig()</code> <code>public class UploadServlet extends
+ * HttpServlet ... } </code><br>
+ *
+ * @since Servlet 3.0
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MultipartConfig {
+
+    /**
+     * @return location in which the Container stores temporary files
+     */
+    String location() default "";
+
+    /**
+     * @return the maximum size allowed for uploaded files (in bytes)
+     */
+    long maxFileSize() default -1L;
+
+    /**
+     * @return the maximum size of the request allowed for {@code
+     *         multipart/form-data}
+     */
+    long maxRequestSize() default -1L;
+
+    /**
+     * @return the size threshold at which the file will be written to the disk
+     */
+    int fileSizeThreshold() default 0;
+}

java/javax/servlet/annotation/ServletSecurity.java

@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Declare this annotation on a {@link javax.servlet.Servlet} implementation
+ * class to enforce security constraints on HTTP protocol requests.<br>
+ * The container applies constraints to the URL patterns mapped to each Servlet
+ * which declares this annotation.<br>
+ * <br>
+ *
+ * @since Servlet 3.0
+ */
+@Inherited
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface ServletSecurity {
+
+    /**
+     * Represents the two possible values of the empty role semantic, active
+     * when a list of role names is empty.
+     */
+    enum EmptyRoleSemantic {
+
+        /**
+         * Access MUST be permitted, regardless of authentication state or
+         * identity
+         */
+        PERMIT,
+
+        /**
+         * Access MUST be denied, regardless of authentication state or identity
+         */
+        DENY
+    }
+
+    /**
+     * Represents the two possible values of data transport, encrypted or not.
+     */
+    enum TransportGuarantee {
+
+        /**
+         * User data must not be encrypted by the container during transport
+         */
+        NONE,
+
+        /**
+         * The container MUST encrypt user data during transport
+         */
+        CONFIDENTIAL
+    }
+
+    /**
+     * The default constraint to apply to requests not handled by specific
+     * method constraints
+     *
+     * @return http constraint
+     */
+    HttpConstraint value() default @HttpConstraint;
+
+    /**
+     * An array of HttpMethodConstraint objects to which the security constraint
+     * will be applied
+     *
+     * @return array of http method constraint
+     */
+    HttpMethodConstraint[] httpMethodConstraints() default {};
+}

java/javax/servlet/annotation/WebFilter.java

@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.servlet.DispatcherType;
+
+/**
+ * The annotation used to declare a Servlet {@link javax.servlet.Filter}. <br>
+ * <br>
+ *
+ * This annotation will be processed by the container during deployment, the
+ * Filter class in which it is found will be created as per the configuration
+ * and applied to the URL patterns, {@link javax.servlet.Servlet}s and
+ * {@link javax.servlet.DispatcherType}s.<br>
+ * <br>
+ *
+ * If the name attribute is not defined, the fully qualified name of the class
+ * is used.<br>
+ * <br>
+ *
+ * At least one URL pattern MUST be declared in either the {@code value} or
+ * {@code urlPattern} attribute of the annotation, but not both.<br>
+ * <br>
+ *
+ * The {@code value} attribute is recommended for use when the URL pattern is
+ * the only attribute being set, otherwise the {@code urlPattern} attribute
+ * should be used.<br>
+ * <br>
+ *
+ * The annotated class MUST implement {@link javax.servlet.Filter}.
+ *
+ * E.g.
+ *
+ * <code>@WebFilter("/path/*")</code><br>
+ * <code>public class AnExampleFilter implements Filter { ... </code><br>
+ *
+ * @since Servlet 3.0 (Section 8.1.2)
+ *
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface WebFilter {
+
+    /**
+     * @return description of the Filter, if present
+     */
+    String description() default "";
+
+    /**
+     * @return display name of the Filter, if present
+     */
+    String displayName() default "";
+
+    /**
+     * @return array of initialization params for this Filter
+     */
+    WebInitParam[] initParams() default {};
+
+    /**
+     * @return name of the Filter, if present
+     */
+    String filterName() default "";
+
+    /**
+     * @return small icon for this Filter, if present
+     */
+    String smallIcon() default "";
+
+    /**
+     * @return the large icon for this Filter, if present
+     */
+    String largeIcon() default "";
+
+    /**
+     * @return array of Servlet names to which this Filter applies
+     */
+    String[] servletNames() default {};
+
+    /**
+     * A convenience method, to allow extremely simple annotation of a class.
+     *
+     * @return array of URL patterns
+     * @see #urlPatterns()
+     */
+    String[] value() default {};
+
+    /**
+     * @return array of URL patterns to which this Filter applies
+     */
+    String[] urlPatterns() default {};
+
+    /**
+     * @return array of DispatcherTypes to which this filter applies
+     */
+    DispatcherType[] dispatcherTypes() default {DispatcherType.REQUEST};
+
+    /**
+     * @return asynchronous operation supported by this Filter
+     */
+    boolean asyncSupported() default false;
+}

java/javax/servlet/annotation/WebInitParam.java

@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * The annotation used to declare an initialization parameter on a
+ * {@link javax.servlet.Servlet} or {@link javax.servlet.Filter}, within a
+ * {@link javax.servlet.annotation.WebFilter} or
+ * {@link javax.servlet.annotation.WebServlet} annotation.<br>
+ * <br>
+ *
+ * E.g.
+ * <code>&amp;#064;WebServlet(name="TestServlet", urlPatterns={"/test"},initParams={&amp;#064;WebInitParam(name="test", value="true")})
+ * public class TestServlet extends HttpServlet { ... </code><br>
+ *
+ * @since Servlet 3.0
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface WebInitParam {
+
+    /**
+     * @return name of the initialization parameter
+     */
+    String name();
+
+    /**
+     * @return value of the initialization parameter
+     */
+    String value();
+
+    /**
+     * @return description of the initialization parameter
+     */
+    String description() default "";
+}

java/javax/servlet/annotation/WebListener.java

@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * The annotation used to declare a listener for various types of event, in a
+ * given web application context.<br>
+ * <br>
+ *
+ * The class annotated MUST implement one, (or more), of the following
+ * interfaces: {@link javax.servlet.http.HttpSessionAttributeListener},
+ * {@link javax.servlet.http.HttpSessionListener},
+ * {@link javax.servlet.ServletContextAttributeListener},
+ * {@link javax.servlet.ServletContextListener},
+ * {@link javax.servlet.ServletRequestAttributeListener},
+ * {@link javax.servlet.ServletRequestListener} or
+ * {@link javax.servlet.http.HttpSessionIdListener}
+ * <br>
+ *
+ * E.g. <code>@WebListener</code><br>
+ * <code>public TestListener implements ServletContextListener {</code><br>
+ *
+ * @since Servlet 3.0
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface WebListener {
+
+    /**
+     * @return description of the listener, if present
+     */
+    String value() default "";
+}

java/javax/servlet/annotation/WebServlet.java

@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to declare the configuration of a
+ * {@link javax.servlet.Servlet}. <br>
+ *
+ * If the name attribute is not defined, the fully qualified name of the class
+ * is used.<br>
+ * <br>
+ *
+ * At least one URL pattern MUST be declared in either the {@code value} or
+ * {@code urlPattern} attribute of the annotation, but not both.<br>
+ * <br>
+ *
+ * The {@code value} attribute is recommended for use when the URL pattern is
+ * the only attribute being set, otherwise the {@code urlPattern} attribute
+ * should be used.<br>
+ * <br>
+ *
+ * The class on which this annotation is declared MUST extend
+ * {@link javax.servlet.http.HttpServlet}. <br>
+ * <br>
+ *
+ * E.g. <code>@WebServlet("/path")}<br>
+ * public class TestServlet extends HttpServlet ... {</code><br>
+ *
+ * E.g.
+ * <code>@WebServlet(name="TestServlet", urlPatterns={"/path", "/alt"}) <br>
+ * public class TestServlet extends HttpServlet ... {</code><br>
+ *
+ * @since Servlet 3.0 (Section 8.1.1)
+ *
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface WebServlet {
+
+    /**
+     * @return name of the Servlet
+     */
+    String name() default "";
+
+    /**
+     * A convenience method, to allow extremely simple annotation of a class.
+     *
+     * @return array of URL patterns
+     * @see #urlPatterns()
+     */
+    String[] value() default {};
+
+    /**
+     * @return array of URL patterns to which this Filter applies
+     */
+    String[] urlPatterns() default {};
+
+    /**
+     * @return load on startup ordering hint
+     */
+    int loadOnStartup() default -1;
+
+    /**
+     * @return array of initialization params for this Servlet
+     */
+    WebInitParam[] initParams() default {};
+
+    /**
+     * @return asynchronous operation supported by this Servlet
+     */
+    boolean asyncSupported() default false;
+
+    /**
+     * @return small icon for this Servlet, if present
+     */
+    String smallIcon() default "";
+
+    /**
+     * @return large icon for this Servlet, if present
+     */
+    String largeIcon() default "";
+
+    /**
+     * @return description of this Servlet, if present
+     */
+    String description() default "";
+
+    /**
+     * @return display name of this Servlet, if present
+     */
+    String displayName() default "";
+}

java/javax/servlet/descriptor/JspConfigDescriptor.java

@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.descriptor;
+
+import java.util.Collection;
+
+/**
+ * @since Servlet 3.0
+ * TODO SERVLET3 - Add comments
+ */
+public interface JspConfigDescriptor {
+    public Collection<TaglibDescriptor> getTaglibs();
+    public Collection<JspPropertyGroupDescriptor> getJspPropertyGroups();
+}

java/javax/servlet/descriptor/JspPropertyGroupDescriptor.java

@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.descriptor;
+
+import java.util.Collection;
+
+/**
+ * @since Servlet 3.0
+ * TODO SERVLET3 - Add comments
+ */
+public interface JspPropertyGroupDescriptor {
+    public Collection<String> getUrlPatterns();
+    public String getElIgnored();
+    public String getPageEncoding();
+    public String getScriptingInvalid();
+    public String getIsXml();
+    public Collection<String> getIncludePreludes();
+    public Collection<String> getIncludeCodas();
+    public String getDeferredSyntaxAllowedAsLiteral();
+    public String getTrimDirectiveWhitespaces();
+    public String getDefaultContentType();
+    public String getBuffer();
+    public String getErrorOnUndeclaredNamespace();
+}

java/javax/servlet/descriptor/TaglibDescriptor.java

@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.descriptor;
+
+/**
+ * @since Servlet 3.0
+ * TODO SERVLET3 - Add comments
+ */
+public interface TaglibDescriptor {
+    public String getTaglibURI();
+    public String getTaglibLocation();
+}

java/javax/servlet/http/Cookie.java

@@ -0,0 +1,453 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.io.Serializable;
+import java.text.MessageFormat;
+import java.util.BitSet;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+/**
+ * Creates a cookie, a small amount of information sent by a servlet to a Web
+ * browser, saved by the browser, and later sent back to the server. A cookie's
+ * value can uniquely identify a client, so cookies are commonly used for
+ * session management.
+ * <p>
+ * A cookie has a name, a single value, and optional attributes such as a
+ * comment, path and domain qualifiers, a maximum age, and a version number.
+ * Some Web browsers have bugs in how they handle the optional attributes, so
+ * use them sparingly to improve the interoperability of your servlets.
+ * <p>
+ * The servlet sends cookies to the browser by using the
+ * {@link HttpServletResponse#addCookie} method, which adds fields to HTTP
+ * response headers to send cookies to the browser, one at a time. The browser
+ * is expected to support 20 cookies for each Web server, 300 cookies total, and
+ * may limit cookie size to 4 KB each.
+ * <p>
+ * The browser returns cookies to the servlet by adding fields to HTTP request
+ * headers. Cookies can be retrieved from a request by using the
+ * {@link HttpServletRequest#getCookies} method. Several cookies might have the
+ * same name but different path attributes.
+ * <p>
+ * Cookies affect the caching of the Web pages that use them. HTTP 1.0 does not
+ * cache pages that use cookies created with this class. This class does not
+ * support the cache control defined with HTTP 1.1.
+ * <p>
+ * This class supports both the RFC 2109 and the RFC 6265 specifications.
+ * By default, cookies are created using RFC 6265.
+ */
+public class Cookie implements Cloneable, Serializable {
+
+    private static final CookieNameValidator validation;
+    static {
+        boolean strictNaming;
+        String prop = System.getProperty("org.apache.tomcat.util.http.ServerCookie.STRICT_NAMING");
+        if (prop != null) {
+            strictNaming = Boolean.parseBoolean(prop);
+        } else {
+            strictNaming = Boolean.getBoolean("org.apache.catalina.STRICT_SERVLET_COMPLIANCE");
+        }
+
+        if (strictNaming) {
+            validation = new RFC2109Validator();
+        }
+        else {
+            validation = new RFC6265Validator();
+        }
+    }
+
+    private static final long serialVersionUID = 1L;
+
+    private final String name;
+    private String value;
+
+    private int version = 0; // ;Version=1 ... means RFC 2109 style
+
+    //
+    // Attributes encoded in the header's cookie fields.
+    //
+    private String comment; // ;Comment=VALUE ... describes cookie's use
+    private String domain; // ;Domain=VALUE ... domain that sees cookie
+    private int maxAge = -1; // ;Max-Age=VALUE ... cookies auto-expire
+    private String path; // ;Path=VALUE ... URLs that see the cookie
+    private boolean secure; // ;Secure ... e.g. use SSL
+    private boolean httpOnly; // Not in cookie specs, but supported by browsers
+
+    /**
+     * Constructs a cookie with a specified name and value.
+     * <p>
+     * The name must conform to RFC 2109. That means it can contain only ASCII
+     * alphanumeric characters and cannot contain commas, semicolons, or white
+     * space or begin with a $ character. The cookie's name cannot be changed
+     * after creation.
+     * <p>
+     * The value can be anything the server chooses to send. Its value is
+     * probably of interest only to the server. The cookie's value can be
+     * changed after creation with the <code>setValue</code> method.
+     * <p>
+     * By default, cookies are created according to the Netscape cookie
+     * specification. The version can be changed with the
+     * <code>setVersion</code> method.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the cookie
+     * @param value
+     *            a <code>String</code> specifying the value of the cookie
+     * @throws IllegalArgumentException
+     *             if the cookie name contains illegal characters (for example,
+     *             a comma, space, or semicolon) or it is one of the tokens
+     *             reserved for use by the cookie protocol
+     * @see #setValue
+     * @see #setVersion
+     */
+    public Cookie(String name, String value) {
+        validation.validate(name);
+        this.name = name;
+        this.value = value;
+    }
+
+    /**
+     * Specifies a comment that describes a cookie's purpose. The comment is
+     * useful if the browser presents the cookie to the user. Comments are not
+     * supported by Netscape Version 0 cookies.
+     *
+     * @param purpose
+     *            a <code>String</code> specifying the comment to display to the
+     *            user
+     * @see #getComment
+     */
+    public void setComment(String purpose) {
+        comment = purpose;
+    }
+
+    /**
+     * Returns the comment describing the purpose of this cookie, or
+     * <code>null</code> if the cookie has no comment.
+     *
+     * @return a <code>String</code> containing the comment, or
+     *         <code>null</code> if none
+     * @see #setComment
+     */
+    public String getComment() {
+        return comment;
+    }
+
+    /**
+     * Specifies the domain within which this cookie should be presented.
+     * <p>
+     * The form of the domain name is specified by RFC 2109. A domain name
+     * begins with a dot (<code>.foo.com</code>) and means that the cookie is
+     * visible to servers in a specified Domain Name System (DNS) zone (for
+     * example, <code>www.foo.com</code>, but not <code>a.b.foo.com</code>). By
+     * default, cookies are only returned to the server that sent them.
+     *
+     * @param pattern
+     *            a <code>String</code> containing the domain name within which
+     *            this cookie is visible; form is according to RFC 2109
+     * @see #getDomain
+     */
+    public void setDomain(String pattern) {
+        domain = pattern.toLowerCase(Locale.ENGLISH); // IE allegedly needs this
+    }
+
+    /**
+     * Returns the domain name set for this cookie. The form of the domain name
+     * is set by RFC 2109.
+     *
+     * @return a <code>String</code> containing the domain name
+     * @see #setDomain
+     */
+    public String getDomain() {
+        return domain;
+    }
+
+    /**
+     * Sets the maximum age of the cookie in seconds.
+     * <p>
+     * A positive value indicates that the cookie will expire after that many
+     * seconds have passed. Note that the value is the <i>maximum</i> age when
+     * the cookie will expire, not the cookie's current age.
+     * <p>
+     * A negative value means that the cookie is not stored persistently and
+     * will be deleted when the Web browser exits. A zero value causes the
+     * cookie to be deleted.
+     *
+     * @param expiry
+     *            an integer specifying the maximum age of the cookie in
+     *            seconds; if negative, means the cookie is not stored; if zero,
+     *            deletes the cookie
+     * @see #getMaxAge
+     */
+    public void setMaxAge(int expiry) {
+        maxAge = expiry;
+    }
+
+    /**
+     * Returns the maximum age of the cookie, specified in seconds, By default,
+     * <code>-1</code> indicating the cookie will persist until browser
+     * shutdown.
+     *
+     * @return an integer specifying the maximum age of the cookie in seconds; if
+     *         negative, means the cookie persists until browser shutdown
+     * @see #setMaxAge
+     */
+    public int getMaxAge() {
+        return maxAge;
+    }
+
+    /**
+     * Specifies a path for the cookie to which the client should return the
+     * cookie.
+     * <p>
+     * The cookie is visible to all the pages in the directory you specify, and
+     * all the pages in that directory's subdirectories. A cookie's path must
+     * include the servlet that set the cookie, for example, <i>/catalog</i>,
+     * which makes the cookie visible to all directories on the server under
+     * <i>/catalog</i>.
+     * <p>
+     * Consult RFC 2109 (available on the Internet) for more information on
+     * setting path names for cookies.
+     *
+     * @param uri
+     *            a <code>String</code> specifying a path
+     * @see #getPath
+     */
+    public void setPath(String uri) {
+        path = uri;
+    }
+
+    /**
+     * Returns the path on the server to which the browser returns this cookie.
+     * The cookie is visible to all subpaths on the server.
+     *
+     * @return a <code>String</code> specifying a path that contains a servlet
+     *         name, for example, <i>/catalog</i>
+     * @see #setPath
+     */
+    public String getPath() {
+        return path;
+    }
+
+    /**
+     * Indicates to the browser whether the cookie should only be sent using a
+     * secure protocol, such as HTTPS or SSL.
+     * <p>
+     * The default value is <code>false</code>.
+     *
+     * @param flag
+     *            if <code>true</code>, sends the cookie from the browser to the
+     *            server only when using a secure protocol; if
+     *            <code>false</code>, sent on any protocol
+     * @see #getSecure
+     */
+    public void setSecure(boolean flag) {
+        secure = flag;
+    }
+
+    /**
+     * Returns <code>true</code> if the browser is sending cookies only over a
+     * secure protocol, or <code>false</code> if the browser can send cookies
+     * using any protocol.
+     *
+     * @return <code>true</code> if the browser uses a secure protocol;
+     *         otherwise, <code>true</code>
+     * @see #setSecure
+     */
+    public boolean getSecure() {
+        return secure;
+    }
+
+    /**
+     * Returns the name of the cookie. The name cannot be changed after
+     * creation.
+     *
+     * @return a <code>String</code> specifying the cookie's name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Assigns a new value to a cookie after the cookie is created. If you use a
+     * binary value, you may want to use BASE64 encoding.
+     * <p>
+     * With Version 0 cookies, values should not contain white space, brackets,
+     * parentheses, equals signs, commas, double quotes, slashes, question
+     * marks, at signs, colons, and semicolons. Empty values may not behave the
+     * same way on all browsers.
+     *
+     * @param newValue
+     *            a <code>String</code> specifying the new value
+     * @see #getValue
+     * @see Cookie
+     */
+    public void setValue(String newValue) {
+        value = newValue;
+    }
+
+    /**
+     * Returns the value of the cookie.
+     *
+     * @return a <code>String</code> containing the cookie's present value
+     * @see #setValue
+     * @see Cookie
+     */
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * Returns the version of the protocol this cookie complies with. Version 1
+     * complies with RFC 2109, and version 0 complies with the original cookie
+     * specification drafted by Netscape. Cookies provided by a browser use and
+     * identify the browser's cookie version.
+     *
+     * @return 0 if the cookie complies with the original Netscape specification;
+     *         1 if the cookie complies with RFC 2109
+     * @see #setVersion
+     */
+    public int getVersion() {
+        return version;
+    }
+
+    /**
+     * Sets the version of the cookie protocol this cookie complies with.
+     * Version 0 complies with the original Netscape cookie specification.
+     * Version 1 complies with RFC 2109.
+     * <p>
+     * Since RFC 2109 is still somewhat new, consider version 1 as experimental;
+     * do not use it yet on production sites.
+     *
+     * @param v
+     *            0 if the cookie should comply with the original Netscape
+     *            specification; 1 if the cookie should comply with RFC 2109
+     * @see #getVersion
+     */
+    public void setVersion(int v) {
+        version = v;
+    }
+
+    /**
+     * Overrides the standard <code>java.lang.Object.clone</code> method to
+     * return a copy of this cookie.
+     */
+    @Override
+    public Object clone() {
+        try {
+            return super.clone();
+        } catch (CloneNotSupportedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Sets the flag that controls if this cookie will be hidden from scripts on
+     * the client side.
+     *
+     * @param httpOnly  The new value of the flag
+     *
+     * @since Servlet 3.0
+     */
+    public void setHttpOnly(boolean httpOnly) {
+        this.httpOnly = httpOnly;
+    }
+
+    /**
+     * Gets the flag that controls if this cookie will be hidden from scripts on
+     * the client side.
+     *
+     * @return  <code>true</code> if the cookie is hidden from scripts, else
+     *          <code>false</code>
+     * @since Servlet 3.0
+     */
+    public boolean isHttpOnly() {
+        return httpOnly;
+    }
+}
+
+
+class CookieNameValidator {
+    private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
+    protected static final ResourceBundle lStrings = ResourceBundle.getBundle(LSTRING_FILE);
+
+    protected final BitSet allowed;
+
+    protected CookieNameValidator(String separators) {
+        allowed = new BitSet(128);
+        allowed.set(0x20, 0x7f); // any CHAR except CTLs or separators
+        for (int i = 0; i < separators.length(); i++) {
+            char ch = separators.charAt(i);
+            allowed.clear(ch);
+        }
+    }
+
+    void validate(String name) {
+        if (name == null || name.length() == 0) {
+            throw new IllegalArgumentException(lStrings.getString("err.cookie_name_blank"));
+        }
+        if (!isToken(name)) {
+            String errMsg = lStrings.getString("err.cookie_name_is_token");
+            throw new IllegalArgumentException(MessageFormat.format(errMsg, name));
+        }
+    }
+
+    private boolean isToken(String possibleToken) {
+        int len = possibleToken.length();
+
+        for (int i = 0; i < len; i++) {
+            char c = possibleToken.charAt(i);
+            if (!allowed.get(c)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+class RFC6265Validator extends CookieNameValidator {
+    private static final String RFC2616_SEPARATORS = "()<>@,;:\\\"/[]?={} \t";
+
+    RFC6265Validator() {
+        super(RFC2616_SEPARATORS);
+    }
+}
+
+class RFC2109Validator extends RFC6265Validator {
+    RFC2109Validator() {
+        // special treatment to allow for FWD_SLASH_IS_SEPARATOR property
+        boolean allowSlash;
+        String prop = System.getProperty("org.apache.tomcat.util.http.ServerCookie.FWD_SLASH_IS_SEPARATOR");
+        if (prop != null) {
+            allowSlash = !Boolean.parseBoolean(prop);
+        } else {
+            allowSlash = !Boolean.getBoolean("org.apache.catalina.STRICT_SERVLET_COMPLIANCE");
+        }
+        if (allowSlash) {
+            allowed.set('/');
+        }
+    }
+
+    @Override
+    void validate(String name) {
+        super.validate(name);
+        if (name.charAt(0) == '$') {
+            String errMsg = lStrings.getString("err.cookie_name_is_token");
+            throw new IllegalArgumentException(MessageFormat.format(errMsg, name));
+        }
+    }
+}

java/javax/servlet/http/HttpServlet.java

@@ -0,0 +1,908 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.text.MessageFormat;
+import java.util.Enumeration;
+import java.util.ResourceBundle;
+
+import javax.servlet.DispatcherType;
+import javax.servlet.GenericServlet;
+import javax.servlet.ServletException;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+
+/**
+ * Provides an abstract class to be subclassed to create
+ * an HTTP servlet suitable for a Web site. A subclass of
+ * <code>HttpServlet</code> must override at least
+ * one method, usually one of these:
+ *
+ * <ul>
+ * <li> <code>doGet</code>, if the servlet supports HTTP GET requests
+ * <li> <code>doPost</code>, for HTTP POST requests
+ * <li> <code>doPut</code>, for HTTP PUT requests
+ * <li> <code>doDelete</code>, for HTTP DELETE requests
+ * <li> <code>init</code> and <code>destroy</code>,
+ * to manage resources that are held for the life of the servlet
+ * <li> <code>getServletInfo</code>, which the servlet uses to
+ * provide information about itself
+ * </ul>
+ *
+ * <p>There's almost no reason to override the <code>service</code>
+ * method. <code>service</code> handles standard HTTP
+ * requests by dispatching them to the handler methods
+ * for each HTTP request type (the <code>do</code><i>Method</i>
+ * methods listed above).
+ *
+ * <p>Likewise, there's almost no reason to override the
+ * <code>doOptions</code> and <code>doTrace</code> methods.
+ *
+ * <p>Servlets typically run on multithreaded servers,
+ * so be aware that a servlet must handle concurrent
+ * requests and be careful to synchronize access to shared resources.
+ * Shared resources include in-memory data such as
+ * instance or class variables and external objects
+ * such as files, database connections, and network
+ * connections.
+ * See the
+ * <a href="http://java.sun.com/Series/Tutorial/java/threads/multithreaded.html">
+ * Java Tutorial on Multithreaded Programming</a> for more
+ * information on handling multiple threads in a Java program.
+ */
+public abstract class HttpServlet extends GenericServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final String METHOD_DELETE = "DELETE";
+    private static final String METHOD_HEAD = "HEAD";
+    private static final String METHOD_GET = "GET";
+    private static final String METHOD_OPTIONS = "OPTIONS";
+    private static final String METHOD_POST = "POST";
+    private static final String METHOD_PUT = "PUT";
+    private static final String METHOD_TRACE = "TRACE";
+
+    private static final String HEADER_IFMODSINCE = "If-Modified-Since";
+    private static final String HEADER_LASTMOD = "Last-Modified";
+
+    private static final String LSTRING_FILE =
+        "javax.servlet.http.LocalStrings";
+    private static final ResourceBundle lStrings =
+        ResourceBundle.getBundle(LSTRING_FILE);
+
+
+    /**
+     * Does nothing, because this is an abstract class.
+     */
+    public HttpServlet() {
+        // NOOP
+    }
+
+
+    /**
+     * Called by the server (via the <code>service</code> method) to
+     * allow a servlet to handle a GET request.
+     *
+     * <p>Overriding this method to support a GET request also
+     * automatically supports an HTTP HEAD request. A HEAD
+     * request is a GET request that returns no body in the
+     * response, only the request header fields.
+     *
+     * <p>When overriding this method, read the request data,
+     * write the response headers, get the response's writer or
+     * output stream object, and finally, write the response data.
+     * It's best to include content type and encoding. When using
+     * a <code>PrintWriter</code> object to return the response,
+     * set the content type before accessing the
+     * <code>PrintWriter</code> object.
+     *
+     * <p>The servlet container must write the headers before
+     * committing the response, because in HTTP the headers must be sent
+     * before the response body.
+     *
+     * <p>Where possible, set the Content-Length header (with the
+     * {@link javax.servlet.ServletResponse#setContentLength} method),
+     * to allow the servlet container to use a persistent connection
+     * to return its response to the client, improving performance.
+     * The content length is automatically set if the entire response fits
+     * inside the response buffer.
+     *
+     * <p>When using HTTP 1.1 chunked encoding (which means that the response
+     * has a Transfer-Encoding header), do not set the Content-Length header.
+     *
+     * <p>The GET method should be safe, that is, without
+     * any side effects for which users are held responsible.
+     * For example, most form queries have no side effects.
+     * If a client request is intended to change stored data,
+     * the request should use some other HTTP method.
+     *
+     * <p>The GET method should also be idempotent, meaning
+     * that it can be safely repeated. Sometimes making a
+     * method safe also makes it idempotent. For example,
+     * repeating queries is both safe and idempotent, but
+     * buying a product online or modifying data is neither
+     * safe nor idempotent.
+     *
+     * <p>If the request is incorrectly formatted, <code>doGet</code>
+     * returns an HTTP "Bad Request" message.
+     *
+     * @param req   an {@link HttpServletRequest} object that
+     *                  contains the request the client has made
+     *                  of the servlet
+     *
+     * @param resp  an {@link HttpServletResponse} object that
+     *                  contains the response the servlet sends
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error is
+     *                              detected when the servlet handles
+     *                              the GET request
+     *
+     * @exception ServletException  if the request for the GET
+     *                                  could not be handled
+     *
+     * @see javax.servlet.ServletResponse#setContentType
+     */
+    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException, IOException
+    {
+        String protocol = req.getProtocol();
+        String msg = lStrings.getString("http.method_get_not_supported");
+        if (protocol.endsWith("1.1")) {
+            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+        } else {
+            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+        }
+    }
+
+
+    /**
+     * Returns the time the <code>HttpServletRequest</code>
+     * object was last modified,
+     * in milliseconds since midnight January 1, 1970 GMT.
+     * If the time is unknown, this method returns a negative
+     * number (the default).
+     *
+     * <p>Servlets that support HTTP GET requests and can quickly determine
+     * their last modification time should override this method.
+     * This makes browser and proxy caches work more effectively,
+     * reducing the load on server and network resources.
+     *
+     * @param req   the <code>HttpServletRequest</code>
+     *                  object that is sent to the servlet
+     *
+     * @return  a <code>long</code> integer specifying
+     *              the time the <code>HttpServletRequest</code>
+     *              object was last modified, in milliseconds
+     *              since midnight, January 1, 1970 GMT, or
+     *              -1 if the time is not known
+     */
+    protected long getLastModified(HttpServletRequest req) {
+        return -1;
+    }
+
+
+    /**
+     * <p>Receives an HTTP HEAD request from the protected
+     * <code>service</code> method and handles the
+     * request.
+     * The client sends a HEAD request when it wants
+     * to see only the headers of a response, such as
+     * Content-Type or Content-Length. The HTTP HEAD
+     * method counts the output bytes in the response
+     * to set the Content-Length header accurately.
+     *
+     * <p>If you override this method, you can avoid computing
+     * the response body and just set the response headers
+     * directly to improve performance. Make sure that the
+     * <code>doHead</code> method you write is both safe
+     * and idempotent (that is, protects itself from being
+     * called multiple times for one HTTP HEAD request).
+     *
+     * <p>If the HTTP HEAD request is incorrectly formatted,
+     * <code>doHead</code> returns an HTTP "Bad Request"
+     * message.
+     *
+     * @param req   the request object that is passed to the servlet
+     *
+     * @param resp  the response object that the servlet
+     *                  uses to return the headers to the client
+     *
+     * @exception IOException   if an input or output error occurs
+     *
+     * @exception ServletException  if the request for the HEAD
+     *                                  could not be handled
+     */
+    protected void doHead(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException, IOException {
+
+        if (DispatcherType.INCLUDE.equals(req.getDispatcherType())) {
+            doGet(req, resp);
+        } else {
+            NoBodyResponse response = new NoBodyResponse(resp);
+            doGet(req, response);
+            response.setContentLength();
+        }
+    }
+
+
+    /**
+     * Called by the server (via the <code>service</code> method)
+     * to allow a servlet to handle a POST request.
+     *
+     * The HTTP POST method allows the client to send
+     * data of unlimited length to the Web server a single time
+     * and is useful when posting information such as
+     * credit card numbers.
+     *
+     * <p>When overriding this method, read the request data,
+     * write the response headers, get the response's writer or output
+     * stream object, and finally, write the response data. It's best
+     * to include content type and encoding. When using a
+     * <code>PrintWriter</code> object to return the response, set the
+     * content type before accessing the <code>PrintWriter</code> object.
+     *
+     * <p>The servlet container must write the headers before committing the
+     * response, because in HTTP the headers must be sent before the
+     * response body.
+     *
+     * <p>Where possible, set the Content-Length header (with the
+     * {@link javax.servlet.ServletResponse#setContentLength} method),
+     * to allow the servlet container to use a persistent connection
+     * to return its response to the client, improving performance.
+     * The content length is automatically set if the entire response fits
+     * inside the response buffer.
+     *
+     * <p>When using HTTP 1.1 chunked encoding (which means that the response
+     * has a Transfer-Encoding header), do not set the Content-Length header.
+     *
+     * <p>This method does not need to be either safe or idempotent.
+     * Operations requested through POST can have side effects for
+     * which the user can be held accountable, for example,
+     * updating stored data or buying items online.
+     *
+     * <p>If the HTTP POST request is incorrectly formatted,
+     * <code>doPost</code> returns an HTTP "Bad Request" message.
+     *
+     *
+     * @param req   an {@link HttpServletRequest} object that
+     *                  contains the request the client has made
+     *                  of the servlet
+     *
+     * @param resp  an {@link HttpServletResponse} object that
+     *                  contains the response the servlet sends
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error is
+     *                              detected when the servlet handles
+     *                              the request
+     *
+     * @exception ServletException  if the request for the POST
+     *                                  could not be handled
+     *
+     * @see javax.servlet.ServletOutputStream
+     * @see javax.servlet.ServletResponse#setContentType
+     */
+    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException, IOException {
+
+        String protocol = req.getProtocol();
+        String msg = lStrings.getString("http.method_post_not_supported");
+        if (protocol.endsWith("1.1")) {
+            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+        } else {
+            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+        }
+    }
+
+
+    /**
+     * Called by the server (via the <code>service</code> method)
+     * to allow a servlet to handle a PUT request.
+     *
+     * The PUT operation allows a client to
+     * place a file on the server and is similar to
+     * sending a file by FTP.
+     *
+     * <p>When overriding this method, leave intact
+     * any content headers sent with the request (including
+     * Content-Length, Content-Type, Content-Transfer-Encoding,
+     * Content-Encoding, Content-Base, Content-Language, Content-Location,
+     * Content-MD5, and Content-Range). If your method cannot
+     * handle a content header, it must issue an error message
+     * (HTTP 501 - Not Implemented) and discard the request.
+     * For more information on HTTP 1.1, see RFC 2616
+     * <a href="http://www.ietf.org/rfc/rfc2616.txt"></a>.
+     *
+     * <p>This method does not need to be either safe or idempotent.
+     * Operations that <code>doPut</code> performs can have side
+     * effects for which the user can be held accountable. When using
+     * this method, it may be useful to save a copy of the
+     * affected URL in temporary storage.
+     *
+     * <p>If the HTTP PUT request is incorrectly formatted,
+     * <code>doPut</code> returns an HTTP "Bad Request" message.
+     *
+     * @param req   the {@link HttpServletRequest} object that
+     *                  contains the request the client made of
+     *                  the servlet
+     *
+     * @param resp  the {@link HttpServletResponse} object that
+     *                  contains the response the servlet returns
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error occurs
+     *                              while the servlet is handling the
+     *                              PUT request
+     *
+     * @exception ServletException  if the request for the PUT
+     *                                  cannot be handled
+     */
+    protected void doPut(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException, IOException {
+
+        String protocol = req.getProtocol();
+        String msg = lStrings.getString("http.method_put_not_supported");
+        if (protocol.endsWith("1.1")) {
+            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+        } else {
+            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+        }
+    }
+
+
+    /**
+     * Called by the server (via the <code>service</code> method)
+     * to allow a servlet to handle a DELETE request.
+     *
+     * The DELETE operation allows a client to remove a document
+     * or Web page from the server.
+     *
+     * <p>This method does not need to be either safe
+     * or idempotent. Operations requested through
+     * DELETE can have side effects for which users
+     * can be held accountable. When using
+     * this method, it may be useful to save a copy of the
+     * affected URL in temporary storage.
+     *
+     * <p>If the HTTP DELETE request is incorrectly formatted,
+     * <code>doDelete</code> returns an HTTP "Bad Request"
+     * message.
+     *
+     * @param req   the {@link HttpServletRequest} object that
+     *                  contains the request the client made of
+     *                  the servlet
+     *
+     *
+     * @param resp  the {@link HttpServletResponse} object that
+     *                  contains the response the servlet returns
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error occurs
+     *                              while the servlet is handling the
+     *                              DELETE request
+     *
+     * @exception ServletException  if the request for the
+     *                                  DELETE cannot be handled
+     */
+    protected void doDelete(HttpServletRequest req,
+                            HttpServletResponse resp)
+        throws ServletException, IOException {
+
+        String protocol = req.getProtocol();
+        String msg = lStrings.getString("http.method_delete_not_supported");
+        if (protocol.endsWith("1.1")) {
+            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+        } else {
+            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+        }
+    }
+
+
+    private static Method[] getAllDeclaredMethods(Class<?> c) {
+
+        if (c.equals(javax.servlet.http.HttpServlet.class)) {
+            return null;
+        }
+
+        Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
+        Method[] thisMethods = c.getDeclaredMethods();
+
+        if ((parentMethods != null) && (parentMethods.length > 0)) {
+            Method[] allMethods =
+                new Method[parentMethods.length + thisMethods.length];
+            System.arraycopy(parentMethods, 0, allMethods, 0,
+                             parentMethods.length);
+            System.arraycopy(thisMethods, 0, allMethods, parentMethods.length,
+                             thisMethods.length);
+
+            thisMethods = allMethods;
+        }
+
+        return thisMethods;
+    }
+
+
+    /**
+     * Called by the server (via the <code>service</code> method)
+     * to allow a servlet to handle a OPTIONS request.
+     *
+     * The OPTIONS request determines which HTTP methods
+     * the server supports and
+     * returns an appropriate header. For example, if a servlet
+     * overrides <code>doGet</code>, this method returns the
+     * following header:
+     *
+     * <p><code>Allow: GET, HEAD, TRACE, OPTIONS</code>
+     *
+     * <p>There's no need to override this method unless the
+     * servlet implements new HTTP methods, beyond those
+     * implemented by HTTP 1.1.
+     *
+     * @param req   the {@link HttpServletRequest} object that
+     *                  contains the request the client made of
+     *                  the servlet
+     *
+     * @param resp  the {@link HttpServletResponse} object that
+     *                  contains the response the servlet returns
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error occurs
+     *                              while the servlet is handling the
+     *                              OPTIONS request
+     *
+     * @exception ServletException  if the request for the
+     *                                  OPTIONS cannot be handled
+     */
+    protected void doOptions(HttpServletRequest req,
+            HttpServletResponse resp)
+        throws ServletException, IOException {
+
+        Method[] methods = getAllDeclaredMethods(this.getClass());
+
+        boolean ALLOW_GET = false;
+        boolean ALLOW_HEAD = false;
+        boolean ALLOW_POST = false;
+        boolean ALLOW_PUT = false;
+        boolean ALLOW_DELETE = false;
+        boolean ALLOW_TRACE = true;
+        boolean ALLOW_OPTIONS = true;
+
+        // Tomcat specific hack to see if TRACE is allowed
+        Class<?> clazz = null;
+        try {
+            clazz = Class.forName("org.apache.catalina.connector.RequestFacade");
+            Method getAllowTrace = clazz.getMethod("getAllowTrace", (Class<?>[]) null);
+            ALLOW_TRACE = ((Boolean) getAllowTrace.invoke(req, (Object[]) null)).booleanValue();
+        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException |
+                IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            // Ignore. Not running on Tomcat. TRACE is always allowed.
+        }
+        // End of Tomcat specific hack
+
+        for (int i=0; i<methods.length; i++) {
+            Method m = methods[i];
+
+            if (m.getName().equals("doGet")) {
+                ALLOW_GET = true;
+                ALLOW_HEAD = true;
+            }
+            if (m.getName().equals("doPost"))
+                ALLOW_POST = true;
+            if (m.getName().equals("doPut"))
+                ALLOW_PUT = true;
+            if (m.getName().equals("doDelete"))
+                ALLOW_DELETE = true;
+        }
+
+        String allow = null;
+        if (ALLOW_GET)
+            allow=METHOD_GET;
+        if (ALLOW_HEAD)
+            if (allow==null) allow=METHOD_HEAD;
+            else allow += ", " + METHOD_HEAD;
+        if (ALLOW_POST)
+            if (allow==null) allow=METHOD_POST;
+            else allow += ", " + METHOD_POST;
+        if (ALLOW_PUT)
+            if (allow==null) allow=METHOD_PUT;
+            else allow += ", " + METHOD_PUT;
+        if (ALLOW_DELETE)
+            if (allow==null) allow=METHOD_DELETE;
+            else allow += ", " + METHOD_DELETE;
+        if (ALLOW_TRACE)
+            if (allow==null) allow=METHOD_TRACE;
+            else allow += ", " + METHOD_TRACE;
+        if (ALLOW_OPTIONS)
+            if (allow==null) allow=METHOD_OPTIONS;
+            else allow += ", " + METHOD_OPTIONS;
+
+        resp.setHeader("Allow", allow);
+    }
+
+
+    /**
+     * Called by the server (via the <code>service</code> method)
+     * to allow a servlet to handle a TRACE request.
+     *
+     * A TRACE returns the headers sent with the TRACE
+     * request to the client, so that they can be used in
+     * debugging. There's no need to override this method.
+     *
+     * @param req   the {@link HttpServletRequest} object that
+     *                  contains the request the client made of
+     *                  the servlet
+     *
+     * @param resp  the {@link HttpServletResponse} object that
+     *                  contains the response the servlet returns
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error occurs
+     *                              while the servlet is handling the
+     *                              TRACE request
+     *
+     * @exception ServletException  if the request for the
+     *                                  TRACE cannot be handled
+     */
+    protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException, IOException
+    {
+
+        int responseLength;
+
+        String CRLF = "\r\n";
+        StringBuilder buffer = new StringBuilder("TRACE ").append(req.getRequestURI())
+            .append(" ").append(req.getProtocol());
+
+        Enumeration<String> reqHeaderEnum = req.getHeaderNames();
+
+        while( reqHeaderEnum.hasMoreElements() ) {
+            String headerName = reqHeaderEnum.nextElement();
+            buffer.append(CRLF).append(headerName).append(": ")
+                .append(req.getHeader(headerName));
+        }
+
+        buffer.append(CRLF);
+
+        responseLength = buffer.length();
+
+        resp.setContentType("message/http");
+        resp.setContentLength(responseLength);
+        ServletOutputStream out = resp.getOutputStream();
+        out.print(buffer.toString());
+        out.close();
+    }
+
+
+    /**
+     * Receives standard HTTP requests from the public
+     * <code>service</code> method and dispatches
+     * them to the <code>do</code><i>Method</i> methods defined in
+     * this class. This method is an HTTP-specific version of the
+     * {@link javax.servlet.Servlet#service} method. There's no
+     * need to override this method.
+     *
+     * @param req   the {@link HttpServletRequest} object that
+     *                  contains the request the client made of
+     *                  the servlet
+     *
+     * @param resp  the {@link HttpServletResponse} object that
+     *                  contains the response the servlet returns
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error occurs
+     *                              while the servlet is handling the
+     *                              HTTP request
+     *
+     * @exception ServletException  if the HTTP request
+     *                                  cannot be handled
+     *
+     * @see javax.servlet.Servlet#service
+     */
+    protected void service(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException, IOException {
+
+        String method = req.getMethod();
+
+        if (method.equals(METHOD_GET)) {
+            long lastModified = getLastModified(req);
+            if (lastModified == -1) {
+                // servlet doesn't support if-modified-since, no reason
+                // to go through further expensive logic
+                doGet(req, resp);
+            } else {
+                long ifModifiedSince;
+                try {
+                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
+                } catch (IllegalArgumentException iae) {
+                    // Invalid date header - proceed as if none was set
+                    ifModifiedSince = -1;
+                }
+                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
+                    // If the servlet mod time is later, call doGet()
+                    // Round down to the nearest second for a proper compare
+                    // A ifModifiedSince of -1 will always be less
+                    maybeSetLastModified(resp, lastModified);
+                    doGet(req, resp);
+                } else {
+                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
+                }
+            }
+
+        } else if (method.equals(METHOD_HEAD)) {
+            long lastModified = getLastModified(req);
+            maybeSetLastModified(resp, lastModified);
+            doHead(req, resp);
+
+        } else if (method.equals(METHOD_POST)) {
+            doPost(req, resp);
+
+        } else if (method.equals(METHOD_PUT)) {
+            doPut(req, resp);
+
+        } else if (method.equals(METHOD_DELETE)) {
+            doDelete(req, resp);
+
+        } else if (method.equals(METHOD_OPTIONS)) {
+            doOptions(req,resp);
+
+        } else if (method.equals(METHOD_TRACE)) {
+            doTrace(req,resp);
+
+        } else {
+            //
+            // Note that this means NO servlet supports whatever
+            // method was requested, anywhere on this server.
+            //
+
+            String errMsg = lStrings.getString("http.method_not_implemented");
+            Object[] errArgs = new Object[1];
+            errArgs[0] = method;
+            errMsg = MessageFormat.format(errMsg, errArgs);
+
+            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
+        }
+    }
+
+
+    /*
+     * Sets the Last-Modified entity header field, if it has not
+     * already been set and if the value is meaningful.  Called before
+     * doGet, to ensure that headers are set before response data is
+     * written.  A subclass might have set this header already, so we
+     * check.
+     */
+    private void maybeSetLastModified(HttpServletResponse resp,
+                                      long lastModified) {
+        if (resp.containsHeader(HEADER_LASTMOD))
+            return;
+        if (lastModified >= 0)
+            resp.setDateHeader(HEADER_LASTMOD, lastModified);
+    }
+
+
+    /**
+     * Dispatches client requests to the protected
+     * <code>service</code> method. There's no need to
+     * override this method.
+     *
+     * @param req   the {@link HttpServletRequest} object that
+     *                  contains the request the client made of
+     *                  the servlet
+     *
+     * @param res   the {@link HttpServletResponse} object that
+     *                  contains the response the servlet returns
+     *                  to the client
+     *
+     * @exception IOException   if an input or output error occurs
+     *                              while the servlet is handling the
+     *                              HTTP request
+     *
+     * @exception ServletException  if the HTTP request cannot
+     *                                  be handled
+     *
+     * @see javax.servlet.Servlet#service
+     */
+    @Override
+    public void service(ServletRequest req, ServletResponse res)
+        throws ServletException, IOException {
+
+        HttpServletRequest  request;
+        HttpServletResponse response;
+
+        try {
+            request = (HttpServletRequest) req;
+            response = (HttpServletResponse) res;
+        } catch (ClassCastException e) {
+            throw new ServletException(lStrings.getString("http.non_http"));
+        }
+        service(request, response);
+    }
+}
+
+
+/*
+ * A response wrapper for use in (dumb) "HEAD" support.
+ * This just swallows that body, counting the bytes in order to set
+ * the content length appropriately.  All other methods delegate to the
+ * wrapped HTTP Servlet Response object.
+ */
+// file private
+class NoBodyResponse extends HttpServletResponseWrapper {
+    private final NoBodyOutputStream noBody;
+    private PrintWriter writer;
+    private boolean didSetContentLength;
+
+    // file private
+    NoBodyResponse(HttpServletResponse r) {
+        super(r);
+        noBody = new NoBodyOutputStream(this);
+    }
+
+    // file private
+    void setContentLength() {
+        if (!didSetContentLength) {
+            if (writer != null) {
+                writer.flush();
+            }
+            super.setContentLength(noBody.getContentLength());
+        }
+    }
+
+
+    // SERVLET RESPONSE interface methods
+
+    @Override
+    public void setContentLength(int len) {
+        super.setContentLength(len);
+        didSetContentLength = true;
+    }
+
+    @Override
+    public void setContentLengthLong(long len) {
+        super.setContentLengthLong(len);
+        didSetContentLength = true;
+    }
+
+    @Override
+    public void setHeader(String name, String value) {
+        super.setHeader(name, value);
+        checkHeader(name);
+    }
+
+    @Override
+    public void addHeader(String name, String value) {
+        super.addHeader(name, value);
+        checkHeader(name);
+    }
+
+    @Override
+    public void setIntHeader(String name, int value) {
+        super.setIntHeader(name, value);
+        checkHeader(name);
+    }
+
+    @Override
+    public void addIntHeader(String name, int value) {
+        super.addIntHeader(name, value);
+        checkHeader(name);
+    }
+
+    private void checkHeader(String name) {
+        if ("content-length".equalsIgnoreCase(name)) {
+            didSetContentLength = true;
+        }
+    }
+
+    @Override
+    public ServletOutputStream getOutputStream() throws IOException {
+        return noBody;
+    }
+
+    @Override
+    public PrintWriter getWriter() throws UnsupportedEncodingException {
+
+        if (writer == null) {
+            OutputStreamWriter w;
+
+            w = new OutputStreamWriter(noBody, getCharacterEncoding());
+            writer = new PrintWriter(w);
+        }
+        return writer;
+    }
+}
+
+
+/*
+ * Servlet output stream that gobbles up all its data.
+ */
+
+// file private
+class NoBodyOutputStream extends ServletOutputStream {
+
+    private static final String LSTRING_FILE =
+        "javax.servlet.http.LocalStrings";
+    private static final ResourceBundle lStrings =
+        ResourceBundle.getBundle(LSTRING_FILE);
+
+    private final HttpServletResponse response;
+    private boolean flushed = false;
+    private int contentLength = 0;
+
+    // file private
+    NoBodyOutputStream(HttpServletResponse response) {
+        this.response = response;
+    }
+
+    // file private
+    int getContentLength() {
+        return contentLength;
+    }
+
+    @Override
+    public void write(int b) throws IOException {
+        contentLength++;
+        checkCommit();
+    }
+
+    @Override
+    public void write(byte buf[], int offset, int len) throws IOException {
+        if (buf == null) {
+            throw new NullPointerException(
+                    lStrings.getString("err.io.nullArray"));
+        }
+
+        if (offset < 0 || len < 0 || offset+len > buf.length) {
+            String msg = lStrings.getString("err.io.indexOutOfBounds");
+            Object[] msgArgs = new Object[3];
+            msgArgs[0] = Integer.valueOf(offset);
+            msgArgs[1] = Integer.valueOf(len);
+            msgArgs[2] = Integer.valueOf(buf.length);
+            msg = MessageFormat.format(msg, msgArgs);
+            throw new IndexOutOfBoundsException(msg);
+        }
+
+        contentLength += len;
+        checkCommit();
+    }
+
+    @Override
+    public boolean isReady() {
+        // TODO SERVLET 3.1
+        return false;
+    }
+
+    @Override
+    public void setWriteListener(javax.servlet.WriteListener listener) {
+        // TODO SERVLET 3.1
+    }
+
+    private void checkCommit() throws IOException {
+        if (!flushed && contentLength > response.getBufferSize()) {
+            response.flushBuffer();
+            flushed = true;
+        }
+    }
+}

java/javax/servlet/http/HttpServletRequest.java

@@ -0,0 +1,537 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Enumeration;
+
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+
+/**
+ * Extends the {@link javax.servlet.ServletRequest} interface to provide request
+ * information for HTTP servlets.
+ * <p>
+ * The servlet container creates an <code>HttpServletRequest</code> object and
+ * passes it as an argument to the servlet's service methods
+ * (<code>doGet</code>, <code>doPost</code>, etc).
+ */
+public interface HttpServletRequest extends ServletRequest {
+
+    /**
+     * String identifier for Basic authentication. Value "BASIC"
+     */
+    public static final String BASIC_AUTH = "BASIC";
+    /**
+     * String identifier for Form authentication. Value "FORM"
+     */
+    public static final String FORM_AUTH = "FORM";
+    /**
+     * String identifier for Client Certificate authentication. Value
+     * "CLIENT_CERT"
+     */
+    public static final String CLIENT_CERT_AUTH = "CLIENT_CERT";
+    /**
+     * String identifier for Digest authentication. Value "DIGEST"
+     */
+    public static final String DIGEST_AUTH = "DIGEST";
+
+    /**
+     * Returns the name of the authentication scheme used to protect the
+     * servlet. All servlet containers support basic, form and client
+     * certificate authentication, and may additionally support digest
+     * authentication. If the servlet is not authenticated <code>null</code> is
+     * returned.
+     * <p>
+     * Same as the value of the CGI variable AUTH_TYPE.
+     *
+     * @return one of the static members BASIC_AUTH, FORM_AUTH, CLIENT_CERT_AUTH,
+     *         DIGEST_AUTH (suitable for == comparison) or the
+     *         container-specific string indicating the authentication scheme,
+     *         or <code>null</code> if the request was not authenticated.
+     */
+    public String getAuthType();
+
+    /**
+     * Returns an array containing all of the <code>Cookie</code> objects the
+     * client sent with this request. This method returns <code>null</code> if
+     * no cookies were sent.
+     *
+     * @return an array of all the <code>Cookies</code> included with this
+     *         request, or <code>null</code> if the request has no cookies
+     */
+    public Cookie[] getCookies();
+
+    /**
+     * Returns the value of the specified request header as a <code>long</code>
+     * value that represents a <code>Date</code> object. Use this method with
+     * headers that contain dates, such as <code>If-Modified-Since</code>.
+     * <p>
+     * The date is returned as the number of milliseconds since January 1, 1970
+     * GMT. The header name is case insensitive.
+     * <p>
+     * If the request did not have a header of the specified name, this method
+     * returns -1. If the header can't be converted to a date, the method throws
+     * an <code>IllegalArgumentException</code>.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of the header
+     * @return a <code>long</code> value representing the date specified in the
+     *         header expressed as the number of milliseconds since January 1,
+     *         1970 GMT, or -1 if the named header was not included with the
+     *         request
+     * @exception IllegalArgumentException
+     *                If the header value can't be converted to a date
+     */
+    public long getDateHeader(String name);
+
+    /**
+     * Returns the value of the specified request header as a
+     * <code>String</code>. If the request did not include a header of the
+     * specified name, this method returns <code>null</code>. If there are
+     * multiple headers with the same name, this method returns the first head
+     * in the request. The header name is case insensitive. You can use this
+     * method with any request header.
+     *
+     * @param name
+     *            a <code>String</code> specifying the header name
+     * @return a <code>String</code> containing the value of the requested
+     *         header, or <code>null</code> if the request does not have a
+     *         header of that name
+     */
+    public String getHeader(String name);
+
+    /**
+     * Returns all the values of the specified request header as an
+     * <code>Enumeration</code> of <code>String</code> objects.
+     * <p>
+     * Some headers, such as <code>Accept-Language</code> can be sent by clients
+     * as several headers each with a different value rather than sending the
+     * header as a comma separated list.
+     * <p>
+     * If the request did not include any headers of the specified name, this
+     * method returns an empty <code>Enumeration</code>. The header name is case
+     * insensitive. You can use this method with any request header.
+     *
+     * @param name
+     *            a <code>String</code> specifying the header name
+     * @return an <code>Enumeration</code> containing the values of the requested
+     *         header. If the request does not have any headers of that name
+     *         return an empty enumeration. If the container does not allow
+     *         access to header information, return null
+     */
+    public Enumeration<String> getHeaders(String name);
+
+    /**
+     * Returns an enumeration of all the header names this request contains. If
+     * the request has no headers, this method returns an empty enumeration.
+     * <p>
+     * Some servlet containers do not allow servlets to access headers using
+     * this method, in which case this method returns <code>null</code>
+     *
+     * @return an enumeration of all the header names sent with this request; if
+     *         the request has no headers, an empty enumeration; if the servlet
+     *         container does not allow servlets to use this method,
+     *         <code>null</code>
+     */
+    public Enumeration<String> getHeaderNames();
+
+    /**
+     * Returns the value of the specified request header as an <code>int</code>.
+     * If the request does not have a header of the specified name, this method
+     * returns -1. If the header cannot be converted to an integer, this method
+     * throws a <code>NumberFormatException</code>.
+     * <p>
+     * The header name is case insensitive.
+     *
+     * @param name
+     *            a <code>String</code> specifying the name of a request header
+     * @return an integer expressing the value of the request header or -1 if the
+     *         request doesn't have a header of this name
+     * @exception NumberFormatException
+     *                If the header value can't be converted to an
+     *                <code>int</code>
+     */
+    public int getIntHeader(String name);
+
+    /**
+     * Returns the name of the HTTP method with which this request was made, for
+     * example, GET, POST, or PUT. Same as the value of the CGI variable
+     * REQUEST_METHOD.
+     *
+     * @return a <code>String</code> specifying the name of the method with
+     *         which this request was made
+     */
+    public String getMethod();
+
+    /**
+     * Returns any extra path information associated with the URL the client
+     * sent when it made this request. The extra path information follows the
+     * servlet path but precedes the query string and will start with a "/"
+     * character.
+     * <p>
+     * This method returns <code>null</code> if there was no extra path
+     * information.
+     * <p>
+     * Same as the value of the CGI variable PATH_INFO.
+     *
+     * @return a <code>String</code>, decoded by the web container, specifying
+     *         extra path information that comes after the servlet path but
+     *         before the query string in the request URL; or <code>null</code>
+     *         if the URL does not have any extra path information
+     */
+    public String getPathInfo();
+
+    /**
+     * Returns any extra path information after the servlet name but before the
+     * query string, and translates it to a real path. Same as the value of the
+     * CGI variable PATH_TRANSLATED.
+     * <p>
+     * If the URL does not have any extra path information, this method returns
+     * <code>null</code> or the servlet container cannot translate the virtual
+     * path to a real path for any reason (such as when the web application is
+     * executed from an archive). The web container does not decode this string.
+     *
+     * @return a <code>String</code> specifying the real path, or
+     *         <code>null</code> if the URL does not have any extra path
+     *         information
+     */
+    public String getPathTranslated();
+
+    /**
+     * Returns the portion of the request URI that indicates the context of the
+     * request. The context path always comes first in a request URI. The path
+     * starts with a "/" character but does not end with a "/" character. For
+     * servlets in the default (root) context, this method returns "". The
+     * container does not decode this string.
+     *
+     * @return a <code>String</code> specifying the portion of the request URI
+     *         that indicates the context of the request
+     */
+    public String getContextPath();
+
+    /**
+     * Returns the query string that is contained in the request URL after the
+     * path. This method returns <code>null</code> if the URL does not have a
+     * query string. Same as the value of the CGI variable QUERY_STRING.
+     *
+     * @return a <code>String</code> containing the query string or
+     *         <code>null</code> if the URL contains no query string. The value
+     *         is not decoded by the container.
+     */
+    public String getQueryString();
+
+    /**
+     * Returns the login of the user making this request, if the user has been
+     * authenticated, or <code>null</code> if the user has not been
+     * authenticated. Whether the user name is sent with each subsequent request
+     * depends on the browser and type of authentication. Same as the value of
+     * the CGI variable REMOTE_USER.
+     *
+     * @return a <code>String</code> specifying the login of the user making
+     *         this request, or <code>null</code> if the user login is not known
+     */
+    public String getRemoteUser();
+
+    /**
+     * Returns a boolean indicating whether the authenticated user is included
+     * in the specified logical "role". Roles and role membership can be defined
+     * using deployment descriptors. If the user has not been authenticated, the
+     * method returns <code>false</code>.
+     *
+     * @param role
+     *            a <code>String</code> specifying the name of the role
+     * @return a <code>boolean</code> indicating whether the user making this
+     *         request belongs to a given role; <code>false</code> if the user
+     *         has not been authenticated
+     */
+    public boolean isUserInRole(String role);
+
+    /**
+     * Returns a <code>java.security.Principal</code> object containing the name
+     * of the current authenticated user. If the user has not been
+     * authenticated, the method returns <code>null</code>.
+     *
+     * @return a <code>java.security.Principal</code> containing the name of the
+     *         user making this request; <code>null</code> if the user has not
+     *         been authenticated
+     */
+    public java.security.Principal getUserPrincipal();
+
+    /**
+     * Returns the session ID specified by the client. This may not be the same
+     * as the ID of the current valid session for this request. If the client
+     * did not specify a session ID, this method returns <code>null</code>.
+     *
+     * @return a <code>String</code> specifying the session ID, or
+     *         <code>null</code> if the request did not specify a session ID
+     * @see #isRequestedSessionIdValid
+     */
+    public String getRequestedSessionId();
+
+    /**
+     * Returns the part of this request's URL from the protocol name up to the
+     * query string in the first line of the HTTP request. The web container
+     * does not decode this String. For example:
+     * <table>
+     * <caption>Examples of Returned Values</caption>
+     * <tr>
+     * <th>First line of HTTP request</th>
+     * <th>Returned Value</th>
+     * <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>/a.html
+     * <tr>
+     * <td>HEAD /xyz?a=b HTTP/1.1
+     * <td>
+     * <td>/xyz
+     * </table>
+     * <p>
+     * To reconstruct a URL with a scheme and host, use
+     * {@link #getRequestURL}.
+     *
+     * @return a <code>String</code> containing the part of the URL from the
+     *         protocol name up to the query string
+     * @see #getRequestURL
+     */
+    public String getRequestURI();
+
+    /**
+     * Reconstructs the URL the client used to make the request. The returned
+     * URL contains a protocol, server name, port number, and server path, but
+     * it does not include query string parameters.
+     * <p>
+     * Because this method returns a <code>StringBuffer</code>, not a string,
+     * you can modify the URL easily, for example, to append query parameters.
+     * <p>
+     * This method is useful for creating redirect messages and for reporting
+     * errors.
+     *
+     * @return a <code>StringBuffer</code> object containing the reconstructed
+     *         URL
+     */
+    public StringBuffer getRequestURL();
+
+    /**
+     * Returns the part of this request's URL that calls the servlet. This path
+     * starts with a "/" character and includes either the servlet name or a
+     * path to the servlet, but does not include any extra path information or a
+     * query string. Same as the value of the CGI variable SCRIPT_NAME.
+     * <p>
+     * This method will return an empty string ("") if the servlet used to
+     * process this request was matched using the "/*" pattern.
+     *
+     * @return a <code>String</code> containing the name or path of the servlet
+     *         being called, as specified in the request URL, decoded, or an
+     *         empty string if the servlet used to process the request is
+     *         matched using the "/*" pattern.
+     */
+    public String getServletPath();
+
+    /**
+     * Returns the current <code>HttpSession</code> associated with this request
+     * or, if there is no current session and <code>create</code> is true,
+     * returns a new session.
+     * <p>
+     * If <code>create</code> is <code>false</code> and the request has no valid
+     * <code>HttpSession</code>, this method returns <code>null</code>.
+     * <p>
+     * To make sure the session is properly maintained, you must call this
+     * method before the response is committed. If the container is using
+     * cookies to maintain session integrity and is asked to create a new
+     * session when the response is committed, an IllegalStateException is
+     * thrown.
+     *
+     * @param create
+     *            <code>true</code> to create a new session for this request if
+     *            necessary; <code>false</code> to return <code>null</code> if
+     *            there's no current session
+     * @return the <code>HttpSession</code> associated with this request or
+     *         <code>null</code> if <code>create</code> is <code>false</code>
+     *         and the request has no valid session
+     * @see #getSession()
+     */
+    public HttpSession getSession(boolean create);
+
+    /**
+     * Returns the current session associated with this request, or if the
+     * request does not have a session, creates one.
+     *
+     * @return the <code>HttpSession</code> associated with this request
+     * @see #getSession(boolean)
+     */
+    public HttpSession getSession();
+
+    /**
+     * Changes the session ID of the session associated with this request. This
+     * method does not create a new session object it only changes the ID of the
+     * current session.
+     *
+     * @return the new session ID allocated to the session
+     * @see HttpSessionIdListener
+     * @since Servlet 3.1
+     */
+    public String changeSessionId();
+
+    /**
+     * Checks whether the requested session ID is still valid.
+     *
+     * @return <code>true</code> if this request has an id for a valid session
+     *         in the current session context; <code>false</code> otherwise
+     * @see #getRequestedSessionId
+     * @see #getSession
+     */
+    public boolean isRequestedSessionIdValid();
+
+    /**
+     * Checks whether the requested session ID came in as a cookie.
+     *
+     * @return <code>true</code> if the session ID came in as a cookie;
+     *         otherwise, <code>false</code>
+     * @see #getSession
+     */
+    public boolean isRequestedSessionIdFromCookie();
+
+    /**
+     * Checks whether the requested session ID came in as part of the request
+     * URL.
+     *
+     * @return <code>true</code> if the session ID came in as part of a URL;
+     *         otherwise, <code>false</code>
+     * @see #getSession
+     */
+    public boolean isRequestedSessionIdFromURL();
+
+    /**
+     * @return {@link #isRequestedSessionIdFromURL()}
+     * @deprecated As of Version 2.1 of the Java Servlet API, use
+     *             {@link #isRequestedSessionIdFromURL} instead.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public boolean isRequestedSessionIdFromUrl();
+
+    /**
+     * Triggers the same authentication process as would be triggered if the
+     * request is for a resource that is protected by a security constraint.
+     *
+     * @param response  The response to use to return any authentication
+     *                  challenge
+     * @return <code>true</code> if the user is successfully authenticated and
+     *         <code>false</code> if not
+     *
+     * @throws IOException if the authentication process attempted to read from
+     *         the request or write to the response and an I/O error occurred
+     * @throws IllegalStateException if the authentication process attempted to
+     *         write to the response after it had been committed
+     * @throws ServletException if the authentication failed and the caller is
+     *         expected to handle the failure
+     * @since Servlet 3.0
+     */
+    public boolean authenticate(HttpServletResponse response)
+            throws IOException, ServletException;
+
+    /**
+     * Authenticate the provided user name and password and then associated the
+     * authenticated user with the request.
+     *
+     * @param username  The user name to authenticate
+     * @param password  The password to use to authenticate the user
+     *
+     * @throws ServletException
+     *             If any of {@link #getRemoteUser()},
+     *             {@link #getUserPrincipal()} or {@link #getAuthType()} are
+     *             non-null, if the configured authenticator does not support
+     *             user name and password authentication or if the
+     *             authentication fails
+     * @since Servlet 3.0
+     */
+    public void login(String username, String password) throws ServletException;
+
+    /**
+     * Removes any authenticated user from the request.
+     *
+     * @throws ServletException
+     *             If the logout fails
+     * @since Servlet 3.0
+     */
+    public void logout() throws ServletException;
+
+    /**
+     * Return a collection of all uploaded Parts.
+     *
+     * @return A collection of all uploaded Parts.
+     * @throws IOException
+     *             if an I/O error occurs
+     * @throws IllegalStateException
+     *             if size limits are exceeded or no multipart configuration is
+     *             provided
+     * @throws ServletException
+     *             if the request is not multipart/form-data
+     * @since Servlet 3.0
+     */
+    public Collection<Part> getParts() throws IOException,
+            ServletException;
+
+    /**
+     * Gets the named Part or null if the Part does not exist. Triggers upload
+     * of all Parts.
+     *
+     * @param name The name of the Part to obtain
+     *
+     * @return The named Part or null if the Part does not exist
+     * @throws IOException
+     *             if an I/O error occurs
+     * @throws IllegalStateException
+     *             if size limits are exceeded
+     * @throws ServletException
+     *             if the request is not multipart/form-data
+     * @since Servlet 3.0
+     */
+    public Part getPart(String name) throws IOException,
+            ServletException;
+
+    /**
+     * Start the HTTP upgrade process and pass the connection to the provided
+     * protocol handler once the current request/response pair has completed
+     * processing. Calling this method sets the response status to {@link
+     * HttpServletResponse#SC_SWITCHING_PROTOCOLS} and flushes the response.
+     * Protocol specific headers must have already been set before this method
+     * is called.
+     *
+     * @param <T>                     The type of the upgrade handler
+     * @param httpUpgradeHandlerClass The class that implements the upgrade
+     *                                handler
+     *
+     * @return A newly created instance of the specified upgrade handler type
+     *
+     * @throws IOException
+     *             if an I/O error occurred during the upgrade
+     * @throws ServletException
+     *             if the given httpUpgradeHandlerClass fails to be instantiated
+     * @since Servlet 3.1
+     */
+    public <T extends HttpUpgradeHandler> T upgrade(
+            Class<T> httpUpgradeHandlerClass) throws java.io.IOException, ServletException;
+}

java/javax/servlet/http/HttpServletRequestWrapper.java

@@ -0,0 +1,378 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Enumeration;
+
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequestWrapper;
+
+/**
+ * Provides a convenient implementation of the HttpServletRequest interface that
+ * can be subclassed by developers wishing to adapt the request to a Servlet.
+ * This class implements the Wrapper or Decorator pattern. Methods default to
+ * calling through to the wrapped request object.
+ *
+ * @see javax.servlet.http.HttpServletRequest
+ * @since v 2.3
+ */
+public class HttpServletRequestWrapper extends ServletRequestWrapper implements
+        HttpServletRequest {
+
+    /**
+     * Constructs a request object wrapping the given request.
+     *
+     * @param request The request to wrap
+     *
+     * @throws java.lang.IllegalArgumentException
+     *             if the request is null
+     */
+    public HttpServletRequestWrapper(HttpServletRequest request) {
+        super(request);
+    }
+
+    private HttpServletRequest _getHttpServletRequest() {
+        return (HttpServletRequest) super.getRequest();
+    }
+
+    /**
+     * The default behavior of this method is to return getAuthType() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getAuthType() {
+        return this._getHttpServletRequest().getAuthType();
+    }
+
+    /**
+     * The default behavior of this method is to return getCookies() on the
+     * wrapped request object.
+     */
+    @Override
+    public Cookie[] getCookies() {
+        return this._getHttpServletRequest().getCookies();
+    }
+
+    /**
+     * The default behavior of this method is to return getDateHeader(String
+     * name) on the wrapped request object.
+     */
+    @Override
+    public long getDateHeader(String name) {
+        return this._getHttpServletRequest().getDateHeader(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getHeader(String name)
+     * on the wrapped request object.
+     */
+    @Override
+    public String getHeader(String name) {
+        return this._getHttpServletRequest().getHeader(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getHeaders(String name)
+     * on the wrapped request object.
+     */
+    @Override
+    public Enumeration<String> getHeaders(String name) {
+        return this._getHttpServletRequest().getHeaders(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getHeaderNames() on the
+     * wrapped request object.
+     */
+    @Override
+    public Enumeration<String> getHeaderNames() {
+        return this._getHttpServletRequest().getHeaderNames();
+    }
+
+    /**
+     * The default behavior of this method is to return getIntHeader(String
+     * name) on the wrapped request object.
+     */
+    @Override
+    public int getIntHeader(String name) {
+        return this._getHttpServletRequest().getIntHeader(name);
+    }
+
+    /**
+     * The default behavior of this method is to return getMethod() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getMethod() {
+        return this._getHttpServletRequest().getMethod();
+    }
+
+    /**
+     * The default behavior of this method is to return getPathInfo() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getPathInfo() {
+        return this._getHttpServletRequest().getPathInfo();
+    }
+
+    /**
+     * The default behavior of this method is to return getPathTranslated() on
+     * the wrapped request object.
+     */
+    @Override
+    public String getPathTranslated() {
+        return this._getHttpServletRequest().getPathTranslated();
+    }
+
+    /**
+     * The default behavior of this method is to return getContextPath() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getContextPath() {
+        return this._getHttpServletRequest().getContextPath();
+    }
+
+    /**
+     * The default behavior of this method is to return getQueryString() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getQueryString() {
+        return this._getHttpServletRequest().getQueryString();
+    }
+
+    /**
+     * The default behavior of this method is to return getRemoteUser() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getRemoteUser() {
+        return this._getHttpServletRequest().getRemoteUser();
+    }
+
+    /**
+     * The default behavior of this method is to return isUserInRole(String
+     * role) on the wrapped request object.
+     */
+    @Override
+    public boolean isUserInRole(String role) {
+        return this._getHttpServletRequest().isUserInRole(role);
+    }
+
+    /**
+     * The default behavior of this method is to return getUserPrincipal() on
+     * the wrapped request object.
+     */
+    @Override
+    public java.security.Principal getUserPrincipal() {
+        return this._getHttpServletRequest().getUserPrincipal();
+    }
+
+    /**
+     * The default behavior of this method is to return getRequestedSessionId()
+     * on the wrapped request object.
+     */
+    @Override
+    public String getRequestedSessionId() {
+        return this._getHttpServletRequest().getRequestedSessionId();
+    }
+
+    /**
+     * The default behavior of this method is to return getRequestURI() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getRequestURI() {
+        return this._getHttpServletRequest().getRequestURI();
+    }
+
+    /**
+     * The default behavior of this method is to return getRequestURL() on the
+     * wrapped request object.
+     */
+    @Override
+    public StringBuffer getRequestURL() {
+        return this._getHttpServletRequest().getRequestURL();
+    }
+
+    /**
+     * The default behavior of this method is to return getServletPath() on the
+     * wrapped request object.
+     */
+    @Override
+    public String getServletPath() {
+        return this._getHttpServletRequest().getServletPath();
+    }
+
+    /**
+     * The default behavior of this method is to return getSession(boolean
+     * create) on the wrapped request object.
+     */
+    @Override
+    public HttpSession getSession(boolean create) {
+        return this._getHttpServletRequest().getSession(create);
+    }
+
+    /**
+     * The default behavior of this method is to return getSession() on the
+     * wrapped request object.
+     */
+    @Override
+    public HttpSession getSession() {
+        return this._getHttpServletRequest().getSession();
+    }
+
+    /**
+     * The default behavior of this method is to call changeSessionId() on the
+     * wrapped request object.
+     */
+    @Override
+    public String changeSessionId() {
+        return this._getHttpServletRequest().changeSessionId();
+    }
+
+    /**
+     * The default behavior of this method is to return
+     * isRequestedSessionIdValid() on the wrapped request object.
+     */
+    @Override
+    public boolean isRequestedSessionIdValid() {
+        return this._getHttpServletRequest().isRequestedSessionIdValid();
+    }
+
+    /**
+     * The default behavior of this method is to return
+     * isRequestedSessionIdFromCookie() on the wrapped request object.
+     */
+    @Override
+    public boolean isRequestedSessionIdFromCookie() {
+        return this._getHttpServletRequest().isRequestedSessionIdFromCookie();
+    }
+
+    /**
+     * The default behavior of this method is to return
+     * isRequestedSessionIdFromURL() on the wrapped request object.
+     */
+    @Override
+    public boolean isRequestedSessionIdFromURL() {
+        return this._getHttpServletRequest().isRequestedSessionIdFromURL();
+    }
+
+    /**
+     * The default behavior of this method is to return
+     * isRequestedSessionIdFromUrl() on the wrapped request object.
+     *
+     * @deprecated As of Version 3.0 of the Java Servlet API
+     */
+    @Override
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public boolean isRequestedSessionIdFromUrl() {
+        return this._getHttpServletRequest().isRequestedSessionIdFromUrl();
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default behavior of this method is to return
+     * {@link HttpServletRequest#authenticate(HttpServletResponse)}
+     * on the wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public boolean authenticate(HttpServletResponse response)
+            throws IOException, ServletException {
+        return this._getHttpServletRequest().authenticate(response);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default behavior of this method is to return
+     * {@link HttpServletRequest#login(String, String)}
+     * on the wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public void login(String username, String password) throws ServletException {
+        this._getHttpServletRequest().login(username, password);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default behavior of this method is to return
+     * {@link HttpServletRequest#logout()}
+     * on the wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public void logout() throws ServletException {
+        this._getHttpServletRequest().logout();
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default behavior of this method is to return
+     * {@link HttpServletRequest#getParts()}
+     * on the wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public Collection<Part> getParts() throws IOException,
+            ServletException {
+        return this._getHttpServletRequest().getParts();
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default behavior of this method is to return
+     * {@link HttpServletRequest#getPart(String)}
+     * on the wrapped request object.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public Part getPart(String name) throws IOException,
+            ServletException {
+        return this._getHttpServletRequest().getPart(name);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default behavior of this method is to return
+     * {@link HttpServletRequest#upgrade(Class)} on the wrapped request object.
+     *
+     * @since Servlet 3.1
+     */
+    @Override
+    public <T extends HttpUpgradeHandler> T upgrade(
+            Class<T> httpUpgradeHandlerClass) throws IOException, ServletException {
+        return this._getHttpServletRequest().upgrade(httpUpgradeHandlerClass);
+    }
+}

java/javax/servlet/http/HttpServletResponse.java

@@ -0,0 +1,609 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.util.Collection;
+
+import javax.servlet.ServletResponse;
+
+/**
+ * Extends the {@link ServletResponse} interface to provide HTTP-specific
+ * functionality in sending a response. For example, it has methods to access
+ * HTTP headers and cookies.
+ * <p>
+ * The servlet container creates an <code>HttpServletResponse</code> object and
+ * passes it as an argument to the servlet's service methods (<code>doGet</code>, <code>doPost</code>, etc).
+ *
+ * @see javax.servlet.ServletResponse
+ */
+public interface HttpServletResponse extends ServletResponse {
+
+    /**
+     * Adds the specified cookie to the response. This method can be called
+     * multiple times to set more than one cookie.
+     *
+     * @param cookie
+     *            the Cookie to return to the client
+     */
+    public void addCookie(Cookie cookie);
+
+    /**
+     * Returns a boolean indicating whether the named response header has
+     * already been set.
+     *
+     * @param name
+     *            the header name
+     * @return <code>true</code> if the named response header has already been
+     *         set; <code>false</code> otherwise
+     */
+    public boolean containsHeader(String name);
+
+    /**
+     * Encodes the specified URL by including the session ID in it, or, if
+     * encoding is not needed, returns the URL unchanged. The implementation of
+     * this method includes the logic to determine whether the session ID needs
+     * to be encoded in the URL. For example, if the browser supports cookies,
+     * or session tracking is turned off, URL encoding is unnecessary.
+     * <p>
+     * For robust session tracking, all URLs emitted by a servlet should be run
+     * through this method. Otherwise, URL rewriting cannot be used with
+     * browsers which do not support cookies.
+     *
+     * @param url
+     *            the url to be encoded.
+     * @return the encoded URL if encoding is needed; the unchanged URL
+     *         otherwise.
+     */
+    public String encodeURL(String url);
+
+    /**
+     * Encodes the specified URL for use in the <code>sendRedirect</code> method
+     * or, if encoding is not needed, returns the URL unchanged. The
+     * implementation of this method includes the logic to determine whether the
+     * session ID needs to be encoded in the URL. Because the rules for making
+     * this determination can differ from those used to decide whether to encode
+     * a normal link, this method is separated from the <code>encodeURL</code>
+     * method.
+     * <p>
+     * All URLs sent to the <code>HttpServletResponse.sendRedirect</code> method
+     * should be run through this method. Otherwise, URL rewriting cannot be
+     * used with browsers which do not support cookies.
+     *
+     * @param url
+     *            the url to be encoded.
+     * @return the encoded URL if encoding is needed; the unchanged URL
+     *         otherwise.
+     * @see #sendRedirect
+     * @see #encodeUrl
+     */
+    public String encodeRedirectURL(String url);
+
+    /**
+     * @param url
+     *            the url to be encoded.
+     * @return the encoded URL if encoding is needed; the unchanged URL
+     *         otherwise.
+     * @deprecated As of version 2.1, use encodeURL(String url) instead
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public String encodeUrl(String url);
+
+    /**
+     * @param url
+     *            the url to be encoded.
+     * @return the encoded URL if encoding is needed; the unchanged URL
+     *         otherwise.
+     * @deprecated As of version 2.1, use encodeRedirectURL(String url) instead
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public String encodeRedirectUrl(String url);
+
+    /**
+     * Sends an error response to the client using the specified status code and
+     * clears the output buffer. The server defaults to creating the response to
+     * look like an HTML-formatted server error page containing the specified
+     * message, setting the content type to "text/html", leaving cookies and
+     * other headers unmodified. If an error-page declaration has been made for
+     * the web application corresponding to the status code passed in, it will
+     * be served back in preference to the suggested msg parameter.
+     * <p>
+     * If the response has already been committed, this method throws an
+     * IllegalStateException. After using this method, the response should be
+     * considered to be committed and should not be written to.
+     *
+     * @param sc
+     *            the error status code
+     * @param msg
+     *            the descriptive message
+     * @exception IOException
+     *                If an input or output exception occurs
+     * @exception IllegalStateException
+     *                If the response was committed
+     */
+    public void sendError(int sc, String msg) throws IOException;
+
+    /**
+     * Sends an error response to the client using the specified status code and
+     * clears the buffer. This is equivalent to calling {@link #sendError(int,
+     * String)} with the same status code and <code>null</code> for the message.
+     *
+     * @param sc
+     *            the error status code
+     * @exception IOException
+     *                If an input or output exception occurs
+     * @exception IllegalStateException
+     *                If the response was committed before this method call
+     */
+    public void sendError(int sc) throws IOException;
+
+    /**
+     * Sends a temporary redirect response to the client using the specified
+     * redirect location URL. This method can accept relative URLs; the servlet
+     * container must convert the relative URL to an absolute URL before sending
+     * the response to the client. If the location is relative without a leading
+     * '/' the container interprets it as relative to the current request URI.
+     * If the location is relative with a leading '/' the container interprets
+     * it as relative to the servlet container root.
+     * <p>
+     * If the response has already been committed, this method throws an
+     * IllegalStateException. After using this method, the response should be
+     * considered to be committed and should not be written to.
+     *
+     * @param location
+     *            the redirect location URL
+     * @exception IOException
+     *                If an input or output exception occurs
+     * @exception IllegalStateException
+     *                If the response was committed or if a partial URL is given
+     *                and cannot be converted into a valid URL
+     */
+    public void sendRedirect(String location) throws IOException;
+
+    /**
+     * Sets a response header with the given name and date-value. The date is
+     * specified in terms of milliseconds since the epoch. If the header had
+     * already been set, the new value overwrites the previous one. The
+     * <code>containsHeader</code> method can be used to test for the presence
+     * of a header before setting its value.
+     *
+     * @param name
+     *            the name of the header to set
+     * @param date
+     *            the assigned date value
+     * @see #containsHeader
+     * @see #addDateHeader
+     */
+    public void setDateHeader(String name, long date);
+
+    /**
+     * Adds a response header with the given name and date-value. The date is
+     * specified in terms of milliseconds since the epoch. This method allows
+     * response headers to have multiple values.
+     *
+     * @param name
+     *            the name of the header to set
+     * @param date
+     *            the additional date value
+     * @see #setDateHeader
+     */
+    public void addDateHeader(String name, long date);
+
+    /**
+     * Sets a response header with the given name and value. If the header had
+     * already been set, the new value overwrites the previous one. The
+     * <code>containsHeader</code> method can be used to test for the presence
+     * of a header before setting its value.
+     *
+     * @param name
+     *            the name of the header
+     * @param value
+     *            the header value If it contains octet string, it should be
+     *            encoded according to RFC 2047
+     *            (http://www.ietf.org/rfc/rfc2047.txt)
+     * @see #containsHeader
+     * @see #addHeader
+     */
+    public void setHeader(String name, String value);
+
+    /**
+     * Adds a response header with the given name and value. This method allows
+     * response headers to have multiple values.
+     *
+     * @param name
+     *            the name of the header
+     * @param value
+     *            the additional header value If it contains octet string, it
+     *            should be encoded according to RFC 2047
+     *            (http://www.ietf.org/rfc/rfc2047.txt)
+     * @see #setHeader
+     */
+    public void addHeader(String name, String value);
+
+    /**
+     * Sets a response header with the given name and integer value. If the
+     * header had already been set, the new value overwrites the previous one.
+     * The <code>containsHeader</code> method can be used to test for the
+     * presence of a header before setting its value.
+     *
+     * @param name
+     *            the name of the header
+     * @param value
+     *            the assigned integer value
+     * @see #containsHeader
+     * @see #addIntHeader
+     */
+    public void setIntHeader(String name, int value);
+
+    /**
+     * Adds a response header with the given name and integer value. This method
+     * allows response headers to have multiple values.
+     *
+     * @param name
+     *            the name of the header
+     * @param value
+     *            the assigned integer value
+     * @see #setIntHeader
+     */
+    public void addIntHeader(String name, int value);
+
+    /**
+     * Sets the status code for this response. This method is used to set the
+     * return status code when there is no error (for example, for the status
+     * codes SC_OK or SC_MOVED_TEMPORARILY). If there is an error, and the
+     * caller wishes to invoke an error-page defined in the web application, the
+     * <code>sendError</code> method should be used instead.
+     * <p>
+     * The container clears the buffer and sets the Location header, preserving
+     * cookies and other headers.
+     *
+     * @param sc
+     *            the status code
+     * @see #sendError
+     */
+    public void setStatus(int sc);
+
+    /**
+     * Sets the status code and message for this response.
+     *
+     * @param sc
+     *            the status code
+     * @param sm
+     *            the status message
+     * @deprecated As of version 2.1, due to ambiguous meaning of the message
+     *             parameter. To set a status code use
+     *             <code>setStatus(int)</code>, to send an error with a
+     *             description use <code>sendError(int, String)</code>.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public void setStatus(int sc, String sm);
+
+    /**
+     * Get the HTTP status code for this Response.
+     *
+     * @return The HTTP status code for this Response
+     *
+     * @since Servlet 3.0
+     */
+    public int getStatus();
+
+    /**
+     * Return the value for the specified header, or <code>null</code> if this
+     * header has not been set.  If more than one value was added for this
+     * name, only the first is returned; use {@link #getHeaders(String)} to
+     * retrieve all of them.
+     *
+     * @param name Header name to look up
+     *
+     * @return The first value for the specified header. This is the raw value
+     *         so if multiple values are specified in the first header then they
+     *         will be returned as a single header value .
+     *
+     * @since Servlet 3.0
+     */
+    public String getHeader(String name);
+
+    /**
+     * Return a Collection of all the header values associated with the
+     * specified header name.
+     *
+     * @param name Header name to look up
+     *
+     * @return The values for the specified header. These are the raw values so
+     *         if multiple values are specified in a single header that will be
+     *         returned as a single header value.
+     *
+     * @since Servlet 3.0
+     */
+    public Collection<String> getHeaders(String name);
+
+    /**
+     * Get the header names set for this HTTP response.
+     *
+     * @return The header names set for this HTTP response.
+     *
+     * @since Servlet 3.0
+     */
+    public Collection<String> getHeaderNames();
+
+    /*
+     * Server status codes; see RFC 2068.
+     */
+
+    /**
+     * Status code (100) indicating the client can continue.
+     */
+    public static final int SC_CONTINUE = 100;
+
+    /**
+     * Status code (101) indicating the server is switching protocols according
+     * to Upgrade header.
+     */
+    public static final int SC_SWITCHING_PROTOCOLS = 101;
+
+    /**
+     * Status code (200) indicating the request succeeded normally.
+     */
+    public static final int SC_OK = 200;
+
+    /**
+     * Status code (201) indicating the request succeeded and created a new
+     * resource on the server.
+     */
+    public static final int SC_CREATED = 201;
+
+    /**
+     * Status code (202) indicating that a request was accepted for processing,
+     * but was not completed.
+     */
+    public static final int SC_ACCEPTED = 202;
+
+    /**
+     * Status code (203) indicating that the meta information presented by the
+     * client did not originate from the server.
+     */
+    public static final int SC_NON_AUTHORITATIVE_INFORMATION = 203;
+
+    /**
+     * Status code (204) indicating that the request succeeded but that there
+     * was no new information to return.
+     */
+    public static final int SC_NO_CONTENT = 204;
+
+    /**
+     * Status code (205) indicating that the agent <em>SHOULD</em> reset the
+     * document view which caused the request to be sent.
+     */
+    public static final int SC_RESET_CONTENT = 205;
+
+    /**
+     * Status code (206) indicating that the server has fulfilled the partial
+     * GET request for the resource.
+     */
+    public static final int SC_PARTIAL_CONTENT = 206;
+
+    /**
+     * Status code (300) indicating that the requested resource corresponds to
+     * any one of a set of representations, each with its own specific location.
+     */
+    public static final int SC_MULTIPLE_CHOICES = 300;
+
+    /**
+     * Status code (301) indicating that the resource has permanently moved to a
+     * new location, and that future references should use a new URI with their
+     * requests.
+     */
+    public static final int SC_MOVED_PERMANENTLY = 301;
+
+    /**
+     * Status code (302) indicating that the resource has temporarily moved to
+     * another location, but that future references should still use the
+     * original URI to access the resource. This definition is being retained
+     * for backwards compatibility. SC_FOUND is now the preferred definition.
+     */
+    public static final int SC_MOVED_TEMPORARILY = 302;
+
+    /**
+     * Status code (302) indicating that the resource reside temporarily under a
+     * different URI. Since the redirection might be altered on occasion, the
+     * client should continue to use the Request-URI for future
+     * requests.(HTTP/1.1) To represent the status code (302), it is recommended
+     * to use this variable.
+     */
+    public static final int SC_FOUND = 302;
+
+    /**
+     * Status code (303) indicating that the response to the request can be
+     * found under a different URI.
+     */
+    public static final int SC_SEE_OTHER = 303;
+
+    /**
+     * Status code (304) indicating that a conditional GET operation found that
+     * the resource was available and not modified.
+     */
+    public static final int SC_NOT_MODIFIED = 304;
+
+    /**
+     * Status code (305) indicating that the requested resource <em>MUST</em> be
+     * accessed through the proxy given by the <code><em>Location</em></code>
+     * field.
+     */
+    public static final int SC_USE_PROXY = 305;
+
+    /**
+     * Status code (307) indicating that the requested resource resides
+     * temporarily under a different URI. The temporary URI <em>SHOULD</em> be
+     * given by the <code><em>Location</em></code> field in the response.
+     */
+    public static final int SC_TEMPORARY_REDIRECT = 307;
+
+    /**
+     * Status code (400) indicating the request sent by the client was
+     * syntactically incorrect.
+     */
+    public static final int SC_BAD_REQUEST = 400;
+
+    /**
+     * Status code (401) indicating that the request requires HTTP
+     * authentication.
+     */
+    public static final int SC_UNAUTHORIZED = 401;
+
+    /**
+     * Status code (402) reserved for future use.
+     */
+    public static final int SC_PAYMENT_REQUIRED = 402;
+
+    /**
+     * Status code (403) indicating the server understood the request but
+     * refused to fulfill it.
+     */
+    public static final int SC_FORBIDDEN = 403;
+
+    /**
+     * Status code (404) indicating that the requested resource is not
+     * available.
+     */
+    public static final int SC_NOT_FOUND = 404;
+
+    /**
+     * Status code (405) indicating that the method specified in the
+     * <code><em>Request-Line</em></code> is not allowed for the resource
+     * identified by the <code><em>Request-URI</em></code>.
+     */
+    public static final int SC_METHOD_NOT_ALLOWED = 405;
+
+    /**
+     * Status code (406) indicating that the resource identified by the request
+     * is only capable of generating response entities which have content
+     * characteristics not acceptable according to the accept headers sent in
+     * the request.
+     */
+    public static final int SC_NOT_ACCEPTABLE = 406;
+
+    /**
+     * Status code (407) indicating that the client <em>MUST</em> first
+     * authenticate itself with the proxy.
+     */
+    public static final int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
+
+    /**
+     * Status code (408) indicating that the client did not produce a request
+     * within the time that the server was prepared to wait.
+     */
+    public static final int SC_REQUEST_TIMEOUT = 408;
+
+    /**
+     * Status code (409) indicating that the request could not be completed due
+     * to a conflict with the current state of the resource.
+     */
+    public static final int SC_CONFLICT = 409;
+
+    /**
+     * Status code (410) indicating that the resource is no longer available at
+     * the server and no forwarding address is known. This condition
+     * <em>SHOULD</em> be considered permanent.
+     */
+    public static final int SC_GONE = 410;
+
+    /**
+     * Status code (411) indicating that the request cannot be handled without a
+     * defined <code><em>Content-Length</em></code>.
+     */
+    public static final int SC_LENGTH_REQUIRED = 411;
+
+    /**
+     * Status code (412) indicating that the precondition given in one or more
+     * of the request-header fields evaluated to false when it was tested on the
+     * server.
+     */
+    public static final int SC_PRECONDITION_FAILED = 412;
+
+    /**
+     * Status code (413) indicating that the server is refusing to process the
+     * request because the request entity is larger than the server is willing
+     * or able to process.
+     */
+    public static final int SC_REQUEST_ENTITY_TOO_LARGE = 413;
+
+    /**
+     * Status code (414) indicating that the server is refusing to service the
+     * request because the <code><em>Request-URI</em></code> is longer than the
+     * server is willing to interpret.
+     */
+    public static final int SC_REQUEST_URI_TOO_LONG = 414;
+
+    /**
+     * Status code (415) indicating that the server is refusing to service the
+     * request because the entity of the request is in a format not supported by
+     * the requested resource for the requested method.
+     */
+    public static final int SC_UNSUPPORTED_MEDIA_TYPE = 415;
+
+    /**
+     * Status code (416) indicating that the server cannot serve the requested
+     * byte range.
+     */
+    public static final int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
+
+    /**
+     * Status code (417) indicating that the server could not meet the
+     * expectation given in the Expect request header.
+     */
+    public static final int SC_EXPECTATION_FAILED = 417;
+
+    /**
+     * Status code (500) indicating an error inside the HTTP server which
+     * prevented it from fulfilling the request.
+     */
+    public static final int SC_INTERNAL_SERVER_ERROR = 500;
+
+    /**
+     * Status code (501) indicating the HTTP server does not support the
+     * functionality needed to fulfill the request.
+     */
+    public static final int SC_NOT_IMPLEMENTED = 501;
+
+    /**
+     * Status code (502) indicating that the HTTP server received an invalid
+     * response from a server it consulted when acting as a proxy or gateway.
+     */
+    public static final int SC_BAD_GATEWAY = 502;
+
+    /**
+     * Status code (503) indicating that the HTTP server is temporarily
+     * overloaded, and unable to handle the request.
+     */
+    public static final int SC_SERVICE_UNAVAILABLE = 503;
+
+    /**
+     * Status code (504) indicating that the server did not receive a timely
+     * response from the upstream server while acting as a gateway or proxy.
+     */
+    public static final int SC_GATEWAY_TIMEOUT = 504;
+
+    /**
+     * Status code (505) indicating that the server does not support or refuses
+     * to support the HTTP protocol version that was used in the request
+     * message.
+     */
+    public static final int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
+}

java/javax/servlet/http/HttpServletResponseWrapper.java

@@ -0,0 +1,272 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.util.Collection;
+
+import javax.servlet.ServletResponseWrapper;
+
+/**
+ * Provides a convenient implementation of the HttpServletResponse interface
+ * that can be subclassed by developers wishing to adapt the response from a
+ * Servlet. This class implements the Wrapper or Decorator pattern. Methods
+ * default to calling through to the wrapped response object.
+ *
+ * @since v 2.3
+ * @see javax.servlet.http.HttpServletResponse
+ */
+public class HttpServletResponseWrapper extends ServletResponseWrapper
+        implements HttpServletResponse {
+
+    /**
+     * Constructs a response adaptor wrapping the given response.
+     *
+     * @param response The response to be wrapped
+     *
+     * @throws java.lang.IllegalArgumentException
+     *             if the response is null
+     */
+    public HttpServletResponseWrapper(HttpServletResponse response) {
+        super(response);
+    }
+
+    private HttpServletResponse _getHttpServletResponse() {
+        return (HttpServletResponse) super.getResponse();
+    }
+
+    /**
+     * The default behavior of this method is to call addCookie(Cookie cookie)
+     * on the wrapped response object.
+     */
+    @Override
+    public void addCookie(Cookie cookie) {
+        this._getHttpServletResponse().addCookie(cookie);
+    }
+
+    /**
+     * The default behavior of this method is to call containsHeader(String
+     * name) on the wrapped response object.
+     */
+    @Override
+    public boolean containsHeader(String name) {
+        return this._getHttpServletResponse().containsHeader(name);
+    }
+
+    /**
+     * The default behavior of this method is to call encodeURL(String url) on
+     * the wrapped response object.
+     */
+    @Override
+    public String encodeURL(String url) {
+        return this._getHttpServletResponse().encodeURL(url);
+    }
+
+    /**
+     * The default behavior of this method is to return encodeRedirectURL(String
+     * url) on the wrapped response object.
+     */
+    @Override
+    public String encodeRedirectURL(String url) {
+        return this._getHttpServletResponse().encodeRedirectURL(url);
+    }
+
+    /**
+     * The default behavior of this method is to call encodeUrl(String url) on
+     * the wrapped response object.
+     *
+     * @deprecated As of Version 3.0 of the Java Servlet API
+     */
+    @Override
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public String encodeUrl(String url) {
+        return this._getHttpServletResponse().encodeUrl(url);
+    }
+
+    /**
+     * The default behavior of this method is to return encodeRedirectUrl(String
+     * url) on the wrapped response object.
+     *
+     * @deprecated As of Version 3.0 of the Java Servlet API
+     */
+    @Override
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public String encodeRedirectUrl(String url) {
+        return this._getHttpServletResponse().encodeRedirectUrl(url);
+    }
+
+    /**
+     * The default behavior of this method is to call sendError(int sc, String
+     * msg) on the wrapped response object.
+     */
+    @Override
+    public void sendError(int sc, String msg) throws IOException {
+        this._getHttpServletResponse().sendError(sc, msg);
+    }
+
+    /**
+     * The default behavior of this method is to call sendError(int sc) on the
+     * wrapped response object.
+     */
+    @Override
+    public void sendError(int sc) throws IOException {
+        this._getHttpServletResponse().sendError(sc);
+    }
+
+    /**
+     * The default behavior of this method is to return sendRedirect(String
+     * location) on the wrapped response object.
+     */
+    @Override
+    public void sendRedirect(String location) throws IOException {
+        this._getHttpServletResponse().sendRedirect(location);
+    }
+
+    /**
+     * The default behavior of this method is to call setDateHeader(String name,
+     * long date) on the wrapped response object.
+     */
+    @Override
+    public void setDateHeader(String name, long date) {
+        this._getHttpServletResponse().setDateHeader(name, date);
+    }
+
+    /**
+     * The default behavior of this method is to call addDateHeader(String name,
+     * long date) on the wrapped response object.
+     */
+    @Override
+    public void addDateHeader(String name, long date) {
+        this._getHttpServletResponse().addDateHeader(name, date);
+    }
+
+    /**
+     * The default behavior of this method is to return setHeader(String name,
+     * String value) on the wrapped response object.
+     */
+    @Override
+    public void setHeader(String name, String value) {
+        this._getHttpServletResponse().setHeader(name, value);
+    }
+
+    /**
+     * The default behavior of this method is to return addHeader(String name,
+     * String value) on the wrapped response object.
+     */
+    @Override
+    public void addHeader(String name, String value) {
+        this._getHttpServletResponse().addHeader(name, value);
+    }
+
+    /**
+     * The default behavior of this method is to call setIntHeader(String name,
+     * int value) on the wrapped response object.
+     */
+    @Override
+    public void setIntHeader(String name, int value) {
+        this._getHttpServletResponse().setIntHeader(name, value);
+    }
+
+    /**
+     * The default behavior of this method is to call addIntHeader(String name,
+     * int value) on the wrapped response object.
+     */
+    @Override
+    public void addIntHeader(String name, int value) {
+        this._getHttpServletResponse().addIntHeader(name, value);
+    }
+
+    /**
+     * The default behavior of this method is to call setStatus(int sc) on the
+     * wrapped response object.
+     */
+    @Override
+    public void setStatus(int sc) {
+        this._getHttpServletResponse().setStatus(sc);
+    }
+
+    /**
+     * The default behavior of this method is to call setStatus(int sc, String
+     * sm) on the wrapped response object.
+     *
+     * @deprecated As of Version 3.0 of the Java Servlet API
+     */
+    @Override
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public void setStatus(int sc, String sm) {
+        this._getHttpServletResponse().setStatus(sc, sm);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default implementation is to call
+     * {@link HttpServletResponse#getStatus()}
+     * on the wrapped {@link HttpServletResponse}.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public int getStatus() {
+        return this._getHttpServletResponse().getStatus();
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default implementation is to call
+     * {@link HttpServletResponse#getHeader(String)}
+     * on the wrapped {@link HttpServletResponse}.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public String getHeader(String name) {
+        return this._getHttpServletResponse().getHeader(name);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default implementation is to call
+     * {@link HttpServletResponse#getHeaders(String)}
+     * on the wrapped {@link HttpServletResponse}.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public Collection<String> getHeaders(String name) {
+        return this._getHttpServletResponse().getHeaders(name);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The default implementation is to call
+     * {@link HttpServletResponse#getHeaderNames()}
+     * on the wrapped {@link HttpServletResponse}.
+     *
+     * @since Servlet 3.0
+     */
+    @Override
+    public Collection<String> getHeaderNames() {
+        return this._getHttpServletResponse().getHeaderNames();
+    }
+}

java/javax/servlet/http/HttpSession.java

@@ -0,0 +1,286 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.util.Enumeration;
+
+import javax.servlet.ServletContext;
+
+/**
+ * Provides a way to identify a user across more than one page request or visit
+ * to a Web site and to store information about that user.
+ * <p>
+ * The servlet container uses this interface to create a session between an HTTP
+ * client and an HTTP server. The session persists for a specified time period,
+ * across more than one connection or page request from the user. A session
+ * usually corresponds to one user, who may visit a site many times. The server
+ * can maintain a session in many ways such as using cookies or rewriting URLs.
+ * <p>
+ * This interface allows servlets to
+ * <ul>
+ * <li>View and manipulate information about a session, such as the session
+ * identifier, creation time, and last accessed time
+ * <li>Bind objects to sessions, allowing user information to persist across
+ * multiple user connections
+ * </ul>
+ * <p>
+ * When an application stores an object in or removes an object from a session,
+ * the session checks whether the object implements
+ * {@link HttpSessionBindingListener}. If it does, the servlet notifies the
+ * object that it has been bound to or unbound from the session. Notifications
+ * are sent after the binding methods complete. For session that are invalidated
+ * or expire, notifications are sent after the session has been invalidated or
+ * expired.
+ * <p>
+ * When container migrates a session between VMs in a distributed container
+ * setting, all session attributes implementing the
+ * {@link HttpSessionActivationListener} interface are notified.
+ * <p>
+ * A servlet should be able to handle cases in which the client does not choose
+ * to join a session, such as when cookies are intentionally turned off. Until
+ * the client joins the session, <code>isNew</code> returns <code>true</code>.
+ * If the client chooses not to join the session, <code>getSession</code> will
+ * return a different session on each request, and <code>isNew</code> will
+ * always return <code>true</code>.
+ * <p>
+ * Session information is scoped only to the current web application (
+ * <code>ServletContext</code>), so information stored in one context will not
+ * be directly visible in another.
+ *
+ * @see HttpSessionBindingListener
+ */
+public interface HttpSession {
+
+    /**
+     * Returns the time when this session was created, measured in milliseconds
+     * since midnight January 1, 1970 GMT.
+     *
+     * @return a <code>long</code> specifying when this session was created,
+     *         expressed in milliseconds since 1/1/1970 GMT
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     */
+    public long getCreationTime();
+
+    /**
+     * Returns a string containing the unique identifier assigned to this
+     * session. The identifier is assigned by the servlet container and is
+     * implementation dependent.
+     *
+     * @return a string specifying the identifier assigned to this session
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     */
+    public String getId();
+
+    /**
+     * Returns the last time the client sent a request associated with this
+     * session, as the number of milliseconds since midnight January 1, 1970
+     * GMT, and marked by the time the container received the request.
+     * <p>
+     * Actions that your application takes, such as getting or setting a value
+     * associated with the session, do not affect the access time.
+     *
+     * @return a <code>long</code> representing the last time the client sent a
+     *         request associated with this session, expressed in milliseconds
+     *         since 1/1/1970 GMT
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     */
+    public long getLastAccessedTime();
+
+    /**
+     * Returns the ServletContext to which this session belongs.
+     *
+     * @return The ServletContext object for the web application
+     * @since 2.3
+     */
+    public ServletContext getServletContext();
+
+    /**
+     * Specifies the time, in seconds, between client requests before the
+     * servlet container will invalidate this session. A zero or negative time
+     * indicates that the session should never timeout.
+     *
+     * @param interval
+     *            An integer specifying the number of seconds
+     */
+    public void setMaxInactiveInterval(int interval);
+
+    /**
+     * Returns the maximum time interval, in seconds, that the servlet container
+     * will keep this session open between client accesses. After this interval,
+     * the servlet container will invalidate the session. The maximum time
+     * interval can be set with the <code>setMaxInactiveInterval</code> method.
+     * A zero or negative time indicates that the session should never timeout.
+     *
+     * @return an integer specifying the number of seconds this session remains
+     *         open between client requests
+     * @see #setMaxInactiveInterval
+     */
+    public int getMaxInactiveInterval();
+
+    /**
+     * Do not use.
+     * @return A dummy implementation of HttpSessionContext
+     * @deprecated As of Version 2.1, this method is deprecated and has no
+     *             replacement. It will be removed in a future version of the
+     *             Java Servlet API.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public HttpSessionContext getSessionContext();
+
+    /**
+     * Returns the object bound with the specified name in this session, or
+     * <code>null</code> if no object is bound under the name.
+     *
+     * @param name
+     *            a string specifying the name of the object
+     * @return the object with the specified name
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     */
+    public Object getAttribute(String name);
+
+    /**
+     * @param name
+     *            a string specifying the name of the object
+     * @return the object with the specified name
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     * @deprecated As of Version 2.2, this method is replaced by
+     *             {@link #getAttribute}.
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public Object getValue(String name);
+
+    /**
+     * Returns an <code>Enumeration</code> of <code>String</code> objects
+     * containing the names of all the objects bound to this session.
+     *
+     * @return an <code>Enumeration</code> of <code>String</code> objects
+     *         specifying the names of all the objects bound to this session
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     */
+    public Enumeration<String> getAttributeNames();
+
+    /**
+     * @return an array of <code>String</code> objects specifying the names of
+     *         all the objects bound to this session
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     * @deprecated As of Version 2.2, this method is replaced by
+     *             {@link #getAttributeNames}
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public String[] getValueNames();
+
+    /**
+     * Binds an object to this session, using the name specified. If an object
+     * of the same name is already bound to the session, the object is replaced.
+     * <p>
+     * After this method executes, and if the new object implements
+     * <code>HttpSessionBindingListener</code>, the container calls
+     * <code>HttpSessionBindingListener.valueBound</code>. The container then
+     * notifies any <code>HttpSessionAttributeListener</code>s in the web
+     * application.
+     * <p>
+     * If an object was already bound to this session of this name that
+     * implements <code>HttpSessionBindingListener</code>, its
+     * <code>HttpSessionBindingListener.valueUnbound</code> method is called.
+     * <p>
+     * If the value passed in is null, this has the same effect as calling
+     * <code>removeAttribute()</code>.
+     *
+     * @param name
+     *            the name to which the object is bound; cannot be null
+     * @param value
+     *            the object to be bound
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     */
+    public void setAttribute(String name, Object value);
+
+    /**
+     * @param name
+     *            the name to which the object is bound; cannot be null
+     * @param value
+     *            the object to be bound; cannot be null
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     * @deprecated As of Version 2.2, this method is replaced by
+     *             {@link #setAttribute}
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public void putValue(String name, Object value);
+
+    /**
+     * Removes the object bound with the specified name from this session. If
+     * the session does not have an object bound with the specified name, this
+     * method does nothing.
+     * <p>
+     * After this method executes, and if the object implements
+     * <code>HttpSessionBindingListener</code>, the container calls
+     * <code>HttpSessionBindingListener.valueUnbound</code>. The container then
+     * notifies any <code>HttpSessionAttributeListener</code>s in the web
+     * application.
+     *
+     * @param name
+     *            the name of the object to remove from this session
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     */
+    public void removeAttribute(String name);
+
+    /**
+     * @param name
+     *            the name of the object to remove from this session
+     * @exception IllegalStateException
+     *                if this method is called on an invalidated session
+     * @deprecated As of Version 2.2, this method is replaced by
+     *             {@link #removeAttribute}
+     */
+    @SuppressWarnings("dep-ann")
+    // Spec API does not use @Deprecated
+    public void removeValue(String name);
+
+    /**
+     * Invalidates this session then unbinds any objects bound to it.
+     *
+     * @exception IllegalStateException
+     *                if this method is called on an already invalidated session
+     */
+    public void invalidate();
+
+    /**
+     * Returns <code>true</code> if the client does not yet know about the
+     * session or if the client chooses not to join the session. For example, if
+     * the server used only cookie-based sessions, and the client had disabled
+     * the use of cookies, then a session would be new on each request.
+     *
+     * @return <code>true</code> if the server has created a session, but the
+     *         client has not yet joined
+     * @exception IllegalStateException
+     *                if this method is called on an already invalidated session
+     */
+    public boolean isNew();
+}

java/javax/servlet/http/HttpSessionActivationListener.java

@@ -0,0 +1,46 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet.http;
+
+import java.util.EventListener;
+
+/**
+ * Objects that are bound to a session may listen to container events notifying
+ * them that sessions will be passivated and that session will be activated. A
+ * container that migrates session between VMs or persists sessions is required
+ * to notify all attributes bound to sessions implementing
+ * HttpSessionActivationListener.
+ *
+ * @since 2.3
+ */
+public interface HttpSessionActivationListener extends EventListener {
+
+    /**
+     * Notification that the session is about to be passivated.
+     *
+     * @param se Information about the session this is about to be passivated
+     */
+    public void sessionWillPassivate(HttpSessionEvent se);
+
+    /**
+     * Notification that the session has just been activated.
+     *
+     * @param se Information about the session this has just been activated
+     */
+    public void sessionDidActivate(HttpSessionEvent se);
+}
+

java/javax/servlet/http/HttpSessionAttributeListener.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.util.EventListener;
+
+/**
+ * This listener interface can be implemented in order to get notifications of
+ * changes to the attribute lists of sessions within this web application.
+ *
+ * @since v 2.3
+ */
+public interface HttpSessionAttributeListener extends EventListener {
+
+    /**
+     * Notification that an attribute has been added to a session. Called after
+     * the attribute is added.
+     *
+     * @param se Information about the added attribute
+     */
+    public void attributeAdded(HttpSessionBindingEvent se);
+
+    /**
+     * Notification that an attribute has been removed from a session. Called
+     * after the attribute is removed.
+     *
+     * @param se Information about the removed attribute
+     */
+    public void attributeRemoved(HttpSessionBindingEvent se);
+
+    /**
+     * Notification that an attribute has been replaced in a session. Called
+     * after the attribute is replaced.
+     *
+     * @param se Information about the replaced attribute
+     */
+    public void attributeReplaced(HttpSessionBindingEvent se);
+}

java/javax/servlet/http/HttpSessionBindingEvent.java

@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.http;
+
+/**
+ * Events of this type are either sent to an object that implements
+ * {@link HttpSessionBindingListener} when it is bound or unbound from a
+ * session, or to a {@link HttpSessionAttributeListener} that has been
+ * configured in the deployment descriptor when any attribute is bound, unbound
+ * or replaced in a session.
+ * <p>
+ * The session binds the object by a call to
+ * <code>HttpSession.setAttribute</code> and unbinds the object by a call to
+ * <code>HttpSession.removeAttribute</code>.
+ *
+ * @see HttpSession
+ * @see HttpSessionBindingListener
+ * @see HttpSessionAttributeListener
+ */
+public class HttpSessionBindingEvent extends HttpSessionEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /* The name to which the object is being bound or unbound */
+    private final String name;
+
+    /* The object is being bound or unbound */
+    private final Object value;
+
+    /**
+     * Constructs an event that notifies an object that it has been bound to or
+     * unbound from a session. To receive the event, the object must implement
+     * {@link HttpSessionBindingListener}.
+     *
+     * @param session
+     *            the session to which the object is bound or unbound
+     * @param name
+     *            the name with which the object is bound or unbound
+     * @see #getName()
+     * @see #getSession()
+     */
+    public HttpSessionBindingEvent(HttpSession session, String name) {
+        super(session);
+        this.name = name;
+        this.value = null;
+    }
+
+    /**
+     * Constructs an event that notifies an object that it has been bound to or
+     * unbound from a session. To receive the event, the object must implement
+     * {@link HttpSessionBindingListener}.
+     *
+     * @param session
+     *            the session to which the object is bound or unbound
+     * @param name
+     *            the name with which the object is bound or unbound
+     * @param value
+     *            the object that is bound or unbound
+     * @see #getName()
+     * @see #getSession()
+     * @see #getValue()
+     */
+    public HttpSessionBindingEvent(HttpSession session, String name,
+            Object value) {
+        super(session);
+        this.name = name;
+        this.value = value;
+    }
+
+    /**
+     * Get the session that changed.
+     * @return The session that changed
+     */
+    @Override
+    public HttpSession getSession() {
+        return super.getSession();
+    }
+
+    /**
+     * Returns the name with which the attribute is bound to or unbound from the
+     * session.
+     *
+     * @return a string specifying the name with which the object is bound to or
+     *         unbound from the session
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Returns the value of the attribute that has been added, removed or
+     * replaced.
+     *
+     * @return If the attribute was added (or bound), this is the value of the
+     *         attribute. If the attribute was removed (or unbound), this is the
+     *         value of the removed attribute. If the attribute was replaced,
+     *         this is the old value of the attribute.
+     *
+     * @since 2.3
+     */
+    public Object getValue() {
+        return this.value;
+    }
+}

java/javax/servlet/http/HttpSessionBindingListener.java

@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.http;
+
+import java.util.EventListener;
+
+/**
+ * Causes an object to be notified when it is bound to or unbound from a
+ * session. The object is notified by an {@link HttpSessionBindingEvent} object.
+ * This may be as a result of a servlet programmer explicitly unbinding an
+ * attribute from a session, due to a session being invalidated, or due to a
+ * session timing out.
+ *
+ * @see HttpSession
+ * @see HttpSessionBindingEvent
+ */
+public interface HttpSessionBindingListener extends EventListener {
+
+    /**
+     * Notifies the object that it is being bound to a session and identifies
+     * the session.
+     *
+     * @param event
+     *            the event that identifies the session
+     * @see #valueUnbound
+     */
+    public void valueBound(HttpSessionBindingEvent event);
+
+    /**
+     * Notifies the object that it is being unbound from a session and
+     * identifies the session.
+     *
+     * @param event
+     *            the event that identifies the session
+     * @see #valueBound
+     */
+    public void valueUnbound(HttpSessionBindingEvent event);
+}

java/javax/servlet/http/HttpSessionContext.java

@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.http;
+
+import java.util.Enumeration;
+
+/**
+ * Do not use.
+ * @deprecated As of Java(tm) Servlet API 2.1 for security reasons, with no
+ *             replacement. This interface will be removed in a future version
+ *             of this API.
+ * @see HttpSession
+ * @see HttpSessionBindingEvent
+ * @see HttpSessionBindingListener
+ */
+@SuppressWarnings("dep-ann")
+// Spec API does not use @Deprecated
+public interface HttpSessionContext {
+
+    /**
+     * Do not use.
+     * @param sessionId Ignored
+     * @return Always <code>null</code>
+     * @deprecated As of Java Servlet API 2.1 with no replacement. This method
+     *             must return null and will be removed in a future version of
+     *             this API.
+     */
+    // Spec API does not use @Deprecated
+    public HttpSession getSession(String sessionId);
+
+    /**
+     * Do not use.
+     * @return Always an empty Enumeration
+     * @deprecated As of Java Servlet API 2.1 with no replacement. This method
+     *             must return an empty <code>Enumeration</code> and will be
+     *             removed in a future version of this API.
+     */
+    // Spec API does not use @Deprecated
+    public Enumeration<String> getIds();
+}

java/javax/servlet/http/HttpSessionEvent.java

@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+/**
+ * This is the class representing event notifications for changes to sessions
+ * within a web application.
+ *
+ * @since v 2.3
+ */
+public class HttpSessionEvent extends java.util.EventObject {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Construct a session event from the given source.
+     *
+     * @param source    The HTTP session where the change took place
+     */
+    public HttpSessionEvent(HttpSession source) {
+        super(source);
+    }
+
+    /**
+     * Get the session that changed.
+     *
+     * @return The session that changed
+     */
+    public HttpSession getSession() {
+        return (HttpSession) super.getSource();
+    }
+}

java/javax/servlet/http/HttpSessionIdListener.java

@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.util.EventListener;
+
+/**
+ * Implementations of this interface are notified when an {@link HttpSession}'s
+ * ID changes. To receive notification events, the implementation class must be
+ * configured in the deployment descriptor for the web application, annotated
+ * with {@link javax.servlet.annotation.WebListener} or registered by calling an
+ * addListener method on the {@link javax.servlet.ServletContext}.
+ *
+ * @see HttpSessionEvent
+ * @see HttpServletRequest#changeSessionId()
+ * @since Servlet 3.1
+ */
+public interface HttpSessionIdListener extends EventListener {
+
+    /**
+     * Notification that a session ID has been changed.
+     *
+     * @param se the notification event
+     * @param oldSessionId the old session ID
+     */
+    public void sessionIdChanged(HttpSessionEvent se, String oldSessionId);
+}

java/javax/servlet/http/HttpSessionListener.java

@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.util.EventListener;
+
+/**
+ * Implementations of this interface are notified of changes to the list of
+ * active sessions in a web application. To receive notification events, the
+ * implementation class must be configured in the deployment descriptor for the
+ * web application.
+ *
+ * @see HttpSessionEvent
+ * @since v 2.3
+ */
+public interface HttpSessionListener extends EventListener {
+
+    /**
+     * Notification that a session was created.
+     *
+     * @param se
+     *            the notification event
+     */
+    public void sessionCreated(HttpSessionEvent se);
+
+    /**
+     * Notification that a session is about to be invalidated.
+     *
+     * @param se
+     *            the notification event
+     */
+    public void sessionDestroyed(HttpSessionEvent se);
+}

java/javax/servlet/http/HttpUpgradeHandler.java

@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+/**
+ * Interface between the HTTP upgrade process and the new protocol.
+ *
+ * @since Servlet 3.1
+ */
+public interface HttpUpgradeHandler {
+
+    /**
+     * This method is called once the request/response pair where
+     * {@link HttpServletRequest#upgrade(Class)} is called has completed
+     * processing and is the point where control of the connection passes from
+     * the container to the {@link HttpUpgradeHandler}.
+     *
+     * @param connection    The connection that has been upgraded
+     *
+     * @since Servlet 3.1
+     */
+    void init(WebConnection connection);
+
+    /**
+     * This method is called after the upgraded connection has been closed.
+     */
+    void destroy();
+}

java/javax/servlet/http/HttpUtils.java

@@ -0,0 +1,281 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.util.Hashtable;
+import java.util.ResourceBundle;
+import java.util.StringTokenizer;
+
+import javax.servlet.ServletInputStream;
+
+/**
+ * @deprecated            As of Java(tm) Servlet API 2.3.
+ *                        These methods were only useful
+ *                        with the default encoding and have been moved
+ *                        to the request interfaces.
+ */
+@SuppressWarnings("dep-ann") // Spec API does not use @Deprecated
+public class HttpUtils {
+
+    private static final String LSTRING_FILE =
+        "javax.servlet.http.LocalStrings";
+    private static final ResourceBundle lStrings =
+        ResourceBundle.getBundle(LSTRING_FILE);
+
+
+    /**
+     * Constructs an empty <code>HttpUtils</code> object.
+     *
+     */
+    public HttpUtils() {
+        // NOOP
+    }
+
+
+    /**
+     *
+     * Parses a query string passed from the client to the
+     * server and builds a <code>HashTable</code> object
+     * with key-value pairs.
+     * The query string should be in the form of a string
+     * packaged by the GET or POST method, that is, it
+     * should have key-value pairs in the form <i>key=value</i>,
+     * with each pair separated from the next by a &amp; character.
+     *
+     * <p>A key can appear more than once in the query string
+     * with different values. However, the key appears only once in
+     * the hashtable, with its value being
+     * an array of strings containing the multiple values sent
+     * by the query string.
+     *
+     * <p>The keys and values in the hashtable are stored in their
+     * decoded form, so
+     * any + characters are converted to spaces, and characters
+     * sent in hexadecimal notation (like <i>%xx</i>) are
+     * converted to ASCII characters.
+     *
+     * @param s                a string containing the query to be parsed
+     *
+     * @return                a <code>HashTable</code> object built
+     *                         from the parsed key-value pairs
+     *
+     * @exception IllegalArgumentException        if the query string
+     *                                                is invalid
+     *
+     */
+    public static Hashtable<String,String[]> parseQueryString(String s) {
+
+        String valArray[] = null;
+
+        if (s == null) {
+            throw new IllegalArgumentException();
+        }
+        Hashtable<String,String[]> ht = new Hashtable<>();
+        StringBuilder sb = new StringBuilder();
+        StringTokenizer st = new StringTokenizer(s, "&");
+        while (st.hasMoreTokens()) {
+            String pair = st.nextToken();
+            int pos = pair.indexOf('=');
+            if (pos == -1) {
+                // XXX
+                // should give more detail about the illegal argument
+                throw new IllegalArgumentException();
+            }
+            String key = parseName(pair.substring(0, pos), sb);
+            String val = parseName(pair.substring(pos+1, pair.length()), sb);
+            if (ht.containsKey(key)) {
+                String oldVals[] = ht.get(key);
+                valArray = new String[oldVals.length + 1];
+                for (int i = 0; i < oldVals.length; i++)
+                    valArray[i] = oldVals[i];
+                valArray[oldVals.length] = val;
+            } else {
+                valArray = new String[1];
+                valArray[0] = val;
+            }
+            ht.put(key, valArray);
+        }
+        return ht;
+    }
+
+
+    /**
+     *
+     * Parses data from an HTML form that the client sends to
+     * the server using the HTTP POST method and the
+     * <i>application/x-www-form-urlencoded</i> MIME type.
+     *
+     * <p>The data sent by the POST method contains key-value
+     * pairs. A key can appear more than once in the POST data
+     * with different values. However, the key appears only once in
+     * the hashtable, with its value being
+     * an array of strings containing the multiple values sent
+     * by the POST method.
+     *
+     * <p>The keys and values in the hashtable are stored in their
+     * decoded form, so
+     * any + characters are converted to spaces, and characters
+     * sent in hexadecimal notation (like <i>%xx</i>) are
+     * converted to ASCII characters.
+     *
+     *
+     *
+     * @param len        an integer specifying the length,
+     *                        in characters, of the
+     *                        <code>ServletInputStream</code>
+     *                        object that is also passed to this
+     *                        method
+     *
+     * @param in        the <code>ServletInputStream</code>
+     *                        object that contains the data sent
+     *                        from the client
+     *
+     * @return                a <code>HashTable</code> object built
+     *                        from the parsed key-value pairs
+     *
+     *
+     * @exception IllegalArgumentException        if the data
+     *                        sent by the POST method is invalid
+     *
+     */
+    public static Hashtable<String,String[]> parsePostData(int len,
+                                          ServletInputStream in) {
+        // XXX
+        // should a length of 0 be an IllegalArgumentException
+
+        // cheap hack to return an empty hash
+        if (len <=0)
+            return new Hashtable<>();
+
+        if (in == null) {
+            throw new IllegalArgumentException();
+        }
+
+        // Make sure we read the entire POSTed body.
+        byte[] postedBytes = new byte [len];
+        try {
+            int offset = 0;
+
+            do {
+                int inputLen = in.read (postedBytes, offset, len - offset);
+                if (inputLen <= 0) {
+                    String msg = lStrings.getString("err.io.short_read");
+                    throw new IllegalArgumentException (msg);
+                }
+                offset += inputLen;
+            } while ((len - offset) > 0);
+
+        } catch (IOException e) {
+            throw new IllegalArgumentException(e.getMessage(), e);
+        }
+
+        // XXX we shouldn't assume that the only kind of POST body
+        // is FORM data encoded using ASCII or ISO Latin/1 ... or
+        // that the body should always be treated as FORM data.
+        try {
+            String postedBody = new String(postedBytes, 0, len, "8859_1");
+            return parseQueryString(postedBody);
+        } catch (java.io.UnsupportedEncodingException e) {
+            // XXX function should accept an encoding parameter & throw this
+            // exception.  Otherwise throw something expected.
+            throw new IllegalArgumentException(e.getMessage(), e);
+        }
+    }
+
+
+    /*
+     * Parse a name in the query string.
+     */
+    private static String parseName(String s, StringBuilder sb) {
+        sb.setLength(0);
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            switch (c) {
+            case '+':
+                sb.append(' ');
+                break;
+            case '%':
+                try {
+                    sb.append((char) Integer.parseInt(s.substring(i+1, i+3),
+                                                      16));
+                    i += 2;
+                } catch (NumberFormatException e) {
+                    // XXX
+                    // need to be more specific about illegal arg
+                    throw new IllegalArgumentException();
+                } catch (StringIndexOutOfBoundsException e) {
+                    String rest  = s.substring(i);
+                    sb.append(rest);
+                    if (rest.length()==2)
+                        i++;
+                }
+
+                break;
+            default:
+                sb.append(c);
+                break;
+            }
+        }
+        return sb.toString();
+    }
+
+
+    /**
+     *
+     * Reconstructs the URL the client used to make the request,
+     * using information in the <code>HttpServletRequest</code> object.
+     * The returned URL contains a protocol, server name, port
+     * number, and server path, but it does not include query
+     * string parameters.
+     *
+     * <p>Because this method returns a <code>StringBuffer</code>,
+     * not a string, you can modify the URL easily, for example,
+     * to append query parameters.
+     *
+     * <p>This method is useful for creating redirect messages
+     * and for reporting errors.
+     *
+     * @param req        a <code>HttpServletRequest</code> object
+     *                        containing the client's request
+     *
+     * @return                a <code>StringBuffer</code> object containing
+     *                        the reconstructed URL
+     *
+     */
+    public static StringBuffer getRequestURL (HttpServletRequest req) {
+        StringBuffer url = new StringBuffer ();
+        String scheme = req.getScheme ();
+        int port = req.getServerPort ();
+        String urlPath = req.getRequestURI();
+
+        url.append (scheme);                // http, https
+        url.append ("://");
+        url.append (req.getServerName ());
+        if ((scheme.equals ("http") && port != 80) || (scheme.equals ("https") && port != 443)) {
+            url.append (':');
+            url.append (req.getServerPort ());
+        }
+
+        url.append(urlPath);
+        return url;
+    }
+}
+
+
+

java/javax/servlet/http/LocalStrings.properties

@@ -0,0 +1,27 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.cookie_name_blank=Cookie name may not be null or zero length
+err.cookie_name_is_token=Cookie name [{0}] is a reserved token
+err.io.indexOutOfBounds=Invalid offset [{0}] and / or length [{1}] specified for array of size [{2}]
+err.io.nullArray=Null passed for byte array in write method
+err.io.short_read=Short Read
+
+http.method_delete_not_supported=HTTP method DELETE is not supported by this URL
+http.method_get_not_supported=HTTP method GET is not supported by this URL
+http.method_not_implemented=Method [{0}] is not implemented by this Servlet for this URI
+http.method_post_not_supported=HTTP method POST is not supported by this URL
+http.method_put_not_supported=HTTP method PUT is not supported by this URL
+http.non_http=Non HTTP request or response

java/javax/servlet/http/LocalStrings_de.properties

@@ -0,0 +1,16 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+http.method_not_implemented=Methode [{0}] ist von diesem Servlet für diese URI nicht implementiert

java/javax/servlet/http/LocalStrings_es.properties

@@ -0,0 +1,25 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.cookie_name_blank=El nombre del Cookie no puede ser nulo o de longitud cero
+err.cookie_name_is_token=El nombre de Cookie [{0}] es una palabra reservada
+err.io.nullArray=Se pasó un valor Null para el arreglo byte en el método de escritura
+err.io.short_read=Lectura Corta
+
+http.method_delete_not_supported=El Metodo HTTP DELETE no es soportado por esta URL
+http.method_get_not_supported=El Metodo HTTP GET no está soportado por esta URL
+http.method_not_implemented=El Metodo [{0}] no esta implementado por este servlet para esta URI
+http.method_post_not_supported=El Metodo HTTP POST no está soportado por esta URL
+http.method_put_not_supported=El Metodo HTTP PUT no está soportado por esta URL

java/javax/servlet/http/LocalStrings_fr.properties

@@ -0,0 +1,27 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.cookie_name_blank=Le nom de cookie ne doit pas être null ou vide
+err.cookie_name_is_token=Le nom de cookie [{0}] est un "token" réservé
+err.io.indexOutOfBounds=L''offset [{0}] et/ou la longueur [{1}] spécifiés pour la taille du tableau [{2}] sont invalides
+err.io.nullArray=Null a été passée comme tableau d'octets à la méthode d'écriture
+err.io.short_read=Lecture partielle
+
+http.method_delete_not_supported=La méthode HTTP DELETE n'est pas supportée par cette URL
+http.method_get_not_supported=La méthode HTTP GET n'est pas supportée par cette URL
+http.method_not_implemented=Le méthode [{0}] n''est pas implémentée par ce Servlet pour cette URI
+http.method_post_not_supported=La méthode HTTP POST n'est pas supportée par cette URL
+http.method_put_not_supported=La méthode HTTP PUT n'est pas supportée par cette URL
+http.non_http=Requête ou réponse non HTTP

java/javax/servlet/http/LocalStrings_ja.properties

@@ -0,0 +1,27 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.cookie_name_blank=Cookie名はnullまたは長さゼロであってはなりません.\n
+err.cookie_name_is_token=クッキー名 [{0}] は予約済のトークンです。
+err.io.indexOutOfBounds=サイズ[{2}]の配列に指定されたオフセット[{0}]または長さ[{1}]が無効です。
+err.io.nullArray=write メソッドに渡されたバイト配列は null です。
+err.io.short_read=読み込みがすぐに終わりました。
+
+http.method_delete_not_supported=HTTPのDELETEメソッドは、このURLではサポートされていません。
+http.method_get_not_supported=HTTPのGETメソッドは、このURLではサポートされていません。
+http.method_not_implemented=メソッド [{0}] はRFC 2068には定義されておらず、サーブレットAPIではサポートされません。
+http.method_post_not_supported=HTTPのPOSTメソッドは、このURLではサポートされていません。
+http.method_put_not_supported=HTTPのPUTメソッドは、このURLではサポートされていません。
+http.non_http=リクエストが HTTP リクエストではない、あるいはレスポンスが HTTP レスポンスではありません。

java/javax/servlet/http/LocalStrings_ko.properties

@@ -0,0 +1,27 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.cookie_name_blank=쿠키 이름이 널이거나 길이가 0인 문자열이어서는 안됩니다.
+err.cookie_name_is_token=쿠키 이름 [{0}]은(는) 예약된 토큰입니다.
+err.io.indexOutOfBounds=크기 [{2}]인 배열에 대하여, 유효하지 않은 offset [{0}] 그리고/또는 길이 [{1}].
+err.io.nullArray=write 메소드에 널인 바이트 배열이 전달되었습니다.
+err.io.short_read=Short Read
+
+http.method_delete_not_supported=HTTP 메소드 DELETE는 이 URL에 의해 지원되지 않습니다.
+http.method_get_not_supported=HTTP 메소드 GET은 이 URL에 의해 지원되지 않습니다.
+http.method_not_implemented=이 URI를 위한 서블릿은 메소드 [{0}]을(를) 구현하지 않았습니다.
+http.method_post_not_supported=HTTP 메소드인 POST는 이 URL에 의해 지원되지 않습니다.
+http.method_put_not_supported=HTTP 메소드 PUT은 이 URL에 의해 지원되지 않습니다.
+http.non_http=HTTP 요청이 아니거나, HTTP 응답이 아닙니다.

java/javax/servlet/http/LocalStrings_zh_CN.properties

@@ -0,0 +1,25 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+err.cookie_name_blank=Cookie名称不能为null或零长度
+err.io.nullArray=Null在write方法中传递给字节数组
+err.io.short_read=短.读
+
+http.method_delete_not_supported=当前URL不支持HTTP的DELETE方法
+http.method_get_not_supported=此URL不支持Http方法GET
+http.method_not_implemented=这个servlet没有为这个URI实现方法[{0}]
+http.method_post_not_supported=此URL不支持Http方法POST
+http.method_put_not_supported=此URL不支持HTTP方法PUT
+http.non_http=没有HTTP请求或响应

java/javax/servlet/http/Part.java

@@ -0,0 +1,137 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+
+/**
+ * This class represents a part as uploaded to the server as part of a
+ * <code>multipart/form-data</code> request body. The part may represent either
+ * an uploaded file or form data.
+ *
+ * @since Servlet 3.0
+ */
+public interface Part {
+
+    /**
+     * Obtain an <code>InputStream</code> that can be used to retrieve the
+     * contents of the file.
+     *
+     * @return An InputStream for the contents of the file
+     *
+     * @throws IOException if an I/O occurs while obtaining the stream
+     */
+    public InputStream getInputStream() throws IOException;
+
+    /**
+     * Obtain the content type passed by the browser.
+     *
+     * @return The content type passed by the browser or <code>null</code> if
+     *         not defined.
+     */
+    public String getContentType();
+
+    /**
+     * Obtain the name of the field in the multipart form corresponding to this
+     * part.
+     *
+     * @return The name of the field in the multipart form corresponding to this
+     *         part.
+     */
+    public String getName();
+
+    /**
+     * If this part represents an uploaded file, gets the file name submitted
+     * in the upload. Returns {@code null} if no file name is available or if
+     * this part is not a file upload.
+     *
+     * @return the submitted file name or {@code null}.
+     *
+     * @since Servlet 3.1
+     */
+    public String getSubmittedFileName();
+
+    /**
+     * Obtain the size of this part.
+     *
+     * @return The size of the part if bytes
+     */
+    public long getSize();
+
+    /**
+     * A convenience method to write an uploaded part to disk. The client code
+     * is not concerned with whether or not the part is stored in memory, or on
+     * disk in a temporary location. They just want to write the uploaded part
+     * to a file.
+     *
+     *  This method is not guaranteed to succeed if called more than once for
+     *  the same part. This allows a particular implementation to use, for
+     *  example, file renaming, where possible, rather than copying all of the
+     *  underlying data, thus gaining a significant performance benefit.
+     *
+     * @param fileName  The location into which the uploaded part should be
+     *                  stored. Relative locations are relative to {@link
+     *                  javax.servlet.MultipartConfigElement#getLocation()}
+     *
+     * @throws IOException if an I/O occurs while attempting to write the part
+     */
+    public void write(String fileName) throws IOException;
+
+    /**
+     * Deletes the underlying storage for a part, including deleting any
+     * associated temporary disk file. Although the container will delete this
+     * storage automatically this method can be used to ensure that this is done
+     * at an earlier time, thus preserving system resources.
+     * <p>
+     * Containers are only required to delete the associated storage when the
+     * Part instance is garbage collected. Apache Tomcat will delete the
+     * associated storage when the associated request has finished processing.
+     * Behaviour of other containers may be different.
+     *
+     * @throws IOException if an I/O occurs while attempting to delete the part
+     */
+    public void delete() throws IOException;
+
+    /**
+     * Obtains the value of the specified part header as a String. If there are
+     * multiple headers with the same name, this method returns the first header
+     * in the part. The header name is case insensitive.
+     *
+     * @param name  Header name
+     * @return      The header value or <code>null</code> if the header is not
+     *              present
+     */
+    public String getHeader(String name);
+
+    /**
+     * Obtain all the values of the specified part header.
+     * @param name The name of the header of interest. The header name is case
+     *             insensitive.
+     * @return All the values of the specified part header. If the part did not
+     *         include any headers of the specified name, this method returns an
+     *         empty Collection.
+     */
+    public Collection<String> getHeaders(String name);
+
+    /**
+     * Get the header names provided for this part.
+     * @return a Collection of all the header names provided for this part.
+     */
+    public Collection<String> getHeaderNames();
+}

java/javax/servlet/http/WebConnection.java

@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.http;
+
+import java.io.IOException;
+
+import javax.servlet.ServletInputStream;
+import javax.servlet.ServletOutputStream;
+
+/**
+ * The interface used by a {@link HttpUpgradeHandler} to interact with an upgraded
+ * HTTP connection.
+ *
+ * @since Servlet 3.1
+ */
+public interface WebConnection extends AutoCloseable {
+
+    /**
+     * Provides access to the {@link ServletInputStream} for reading data from
+     * the client.
+     *
+     * @return the input stream
+     *
+     * @throws IOException If an I/O occurs while obtaining the stream
+     */
+    ServletInputStream getInputStream() throws IOException;
+
+    /**
+     * Provides access to the {@link ServletOutputStream} for writing data to
+     * the client.
+     *
+     * @return the output stream
+     *
+     * @throws IOException If an I/O occurs while obtaining the stream
+     */
+    ServletOutputStream getOutputStream() throws IOException;
+}

java/javax/servlet/http/package.html

@@ -0,0 +1,30 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+</HEAD>
+<BODY BGCOLOR="white">
+
+The javax.servlet.http package contains a number of classes and interfaces
+that describe and define the contracts between a servlet class
+running under the HTTP protocol and the runtime environment provided
+for an instance of such a class by a conforming servlet container.
+
+
+</BODY>
+</HTML>

java/javax/servlet/jsp/ErrorData.java

@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.jsp;
+
+/**
+ * Contains information about an error, for error pages. The information
+ * contained in this instance is meaningless if not used in the context of an
+ * error page. To indicate a JSP is an error page, the page author must set the
+ * isErrorPage attribute of the page directive to "true".
+ *
+ * @see PageContext#getErrorData
+ * @since 2.0
+ */
+public final class ErrorData {
+
+    private final Throwable throwable;
+    private final int statusCode;
+    private final String uri;
+    private final String servletName;
+
+    /**
+     * Creates a new ErrorData object.
+     *
+     * @param throwable
+     *            The Throwable that is the cause of the error
+     * @param statusCode
+     *            The status code of the error
+     * @param uri
+     *            The request URI
+     * @param servletName
+     *            The name of the servlet invoked
+     */
+    public ErrorData(Throwable throwable, int statusCode, String uri,
+            String servletName) {
+        this.throwable = throwable;
+        this.statusCode = statusCode;
+        this.uri = uri;
+        this.servletName = servletName;
+    }
+
+    /**
+     * Returns the Throwable that caused the error.
+     *
+     * @return The Throwable that caused the error
+     */
+    public Throwable getThrowable() {
+        return this.throwable;
+    }
+
+    /**
+     * Returns the status code of the error.
+     *
+     * @return The status code of the error
+     */
+    public int getStatusCode() {
+        return this.statusCode;
+    }
+
+    /**
+     * Returns the request URI.
+     *
+     * @return The request URI
+     */
+    public String getRequestURI() {
+        return this.uri;
+    }
+
+    /**
+     * Returns the name of the servlet invoked.
+     *
+     * @return The name of the servlet invoked
+     */
+    public String getServletName() {
+        return this.servletName;
+    }
+}

java/javax/servlet/jsp/HttpJspPage.java

@@ -0,0 +1,60 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package javax.servlet.jsp;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * The HttpJspPage interface describes the interaction that a JSP Page
+ * Implementation Class must satisfy when using the HTTP protocol.
+ *
+ * <p>
+ * The behaviour is identical to that of the JspPage, except for the signature
+ * of the _jspService method, which is now expressible in the Java type
+ * system and included explicitly in the interface.
+ *
+ * @see JspPage
+ */
+
+public interface HttpJspPage extends JspPage {
+
+    /** The _jspService()method corresponds to the body of the JSP page. This
+     * method is defined automatically by the JSP container and should never
+     * be defined by the JSP page author.
+     * <p>
+     * If a superclass is specified using the extends attribute, that
+     * superclass may choose to perform some actions in its service() method
+     * before or after calling the _jspService() method.  See using the extends
+     * attribute in the JSP_Engine chapter of the JSP specification.
+     *
+     * @param request Provides client request information to the JSP.
+     * @param response Assists the JSP in sending a response to the client.
+     * @throws ServletException Thrown if an error occurred during the
+     *     processing of the JSP and that the container should take
+     *     appropriate action to clean up the request.
+     * @throws IOException Thrown if an error occurred while writing the
+     *     response for this page.
+     */
+    public void _jspService(HttpServletRequest request,
+                            HttpServletResponse response)
+       throws ServletException, IOException;
+}

java/javax/servlet/jsp/JspApplicationContext.java

@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.jsp;
+
+import javax.el.ELContextListener;
+import javax.el.ELResolver;
+import javax.el.ExpressionFactory;
+
+/**
+ * <p>
+ * Stores <i>application</i>-scoped information for the JSP container.
+ * </p>
+ *
+ * @since 2.1
+ */
+public interface JspApplicationContext {
+
+    /**
+     * Registers an <code>ELContextListener</code> that will be notified
+     * whenever a new <code>ELContext</code> is created.
+     * <p>
+     * At the very least, any <code>ELContext</code> instantiated will have
+     * reference to the <code>JspContext</code> under
+     * <code>JspContext.class</code>.
+     *
+     * @param listener The listener to add
+     */
+    public void addELContextListener(ELContextListener listener);
+
+    /**
+     * <p>
+     * Adds an <code>ELResolver</code> to the chain of EL variable and property
+     * management within JSP pages and Tag files.
+     * </p>
+     * <p>
+     * JSP has a default set of ELResolvers to chain for all EL evaluation:
+     * </p>
+     * <ul>
+     * <li><code>ImplicitObjectELResolver</code></li>
+     * <li><code>ELResolver</code> instances registered with this method</li>
+     * <li><code>MapELResolver</code></li>
+     * <li><code>ListELResolver</code></li>
+     * <li><code>ArrayELResolver</code></li>
+     * <li><code>BeanELResolver</code></li>
+     * <li><code>ScopedAttributeELResolver</code></li>
+     * </ul>
+     *
+     * @param resolver
+     *            an additional resolver
+     * @throws IllegalStateException
+     *             if called after the application's
+     *             <code>ServletContextListeners</code> have been initialized.
+     */
+    public void addELResolver(ELResolver resolver) throws IllegalStateException;
+
+    /**
+     * <p>
+     * Returns the JSP container's <code>ExpressionFactory</code> implementation
+     * for EL use.
+     * </p>
+     *
+     * @return an <code>ExpressionFactory</code> implementation
+     */
+    public ExpressionFactory getExpressionFactory();
+
+}

java/javax/servlet/jsp/JspContext.java

@@ -0,0 +1,282 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet.jsp;
+
+import java.util.Enumeration;
+
+import javax.el.ELContext;
+
+/**
+ * <p>
+ * <code>JspContext</code> serves as the base class for the
+ * PageContext class and abstracts all information that is not specific
+ * to servlets.  This allows for Simple Tag Extensions to be used
+ * outside of the context of a request/response Servlet.
+ * <p>
+ * The JspContext provides a number of facilities to the
+ * page/component author and page implementor, including:
+ * <ul>
+ * <li>a single API to manage the various scoped namespaces
+ * <li>a mechanism to obtain the JspWriter for output
+ * <li>a mechanism to expose page directive attributes to the
+ *     scripting environment
+ * </ul>
+ *
+ * <p><B>Methods Intended for Container Generated Code</B>
+ * <p>
+ * The following methods enable the <B>management of nested</B> JspWriter
+ * streams to implement Tag Extensions: <code>pushBody()</code> and
+ * <code>popBody()</code>
+ *
+ * <p><B>Methods Intended for JSP authors</B>
+ * <p>
+ * Some methods provide <B>uniform access</B> to the diverse objects
+ * representing scopes.
+ * The implementation must use the underlying machinery
+ * corresponding to that scope, so information can be passed back and
+ * forth between the underlying environment (e.g. Servlets) and JSP pages.
+ * The methods are:
+ * <code>setAttribute()</code>,  <code>getAttribute()</code>,
+ * <code>findAttribute()</code>,  <code>removeAttribute()</code>,
+ * <code>getAttributesScope()</code> and
+ * <code>getAttributeNamesInScope()</code>.
+ *
+ * <p>
+ * The following methods provide <B>convenient access</B> to implicit objects:
+ * <code>getOut()</code>
+ *
+ * <p>
+ * The following methods provide <B>programmatic access</b> to the
+ * Expression Language evaluator:
+ * <code>getExpressionEvaluator()</code>, <code>getVariableResolver()</code>
+ *
+ * @since 2.0
+ */
+
+public abstract class JspContext {
+
+    /**
+     * Sole constructor. (For invocation by subclass constructors,
+     * typically implicit.)
+     */
+    public JspContext() {
+        // NOOP by default
+    }
+
+    /**
+     * Register the name and value specified with page scope semantics.
+     * If the value passed in is <code>null</code>, this has the same
+     * effect as calling
+     * <code>removeAttribute( name, PageContext.PAGE_SCOPE )</code>.
+     *
+     * @param name the name of the attribute to set
+     * @param value the value to associate with the name, or null if the
+     *     attribute is to be removed from the page scope.
+     * @throws NullPointerException if the name is null
+     */
+
+    public abstract void setAttribute(String name, Object value);
+
+    /**
+     * Register the name and value specified with appropriate
+     * scope semantics.  If the value passed in is <code>null</code>,
+     * this has the same effect as calling
+     * <code>removeAttribute( name, scope )</code>.
+     *
+     * @param name the name of the attribute to set
+     * @param value the object to associate with the name, or null if
+     *     the attribute is to be removed from the specified scope.
+     * @param scope the scope with which to associate the name/object
+     *
+     * @throws NullPointerException if the name is null
+     * @throws IllegalArgumentException if the scope is invalid
+     * @throws IllegalStateException if the scope is
+     *     PageContext.SESSION_SCOPE but the page that was requested
+     *     does not participate in a session or the session has been
+     *     invalidated.
+     */
+
+    public abstract void setAttribute(String name, Object value, int scope);
+
+    /**
+     * Returns the object associated with the name in the page scope or null
+     * if not found.
+     *
+     * @param name the name of the attribute to get
+     * @return the object associated with the name in the page scope
+     *     or null if not found.
+     *
+     * @throws NullPointerException if the name is null
+     */
+
+    public abstract Object getAttribute(String name);
+
+    /**
+     * Return the object associated with the name in the specified
+     * scope or null if not found.
+     *
+     * @param name the name of the attribute to set
+     * @param scope the scope with which to associate the name/object
+     * @return the object associated with the name in the specified
+     *     scope or null if not found.
+     *
+     * @throws NullPointerException if the name is null
+     * @throws IllegalArgumentException if the scope is invalid
+     * @throws IllegalStateException if the scope is
+     *     PageContext.SESSION_SCOPE but the page that was requested
+     *     does not participate in a session or the session has been
+     *     invalidated.
+     */
+
+    public abstract Object getAttribute(String name, int scope);
+
+    /**
+     * Searches for the named attribute in page, request, session (if valid),
+     * and application scope(s) in order and returns the value associated or
+     * null.
+     *
+     * @param name the name of the attribute to search for
+     * @return the value associated or null
+     * @throws NullPointerException if the name is null
+     */
+
+    public abstract Object findAttribute(String name);
+
+    /**
+     * Remove the object reference associated with the given name
+     * from all scopes.  Does nothing if there is no such object.
+     *
+     * @param name The name of the object to remove.
+     * @throws NullPointerException if the name is null
+     */
+
+    public abstract void removeAttribute(String name);
+
+    /**
+     * Remove the object reference associated with the specified name
+     * in the given scope.  Does nothing if there is no such object.
+     *
+     * @param name The name of the object to remove.
+     * @param scope The scope where to look.
+     * @throws IllegalArgumentException if the scope is invalid
+     * @throws IllegalStateException if the scope is
+     *     PageContext.SESSION_SCOPE but the page that was requested
+     *     does not participate in a session or the session has been
+     *     invalidated.
+     * @throws NullPointerException if the name is null
+     */
+
+    public abstract void removeAttribute(String name, int scope);
+
+    /**
+     * Get the scope where a given attribute is defined.
+     *
+     * @param name the name of the attribute to return the scope for
+     * @return the scope of the object associated with the name specified or 0
+     * @throws NullPointerException if the name is null
+     */
+
+    public abstract int getAttributesScope(String name);
+
+    /**
+     * Enumerate all the attributes in a given scope.
+     *
+     * @param scope the scope to enumerate all the attributes for
+     * @return an enumeration of names (java.lang.String) of all the
+     *     attributes the specified scope
+     * @throws IllegalArgumentException if the scope is invalid
+     * @throws IllegalStateException if the scope is
+     *     PageContext.SESSION_SCOPE but the page that was requested
+     *     does not participate in a session or the session has been
+     *     invalidated.
+     */
+
+    public abstract Enumeration<String> getAttributeNamesInScope(int scope);
+
+    /**
+     * The current value of the out object (a JspWriter).
+     *
+     * @return the current JspWriter stream being used for client response
+     */
+    public abstract JspWriter getOut();
+
+    /**
+     * Provides programmatic access to the ExpressionEvaluator.
+     * The JSP Container must return a valid instance of an
+     * ExpressionEvaluator that can parse EL expressions.
+     *
+     * @return A valid instance of an ExpressionEvaluator.
+     * @since 2.0
+     * @deprecated As of JSP 2.1, replaced by
+     *             JspApplicationContext.getExpressionFactory()
+     */
+    @SuppressWarnings("dep-ann") // TCK signature test fails with annotation
+    public abstract javax.servlet.jsp.el.ExpressionEvaluator getExpressionEvaluator();
+
+
+    public abstract ELContext getELContext();
+
+    /**
+     * Returns an instance of a VariableResolver that provides access to the
+     * implicit objects specified in the JSP specification using this JspContext
+     * as the context object.
+     *
+     * @return A valid instance of a VariableResolver.
+     * @since 2.0
+     * @deprecated As of JSP 2.1,
+     *             replaced by javax.el.ELContext.getELResolver()
+     *             which can be obtained by
+     *             jspContext.getELContext().getELResolver()
+     */
+    @SuppressWarnings("dep-ann") // TCK signature test fails with annotation
+    public abstract javax.servlet.jsp.el.VariableResolver getVariableResolver();
+
+    /**
+     * Return a new JspWriter object that sends output to the
+     * provided Writer.  Saves the current "out" JspWriter,
+     * and updates the value of the "out" attribute in the
+     * page scope attribute namespace of the JspContext.
+     * <p>The returned JspWriter must implement all methods and
+     * behave as though it were unbuffered.  More specifically:
+     * </p>
+     * <ul>
+     *   <li>clear() must throw an IOException</li>
+     *   <li>clearBuffer() does nothing</li>
+     *   <li>getBufferSize() always returns 0</li>
+     *   <li>getRemaining() always returns 0</li>
+     * </ul>
+     *
+     * @param writer The Writer for the returned JspWriter to send
+     *     output to.
+     * @return a new JspWriter that writes to the given Writer.
+     * @since 2.0
+     */
+    public JspWriter pushBody( java.io.Writer writer ) {
+        return null; // XXX to implement
+    }
+
+    /**
+     * Return the previous JspWriter "out" saved by the matching
+     * pushBody(), and update the value of the "out" attribute in
+     * the page scope attribute namespace of the JspContext.
+     *
+     * @return the saved JspWriter.
+     */
+    public JspWriter popBody() {
+        return null; // XXX to implement
+    }
+}

java/javax/servlet/jsp/JspEngineInfo.java

@@ -0,0 +1,49 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet.jsp;
+
+/**
+ * The JspEngineInfo is an abstract class that provides information on the
+ * current JSP engine.
+ */
+
+public abstract class JspEngineInfo {
+
+    /**
+     * Sole constructor. (For invocation by subclass constructors,
+     * typically implicit.)
+     */
+    public JspEngineInfo() {
+        // NOOP by default
+    }
+
+    /**
+     * Return the version number of the JSP specification that is supported by
+     * this JSP engine.
+     * <p>
+     * Specification version numbers that consists of positive decimal integers
+     * separated by periods ".", for example, "2.0" or "1.2.3.4.5.6.7".
+     * This allows an extensible number to be used to
+     * represent major, minor, micro, etc versions.
+     * The version number must begin with a number.
+     * </p>
+     *
+     * @return the specification version, null is returned if it is not known
+     */
+
+    public abstract String getSpecificationVersion();
+}

java/javax/servlet/jsp/JspException.java

@@ -0,0 +1,101 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet.jsp;
+
+/**
+ * A generic exception known to the JSP engine; uncaught
+ * JspExceptions will result in an invocation of the errorpage
+ * machinery.
+ */
+public class JspException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+
+    /**
+     * Construct a JspException.
+     */
+    public JspException() {
+        // NOOP
+    }
+
+
+    /**
+     * Constructs a new JSP exception with the
+     * specified message. The message can be written
+     * to the server log and/or displayed for the user.
+     *
+     * @param msg   a <code>String</code> specifying the text of the exception
+     *              message
+     */
+    public JspException(String msg) {
+        super(msg);
+    }
+
+
+    /**
+     * Constructs a new <code>JSPException</code> with the specified detail
+     * message and cause. The cause is saved for later retrieval by the
+     * <code>java.lang.Throwable.getCause()</code> and {@link #getRootCause()}
+     * methods.
+     *
+     * @see java.lang.Exception#Exception(String, Throwable)
+     *
+     * @param message       a <code>String</code> containing the text of the
+     *                      exception message
+     *
+     * @param cause         the <code>Throwable</code> exception that
+     *                      interfered with the JSP's normal operation,
+     *                      making this JSP exception necessary
+     */
+
+    public JspException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+
+    /**
+     * Constructs a new <code>JSPException</code> with the specified cause.
+     * The cause is saved for later retrieval by the
+     * <code>java.lang.Throwable.getCause()</code> and {@link #getRootCause()}
+     * methods.
+     *
+     * @see java.lang.Exception#Exception(Throwable)
+     *
+     * @param cause         the <code>Throwable</code> exception that
+     *                      interfered with the JSP's normal operation, making
+     *                      the JSP exception necessary
+     */
+
+    public JspException(Throwable cause) {
+        super(cause);
+    }
+
+
+    /**
+     * Returns the exception that caused this JSP exception.
+     *
+     * @return  the <code>Throwable</code> that caused this JSP exception
+     *
+     * @deprecated As of JSP 2.1, replaced by
+     * <code>java.lang.Throwable.getCause()</code>
+     */
+    @SuppressWarnings("dep-ann") // TCK signature test fails with annotation
+    public Throwable getRootCause() {
+        return getCause();
+    }
+}

java/javax/servlet/jsp/JspFactory.java

@@ -0,0 +1,157 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet.jsp;
+
+import javax.servlet.Servlet;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+/**
+ * <p>
+ * The JspFactory is an abstract class that defines a number of factory
+ * methods available to a JSP page at runtime for the purposes of creating
+ * instances of various interfaces and classes used to support the JSP
+ * implementation.
+ * <p>
+ * A conformant JSP Engine implementation will, during it's initialization
+ * instantiate an implementation dependent subclass of this class, and make
+ * it globally available for use by JSP implementation classes by registering
+ * the instance created with this class via the
+ * static <code> setDefaultFactory() </code> method.
+ * <p>
+ * The PageContext and the JspEngineInfo classes are the only
+ * implementation-dependent classes that can be created from the factory.
+ * <p>
+ * JspFactory objects should not be used by JSP page authors.
+ */
+
+public abstract class JspFactory {
+
+    private static volatile JspFactory deflt = null;
+
+    /**
+     * Sole constructor. (For invocation by subclass constructors,
+     * typically implicit.)
+     */
+    public JspFactory() {
+        // NOOP by default
+    }
+
+    /**
+     * <p>
+     * set the default factory for this implementation. It is illegal for
+     * any principal other than the JSP Engine runtime to call this method.
+     * </p>
+     *
+     * @param deflt        The default factory implementation
+     */
+
+    public static void setDefaultFactory(JspFactory deflt) {
+        JspFactory.deflt = deflt;
+    }
+
+    /**
+     * Returns the default factory for this implementation.
+     *
+     * @return the default factory for this implementation
+     */
+
+    public static JspFactory getDefaultFactory() {
+        return deflt;
+    }
+
+    /**
+     * <p>
+     * obtains an instance of an implementation dependent
+     * javax.servlet.jsp.PageContext abstract class for the calling Servlet
+     * and currently pending request and response.
+     * </p>
+     *
+     * <p>
+     * This method is typically called early in the processing of the
+     * _jspService() method of a JSP implementation class in order to
+     * obtain a PageContext object for the request being processed.
+     * </p>
+     * <p>
+     * Invoking this method shall result in the PageContext.initialize()
+     * method being invoked. The PageContext returned is properly initialized.
+     * </p>
+     * <p>
+     * All PageContext objects obtained via this method shall be released
+     * by invoking releasePageContext().
+     * </p>
+     *
+     * @param servlet      the requesting servlet
+     * @param request      the current request pending on the servlet
+     * @param response     the current response pending on the servlet
+     * @param errorPageURL the URL of the error page for the requesting JSP, or
+     *                         null
+     * @param needsSession true if the JSP participates in a session
+     * @param buffer       size of buffer in bytes, {@link JspWriter#NO_BUFFER}
+     *                         if no buffer, {@link JspWriter#DEFAULT_BUFFER}
+     *                         if implementation default.
+     * @param autoflush    should the buffer autoflush to the output stream on
+     *                         buffer overflow, or throw an IOException?
+     *
+     * @return the page context
+     *
+     * @see javax.servlet.jsp.PageContext
+     */
+
+    public abstract PageContext getPageContext(Servlet servlet,
+            ServletRequest request, ServletResponse response,
+            String errorPageURL, boolean needsSession, int buffer,
+            boolean autoflush);
+
+    /**
+     * <p>
+     * called to release a previously allocated PageContext object.
+     * Results in PageContext.release() being invoked.
+     * This method should be invoked prior to returning from the _jspService()
+     * method of a JSP implementation class.
+     * </p>
+     *
+     * @param pc A PageContext previously obtained by getPageContext()
+     */
+    public abstract void releasePageContext(PageContext pc);
+
+    /**
+     * <p>
+     * called to get implementation-specific information on the current JSP
+     * engine.
+     * </p>
+     *
+     * @return a JspEngineInfo object describing the current JSP engine
+     */
+
+    public abstract JspEngineInfo getEngineInfo();
+
+    /**
+     * <p>
+     * Obtain the <code>JspApplicationContext</code> instance that was
+     * associated within the passed <code>ServletContext</code> for this web
+     * application.
+     * </p>
+     *
+     * @param context the current web application's <code>ServletContext</code>
+     * @return <code>JspApplicationContext</code> instance
+     * @since 2.1
+     */
+    public abstract JspApplicationContext getJspApplicationContext(
+            ServletContext context);
+}

java/javax/servlet/jsp/JspPage.java

@@ -0,0 +1,90 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package javax.servlet.jsp;
+
+import javax.servlet.Servlet;
+
+/**
+ * The JspPage interface describes the generic interaction that a JSP Page
+ * Implementation class must satisfy; pages that use the HTTP protocol
+ * are described by the HttpJspPage interface.
+ *
+ * <p><B>Two plus One Methods</B>
+ * <p>
+ * The interface defines a protocol with 3 methods; only two of
+ * them: jspInit() and jspDestroy() are part of this interface as
+ * the signature of the third method: _jspService() depends on
+ * the specific protocol used and cannot be expressed in a generic
+ * way in Java.
+ * <p>
+ * A class implementing this interface is responsible for invoking
+ * the above methods at the appropriate time based on the
+ * corresponding Servlet-based method invocations.
+ * <p>
+ * The jspInit() and jspDestroy() methods can be defined by a JSP
+ * author, but the _jspService() method is defined automatically
+ * by the JSP processor based on the contents of the JSP page.
+ *
+ * <p><B>_jspService()</B>
+ * <p>
+ * The _jspService()method corresponds to the body of the JSP page. This
+ * method is defined automatically by the JSP container and should never
+ * be defined by the JSP page author.
+ * <p>
+ * If a superclass is specified using the extends attribute, that
+ * superclass may choose to perform some actions in its service() method
+ * before or after calling the _jspService() method.  See using the extends
+ * attribute in the JSP_Engine chapter of the JSP specification.
+ * <p>
+ * The specific signature depends on the protocol supported by the JSP page.
+ *
+ * <pre>
+ * public void _jspService(<em>ServletRequestSubtype</em> request,
+ *                             <em>ServletResponseSubtype</em> response)
+ *        throws ServletException, IOException;
+ * </pre>
+ */
+
+
+public interface JspPage extends Servlet {
+
+    /**
+     * The jspInit() method is invoked when the JSP page is initialized. It
+     * is the responsibility of the JSP implementation (and of the class
+     * mentioned by the extends attribute, if present) that at this point
+     * invocations to the getServletConfig() method will return the desired
+     * value.
+     *
+     * A JSP page can override this method by including a definition for it
+     * in a declaration element.
+     *
+     * A JSP page should redefine the init() method from Servlet.
+     */
+    public void jspInit();
+
+    /**
+     * The jspDestroy() method is invoked when the JSP page is about to be
+     * destroyed.
+     *
+     * A JSP page can override this method by including a definition for it
+     * in a declaration element.
+     *
+     * A JSP page should redefine the destroy() method from Servlet.
+     */
+    public void jspDestroy();
+
+}

java/javax/servlet/jsp/JspTagException.java

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.jsp;
+
+/**
+ * Exception to be used by a Tag Handler to indicate some unrecoverable error.
+ * This error is to be caught by the top level of the JSP page and will result
+ * in an error page.
+ */
+public class JspTagException extends JspException {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Constructs a new JspTagException with the specified message. The message
+     * can be written to the server log and/or displayed for the user.
+     *
+     * @param msg
+     *            a <code>String</code> specifying the text of the exception
+     *            message
+     */
+    public JspTagException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Constructs a new JspTagException with no message.
+     */
+    public JspTagException() {
+        super();
+    }
+
+    /**
+     * Constructs a new JspTagException when the JSP Tag needs to throw an
+     * exception and include a message about the "root cause" exception that
+     * interfered with its normal operation, including a description message.
+     *
+     * @param message
+     *            a <code>String</code> containing the text of the exception
+     *            message
+     * @param rootCause
+     *            the <code>Throwable</code> exception that interfered with the
+     *            JSP Tag's normal operation, making this JSP Tag exception
+     *            necessary
+     * @since 2.0
+     */
+    public JspTagException(String message, Throwable rootCause) {
+        super(message, rootCause);
+    }
+
+    /**
+     * Constructs a new JSP Tag exception when the JSP Tag needs to throw an
+     * exception and include a message about the "root cause" exception that
+     * interfered with its normal operation. The exception's message is based on
+     * the localized message of the underlying exception.
+     * <p>
+     * This method calls the <code>getLocalizedMessage</code> method on the
+     * <code>Throwable</code> exception to get a localized exception message.
+     * When subclassing <code>JspTagException</code>, this method can be
+     * overridden to create an exception message designed for a specific locale.
+     *
+     * @param rootCause
+     *            the <code>Throwable</code> exception that interfered with the
+     *            JSP Tag's normal operation, making the JSP Tag exception
+     *            necessary
+     * @since 2.0
+     */
+    public JspTagException(Throwable rootCause) {
+        super(rootCause);
+    }
+}

java/javax/servlet/jsp/JspWriter.java

@@ -0,0 +1,458 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.jsp;
+
+import java.io.IOException;
+
+/**
+ * <p>
+ * The actions and template data in a JSP page is written using the JspWriter
+ * object that is referenced by the implicit variable out which is initialized
+ * automatically using methods in the PageContext object.
+ *<p>
+ * This abstract class emulates some of the functionality found in the
+ * java.io.BufferedWriter and java.io.PrintWriter classes, however it differs in
+ * that it throws java.io.IOException from the print methods while PrintWriter
+ * does not.
+ * <p>
+ * <B>Buffering</B>
+ * <p>
+ * The initial JspWriter object is associated with the PrintWriter object of the
+ * ServletResponse in a way that depends on whether the page is or is not
+ * buffered. If the page is not buffered, output written to this JspWriter
+ * object will be written through to the PrintWriter directly, which will be
+ * created if necessary by invoking the getWriter() method on the response
+ * object. But if the page is buffered, the PrintWriter object will not be
+ * created until the buffer is flushed and operations like setContentType() are
+ * legal. Since this flexibility simplifies programming substantially, buffering
+ * is the default for JSP pages.
+ * <p>
+ * Buffering raises the issue of what to do when the buffer is exceeded. Two
+ * approaches can be taken:
+ * <ul>
+ * <li>Exceeding the buffer is not a fatal error; when the buffer is exceeded,
+ * just flush the output.
+ * <li>Exceeding the buffer is a fatal error; when the buffer is exceeded, raise
+ * an exception.
+ * </ul>
+ * <p>
+ * Both approaches are valid, and thus both are supported in the JSP technology.
+ * The behavior of a page is controlled by the autoFlush attribute, which
+ * defaults to true. In general, JSP pages that need to be sure that correct and
+ * complete data has been sent to their client may want to set autoFlush to
+ * false, with a typical case being that where the client is an application
+ * itself. On the other hand, JSP pages that send data that is meaningful even
+ * when partially constructed may want to set autoFlush to true; such as when
+ * the data is sent for immediate display through a browser. Each application
+ * will need to consider their specific needs.
+ * <p>
+ * An alternative considered was to make the buffer size unbounded; but, this
+ * had the disadvantage that runaway computations would consume an unbounded
+ * amount of resources.
+ * <p>
+ * The "out" implicit variable of a JSP implementation class is of this type. If
+ * the page directive selects autoflush="true" then all the I/O operations on
+ * this class shall automatically flush the contents of the buffer if an
+ * overflow condition would result if the current operation were performed
+ * without a flush. If autoflush="false" then all the I/O operations on this
+ * class shall throw an IOException if performing the current operation would
+ * result in a buffer overflow condition.
+ *
+ * @see java.io.Writer
+ * @see java.io.BufferedWriter
+ * @see java.io.PrintWriter
+ */
+public abstract class JspWriter extends java.io.Writer {
+
+    /**
+     * Constant indicating that the Writer is not buffering output.
+     */
+    public static final int NO_BUFFER = 0;
+
+    /**
+     * Constant indicating that the Writer is buffered and is using the
+     * implementation default buffer size.
+     */
+    public static final int DEFAULT_BUFFER = -1;
+
+    /**
+     * Constant indicating that the Writer is buffered and is unbounded; this is
+     * used in BodyContent.
+     */
+    public static final int UNBOUNDED_BUFFER = -2;
+
+    /**
+     * Protected constructor.
+     *
+     * @param bufferSize
+     *            the size of the buffer to be used by the JspWriter
+     * @param autoFlush
+     *            whether the JspWriter should be autoflushing
+     */
+    protected JspWriter(int bufferSize, boolean autoFlush) {
+        this.bufferSize = bufferSize;
+        this.autoFlush = autoFlush;
+    }
+
+    /**
+     * Write a line separator. The line separator string is defined by the
+     * system property <code>line.separator</code>, and is not necessarily a
+     * single newline ('\n') character.
+     *
+     * @exception IOException
+     *                If an I/O error occurs
+     */
+    public abstract void newLine() throws IOException;
+
+    /**
+     * Print a boolean value. The string produced by <code>{@link
+     * java.lang.String#valueOf(boolean)}</code>
+     * is written to the JspWriter's buffer or, if no buffer is used, directly
+     * to the underlying writer.
+     *
+     * @param b
+     *            The <code>boolean</code> to be printed
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(boolean b) throws IOException;
+
+    /**
+     * Print a character. The character is written to the JspWriter's buffer or,
+     * if no buffer is used, directly to the underlying writer.
+     *
+     * @param c
+     *            The <code>char</code> to be printed
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(char c) throws IOException;
+
+    /**
+     * Print an integer. The string produced by <code>{@link
+     * java.lang.String#valueOf(int)}</code>
+     * is written to the JspWriter's buffer or, if no buffer is used, directly
+     * to the underlying writer.
+     *
+     * @param i
+     *            The <code>int</code> to be printed
+     * @see java.lang.Integer#toString(int)
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(int i) throws IOException;
+
+    /**
+     * Print a long integer. The string produced by <code>{@link
+     * java.lang.String#valueOf(long)}</code>
+     * is written to the JspWriter's buffer or, if no buffer is used, directly
+     * to the underlying writer.
+     *
+     * @param l
+     *            The <code>long</code> to be printed
+     * @see java.lang.Long#toString(long)
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(long l) throws IOException;
+
+    /**
+     * Print a floating-point number. The string produced by <code>{@link
+     * java.lang.String#valueOf(float)}</code>
+     * is written to the JspWriter's buffer or, if no buffer is used, directly
+     * to the underlying writer.
+     *
+     * @param f
+     *            The <code>float</code> to be printed
+     * @see java.lang.Float#toString(float)
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(float f) throws IOException;
+
+    /**
+     * Print a double-precision floating-point number. The string produced by
+     * <code>{@link java.lang.String#valueOf(double)}</code> is written to the
+     * JspWriter's buffer or, if no buffer is used, directly to the underlying
+     * writer.
+     *
+     * @param d
+     *            The <code>double</code> to be printed
+     * @see java.lang.Double#toString(double)
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(double d) throws IOException;
+
+    /**
+     * Print an array of characters. The characters are written to the
+     * JspWriter's buffer or, if no buffer is used, directly to the underlying
+     * writer.
+     *
+     * @param s
+     *            The array of chars to be printed
+     * @throws NullPointerException
+     *             If <code>s</code> is <code>null</code>
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(char s[]) throws IOException;
+
+    /**
+     * Print a string. If the argument is <code>null</code> then the string
+     * <code>"null"</code> is printed. Otherwise, the string's characters are
+     * written to the JspWriter's buffer or, if no buffer is used, directly to
+     * the underlying writer.
+     *
+     * @param s
+     *            The <code>String</code> to be printed
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(String s) throws IOException;
+
+    /**
+     * Print an object. The string produced by the <code>{@link
+     * java.lang.String#valueOf(Object)}</code>
+     * method is written to the JspWriter's buffer or, if no buffer is used,
+     * directly to the underlying writer.
+     *
+     * @param obj
+     *            The <code>Object</code> to be printed
+     * @see java.lang.Object#toString()
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void print(Object obj) throws IOException;
+
+    /**
+     * Terminate the current line by writing the line separator string. The line
+     * separator string is defined by the system property
+     * <code>line.separator</code>, and is not necessarily a single newline
+     * character (<code>'\n'</code>).
+     *
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println() throws IOException;
+
+    /**
+     * Print a boolean value and then terminate the line. This method behaves as
+     * though it invokes <code>{@link #print(boolean)}</code> and then
+     * <code>{@link #println()}</code>.
+     *
+     * @param x
+     *            the boolean to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(boolean x) throws IOException;
+
+    /**
+     * Print a character and then terminate the line. This method behaves as
+     * though it invokes <code>{@link #print(char)}</code> and then <code>{@link
+     * #println()}</code>
+     * .
+     *
+     * @param x
+     *            the char to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(char x) throws IOException;
+
+    /**
+     * Print an integer and then terminate the line. This method behaves as
+     * though it invokes <code>{@link #print(int)}</code> and then <code>{@link
+     * #println()}</code>
+     * .
+     *
+     * @param x
+     *            the int to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(int x) throws IOException;
+
+    /**
+     * Print a long integer and then terminate the line. This method behaves as
+     * though it invokes <code>{@link #print(long)}</code> and then
+     * <code>{@link #println()}</code>.
+     *
+     * @param x
+     *            the long to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(long x) throws IOException;
+
+    /**
+     * Print a floating-point number and then terminate the line. This method
+     * behaves as though it invokes <code>{@link #print(float)}</code> and then
+     * <code>{@link #println()}</code>.
+     *
+     * @param x
+     *            the float to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(float x) throws IOException;
+
+    /**
+     * Print a double-precision floating-point number and then terminate the
+     * line. This method behaves as though it invokes <code>{@link
+     * #print(double)}</code> and
+     * then <code>{@link #println()}</code>.
+     *
+     * @param x
+     *            the double to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(double x) throws IOException;
+
+    /**
+     * Print an array of characters and then terminate the line. This method
+     * behaves as though it invokes <code>print(char[])</code> and then
+     * <code>println()</code>.
+     *
+     * @param x
+     *            the char[] to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(char x[]) throws IOException;
+
+    /**
+     * Print a String and then terminate the line. This method behaves as though
+     * it invokes <code>{@link #print(String)}</code> and then
+     * <code>{@link #println()}</code>.
+     *
+     * @param x
+     *            the String to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(String x) throws IOException;
+
+    /**
+     * Print an Object and then terminate the line. This method behaves as
+     * though it invokes <code>{@link #print(Object)}</code> and then
+     * <code>{@link #println()}</code>.
+     *
+     * @param x
+     *            the Object to write
+     * @throws java.io.IOException
+     *             If an error occurred while writing
+     */
+    public abstract void println(Object x) throws IOException;
+
+    /**
+     * Clear the contents of the buffer. If the buffer has been already been
+     * flushed then the clear operation shall throw an IOException to signal the
+     * fact that some data has already been irrevocably written to the client
+     * response stream.
+     *
+     * @throws IOException
+     *             If an I/O error occurs
+     */
+    public abstract void clear() throws IOException;
+
+    /**
+     * Clears the current contents of the buffer. Unlike clear(), this method
+     * will not throw an IOException if the buffer has already been flushed. It
+     * merely clears the current content of the buffer and returns.
+     *
+     * @throws IOException
+     *             If an I/O error occurs
+     */
+    public abstract void clearBuffer() throws IOException;
+
+    /**
+     * Flush the stream. If the stream has saved any characters from the various
+     * write() methods in a buffer, write them immediately to their intended
+     * destination. Then, if that destination is another character or byte
+     * stream, flush it. Thus one flush() invocation will flush all the buffers
+     * in a chain of Writers and OutputStreams.
+     * <p>
+     * The method may be invoked indirectly if the buffer size is exceeded.
+     * <p>
+     * Once a stream has been closed, further write() or flush() invocations
+     * will cause an IOException to be thrown.
+     *
+     * @exception IOException
+     *                If an I/O error occurs
+     */
+    @Override
+    public abstract void flush() throws IOException;
+
+    /**
+     * Close the stream, flushing it first.
+     * <p>
+     * This method needs not be invoked explicitly for the initial JspWriter as
+     * the code generated by the JSP container will automatically include a call
+     * to close().
+     * <p>
+     * Closing a previously-closed stream, unlike flush(), has no effect.
+     *
+     * @exception IOException
+     *                If an I/O error occurs
+     */
+    @Override
+    public abstract void close() throws IOException;
+
+    /**
+     * This method returns the size of the buffer used by the JspWriter.
+     *
+     * @return the size of the buffer in bytes, or 0 is unbuffered.
+     */
+    public int getBufferSize() {
+        return bufferSize;
+    }
+
+    /**
+     * This method returns the number of unused bytes in the buffer.
+     *
+     * @return the number of bytes unused in the buffer
+     */
+    public abstract int getRemaining();
+
+    /**
+     * This method indicates whether the JspWriter is autoFlushing.
+     *
+     * @return if this JspWriter is auto flushing or throwing IOExceptions on
+     *         buffer overflow conditions
+     */
+    public boolean isAutoFlush() {
+        return autoFlush;
+    }
+
+    /*
+     * fields
+     */
+
+    /**
+     * The size of the buffer used by the JspWriter.
+     */
+    protected int bufferSize;
+
+    /**
+     * Whether the JspWriter is autoflushing.
+     */
+    protected boolean autoFlush;
+}

java/javax/servlet/jsp/PageContext.java

@@ -0,0 +1,535 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package javax.servlet.jsp;
+
+import java.io.IOException;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.Servlet;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpSession;
+import javax.servlet.jsp.tagext.BodyContent;
+
+/**
+ * <p>
+ * PageContext extends JspContext to provide useful context information for
+ * when JSP technology is used in a Servlet environment.
+ * <p>
+ * A PageContext instance provides access to all the namespaces associated
+ * with a JSP page, provides access to several page attributes, as well as
+ * a layer above the implementation details.  Implicit objects are added
+ * to the pageContext automatically.
+ *
+ * <p> The <code> PageContext </code> class is an abstract class, designed to be
+ * extended to provide implementation dependent implementations thereof, by
+ * conformant JSP engine runtime environments. A PageContext instance is
+ * obtained by a JSP implementation class by calling the
+ * JspFactory.getPageContext() method, and is released by calling
+ * JspFactory.releasePageContext().
+ *
+ * <p> An example of how PageContext, JspFactory, and other classes can be
+ * used  within a JSP Page Implementation object is given elsewhere.
+ *
+ * <p>
+ * The PageContext provides a number of facilities to the page/component
+ * author and page implementor, including:
+ * <ul>
+ * <li>a single API to manage the various scoped namespaces
+ * <li>a number of convenience API's to access various public objects
+ * <li>a mechanism to obtain the JspWriter for output
+ * <li>a mechanism to manage session usage by the page
+ * <li>a mechanism to expose page directive attributes to the scripting
+ *     environment
+ * <li>mechanisms to forward or include the current request to other active
+ *     components in the application
+ * <li>a mechanism to handle errorpage exception processing
+ * </ul>
+ *
+ * <p><B>Methods Intended for Container Generated Code</B>
+ * <p>Some methods are intended to be used by the code generated by the
+ * container, not by code written by JSP page authors, or JSP tag library
+ * authors.
+ * <p>The methods supporting <B>lifecycle</B> are <code>initialize()</code>
+ * and <code>release()</code>
+ *
+ * <p>
+ * The following methods enable the <B>management of nested</B> JspWriter
+ * streams to implement Tag Extensions: <code>pushBody()</code>
+ *
+ * <p><B>Methods Intended for JSP authors</B>
+ * <p>
+ * The following methods provide <B>convenient access</B> to implicit objects:
+ * <code>getException()</code>,  <code>getPage()</code>
+ * <code>getRequest()</code>,  <code>getResponse()</code>,
+ * <code>getSession()</code>,  <code>getServletConfig()</code>
+ * and <code>getServletContext()</code>.
+ *
+ * <p>
+ * The following methods provide support for <B>forwarding, inclusion
+ * and error handling</B>:
+ * <code>forward()</code>,  <code>include()</code>,
+ * and  <code>handlePageException()</code>.
+ */
+
+public abstract class PageContext
+    extends JspContext
+{
+
+    /**
+     * Sole constructor. (For invocation by subclass constructors,
+     * typically implicit.)
+     */
+    public PageContext() {
+        // NOOP by default
+    }
+
+    /**
+     * Page scope: (this is the default) the named reference remains available
+     * in this PageContext until the return from the current Servlet.service()
+     * invocation.
+     */
+
+    public static final int PAGE_SCOPE = 1;
+
+    /**
+     * Request scope: the named reference remains available from the
+     * ServletRequest associated with the Servlet until the current request
+     * is completed.
+     */
+
+    public static final int REQUEST_SCOPE = 2;
+
+    /**
+     * Session scope (only valid if this page participates in a session):
+     * the named reference remains available from the HttpSession (if any)
+     * associated with the Servlet until the HttpSession is invalidated.
+     */
+
+    public static final int SESSION_SCOPE = 3;
+
+    /**
+     * Application scope: named reference remains available in the
+     * ServletContext until it is reclaimed.
+     */
+
+    public static final int APPLICATION_SCOPE = 4;
+
+    /**
+     * Name used to store the Servlet in this PageContext's nametables.
+     */
+
+    public static final String PAGE = "javax.servlet.jsp.jspPage";
+
+    /**
+     * Name used to store this PageContext in it's own name table.
+     */
+
+    public static final String PAGECONTEXT = "javax.servlet.jsp.jspPageContext";
+
+    /**
+     * Name used to store ServletRequest in PageContext name table.
+     */
+
+    public static final String REQUEST = "javax.servlet.jsp.jspRequest";
+
+    /**
+     * Name used to store ServletResponse in PageContext name table.
+     */
+
+    public static final String RESPONSE = "javax.servlet.jsp.jspResponse";
+
+    /**
+     * Name used to store ServletConfig in PageContext name table.
+     */
+
+    public static final String CONFIG = "javax.servlet.jsp.jspConfig";
+
+    /**
+     * Name used to store HttpSession in PageContext name table.
+     */
+
+    public static final String SESSION = "javax.servlet.jsp.jspSession";
+    /**
+     * Name used to store current JspWriter in PageContext name table.
+     */
+
+    public static final String OUT = "javax.servlet.jsp.jspOut";
+
+    /**
+     * Name used to store ServletContext in PageContext name table.
+     */
+
+    public static final String APPLICATION = "javax.servlet.jsp.jspApplication";
+
+    /**
+     * Name used to store uncaught exception in ServletRequest attribute
+     * list and PageContext name table.
+     */
+
+    public static final String EXCEPTION = "javax.servlet.jsp.jspException";
+
+    /**
+     * <p>
+     * The initialize method is called to initialize an uninitialized PageContext
+     * so that it may be used by a JSP Implementation class to service an
+     * incoming request and response within it's _jspService() method.
+     *
+     * <p>
+     * This method is typically called from JspFactory.getPageContext() in
+     * order to initialize state.
+     *
+     * <p>
+     * This method is required to create an initial JspWriter, and associate
+     * the "out" name in page scope with this newly created object.
+     *
+     * <p>
+     * This method should not be used by page  or tag library authors.
+     *
+     * @param servlet The Servlet that is associated with this PageContext
+     * @param request The currently pending request for this Servlet
+     * @param response The currently pending response for this Servlet
+     * @param errorPageURL The value of the errorpage attribute from the page
+     *     directive or null
+     * @param needsSession The value of the session attribute from the
+     *     page directive
+     * @param bufferSize The value of the buffer attribute from the page
+     *     directive
+     * @param autoFlush The value of the autoflush attribute from the page
+     *     directive
+     *
+     * @throws IOException during creation of JspWriter
+     * @throws IllegalStateException if out not correctly initialized
+     * @throws IllegalArgumentException If one of the given parameters
+     *     is invalid
+     */
+
+    public abstract void initialize(Servlet servlet, ServletRequest request,
+        ServletResponse response, String errorPageURL, boolean needsSession,
+        int bufferSize, boolean autoFlush)
+        throws IOException, IllegalStateException, IllegalArgumentException;
+
+    /**
+     * <p>
+     * This method shall "reset" the internal state of a PageContext, releasing
+     * all internal references, and preparing the PageContext for potential
+     * reuse by a later invocation of initialize(). This method is typically
+     * called from JspFactory.releasePageContext().
+     *
+     * <p>
+     * Subclasses shall envelope this method.
+     *
+     * <p>
+     * This method should not be used by page  or tag library authors.
+     *
+     */
+
+    public abstract void release();
+
+    /**
+     * The current value of the session object (an HttpSession).
+     *
+     * @return the HttpSession for this PageContext or null
+     */
+
+    public abstract HttpSession getSession();
+
+    /**
+     * The current value of the page object (In a Servlet environment,
+     * this is an instance of javax.servlet.Servlet).
+     *
+     * @return the Page implementation class instance associated
+     *     with this PageContext
+     */
+
+    public abstract Object getPage();
+
+
+    /**
+     * The current value of the request object (a ServletRequest).
+     *
+     * @return The ServletRequest for this PageContext
+     */
+
+    public abstract ServletRequest getRequest();
+
+    /**
+     * The current value of the response object (a ServletResponse).
+     *
+     * @return the ServletResponse for this PageContext
+     */
+
+    public abstract ServletResponse getResponse();
+
+    /**
+     * The current value of the exception object (an Exception).
+     *
+     * @return any exception passed to this as an errorpage
+     */
+
+    public abstract Exception getException();
+
+    /**
+     * The ServletConfig instance.
+     *
+     * @return the ServletConfig for this PageContext
+     */
+
+    public abstract ServletConfig getServletConfig();
+
+    /**
+     * The ServletContext instance.
+     *
+     * @return the ServletContext for this PageContext
+     */
+
+    public abstract ServletContext getServletContext();
+
+    /**
+     * <p>
+     * This method is used to re-direct, or "forward" the current
+     * ServletRequest and ServletResponse to another active component in
+     * the application.
+     * </p>
+     * <p>
+     * If the <I> relativeUrlPath </I> begins with a "/" then the URL specified
+     * is calculated relative to the DOCROOT of the <code> ServletContext </code>
+     * for this JSP. If the path does not begin with a "/" then the URL
+     * specified is calculated relative to the URL of the request that was
+     * mapped to the calling JSP.
+     * </p>
+     * <p>
+     * It is only valid to call this method from a <code> Thread </code>
+     * executing within a <code> _jspService(...) </code> method of a JSP.
+     * </p>
+     * <p>
+     * Once this method has been called successfully, it is illegal for the
+     * calling <code> Thread </code> to attempt to modify the <code>
+     * ServletResponse </code> object.  Any such attempt to do so, shall result
+     * in undefined behavior. Typically, callers immediately return from
+     * <code> _jspService(...) </code> after calling this method.
+     * </p>
+     *
+     * @param relativeUrlPath specifies the relative URL path to the target
+     *     resource as described above
+     *
+     * @throws IllegalStateException if <code> ServletResponse </code> is not
+     *     in a state where a forward can be performed
+     * @throws ServletException if the page that was forwarded to throws
+     *     a ServletException
+     * @throws IOException if an I/O error occurred while forwarding
+     */
+
+    public abstract void forward(String relativeUrlPath)
+        throws ServletException, IOException;
+
+    /**
+     * <p>
+     * Causes the resource specified to be processed as part of the current
+     * ServletRequest and ServletResponse being processed by the calling Thread.
+     * The output of the target resources processing of the request is written
+     * directly to the ServletResponse output stream.
+     * </p>
+     * <p>
+     * The current JspWriter "out" for this JSP is flushed as a side-effect
+     * of this call, prior to processing the include.
+     * </p>
+     * <p>
+     * If the <I> relativeUrlPath </I> begins with a "/" then the URL specified
+     * is calculated relative to the DOCROOT of the <code>ServletContext</code>
+     * for this JSP. If the path does not begin with a "/" then the URL
+     * specified is calculated relative to the URL of the request that was
+     * mapped to the calling JSP.
+     * </p>
+     * <p>
+     * It is only valid to call this method from a <code> Thread </code>
+     * executing within a <code> _jspService(...) </code> method of a JSP.
+     * </p>
+     *
+     * @param relativeUrlPath specifies the relative URL path to the target
+     *     resource to be included
+     *
+     * @throws ServletException if the page that was forwarded to throws
+     *     a ServletException
+     * @throws IOException if an I/O error occurred while forwarding
+     */
+    public abstract void include(String relativeUrlPath)
+        throws ServletException, IOException;
+
+    /**
+     * <p>
+     * Causes the resource specified to be processed as part of the current
+     * ServletRequest and ServletResponse being processed by the calling Thread.
+     * The output of the target resources processing of the request is written
+     * directly to the current JspWriter returned by a call to getOut().
+     * </p>
+     * <p>
+     * If flush is true, The current JspWriter "out" for this JSP
+     * is flushed as a side-effect of this call, prior to processing
+     * the include.  Otherwise, the JspWriter "out" is not flushed.
+     * </p>
+     * <p>
+     * If the <i>relativeUrlPath</i> begins with a "/" then the URL specified
+     * is calculated relative to the DOCROOT of the <code>ServletContext</code>
+     * for this JSP. If the path does not begin with a "/" then the URL
+     * specified is calculated relative to the URL of the request that was
+     * mapped to the calling JSP.
+     * </p>
+     * <p>
+     * It is only valid to call this method from a <code> Thread </code>
+     * executing within a <code> _jspService(...) </code> method of a JSP.
+     * </p>
+     *
+     * @param relativeUrlPath specifies the relative URL path to the
+     *     target resource to be included
+     * @param flush True if the JspWriter is to be flushed before the include,
+     *     or false if not.
+     *
+     * @throws ServletException if the page that was forwarded to throws
+     *     a ServletException
+     * @throws IOException if an I/O error occurred while forwarding
+     * @since 2.0
+     */
+    public abstract void include(String relativeUrlPath, boolean flush)
+        throws ServletException, IOException;
+
+    /**
+     * <p>
+     * This method is intended to process an unhandled 'page' level
+     * exception by forwarding the exception to the specified
+     * error page for this JSP.  If forwarding is not possible (for
+     * example because the response has already been committed), an
+     * implementation dependent mechanism should be used to invoke
+     * the error page (e.g. "including" the error page instead).
+     *
+     * <p>
+     * If no error page is defined in the page, the exception should
+     * be rethrown so that the standard servlet error handling
+     * takes over.
+     *
+     * <p>
+     * A JSP implementation class shall typically clean up any local state
+     * prior to invoking this and will return immediately thereafter. It is
+     * illegal to generate any output to the client, or to modify any
+     * ServletResponse state after invoking this call.
+     *
+     * <p>
+     * This method is kept for backwards compatibility reasons.  Newly
+     * generated code should use PageContext.handlePageException(Throwable).
+     *
+     * @param e the exception to be handled
+     *
+     * @throws ServletException if an error occurs while invoking the error page
+     * @throws IOException if an I/O error occurred while invoking the error
+     *     page
+     * @throws NullPointerException if the exception is null
+     *
+     * @see #handlePageException(Throwable)
+     */
+
+    public abstract void handlePageException(Exception e)
+        throws ServletException, IOException;
+
+    /**
+     * <p>
+     * This method is intended to process an unhandled 'page' level
+     * exception by forwarding the exception to the specified
+     * error page for this JSP.  If forwarding is not possible (for
+     * example because the response has already been committed), an
+     * implementation dependent mechanism should be used to invoke
+     * the error page (e.g. "including" the error page instead).
+     *
+     * <p>
+     * If no error page is defined in the page, the exception should
+     * be rethrown so that the standard servlet error handling
+     * takes over.
+     *
+     * <p>
+     * This method is intended to process an unhandled "page" level exception
+     * by redirecting the exception to either the specified error page for this
+     * JSP, or if none was specified, to perform some implementation dependent
+     * action.
+     *
+     * <p>
+     * A JSP implementation class shall typically clean up any local state
+     * prior to invoking this and will return immediately thereafter. It is
+     * illegal to generate any output to the client, or to modify any
+     * ServletResponse state after invoking this call.
+     *
+     * @param t the throwable to be handled
+     *
+     * @throws ServletException if an error occurs while invoking the error page
+     * @throws IOException if an I/O error occurred while invoking the error
+     *     page
+     * @throws NullPointerException if the exception is null
+     *
+     * @see #handlePageException(Exception)
+     */
+
+    public abstract void handlePageException(Throwable t)
+        throws ServletException, IOException;
+
+    /**
+     * Return a new BodyContent object, save the current "out" JspWriter,
+     * and update the value of the "out" attribute in the page scope
+     * attribute namespace of the PageContext.
+     *
+     * @return the new BodyContent
+     */
+
+    public BodyContent pushBody() {
+        return null; // XXX to implement
+    }
+
+
+    /**
+     * Provides convenient access to error information.
+     *
+     * @return an ErrorData instance containing information about the
+     * error, as obtained from the request attributes, as per the
+     * Servlet specification.  If this is not an error page (that is,
+     * if the isErrorPage attribute of the page directive is not set
+     * to "true"), the information is meaningless.
+     *
+     * @since 2.0
+     */
+    public ErrorData getErrorData() {
+        int status = 0;
+
+        Integer status_code = (Integer)getRequest().getAttribute(
+                RequestDispatcher.ERROR_STATUS_CODE);
+        // Avoid NPE if attribute is not set
+        if (status_code != null) {
+            status = status_code.intValue();
+        }
+
+        return new ErrorData(
+            (Throwable)getRequest().getAttribute(
+                    RequestDispatcher.ERROR_EXCEPTION),
+            status,
+            (String)getRequest().getAttribute(
+                    RequestDispatcher.ERROR_REQUEST_URI),
+            (String)getRequest().getAttribute(
+                    RequestDispatcher.ERROR_SERVLET_NAME)
+            );
+    }
+
+}

java/javax/servlet/jsp/SkipPageException.java

@@ -0,0 +1,77 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package javax.servlet.jsp;
+
+/**
+ * Exception to indicate the calling page must cease evaluation. Thrown by a
+ * simple tag handler to indicate that the remainder of the page must not be
+ * evaluated. The result is propagated back to the page in the case where one
+ * tag invokes another (as can be the case with tag files). The effect is
+ * similar to that of a Classic Tag Handler returning Tag.SKIP_PAGE from
+ * doEndTag(). Jsp Fragments may also throw this exception. This exception
+ * should not be thrown manually in a JSP page or tag file - the behavior is
+ * undefined. The exception is intended to be thrown inside SimpleTag handlers
+ * and in JSP fragments.
+ *
+ * @see javax.servlet.jsp.tagext.SimpleTag#doTag
+ * @see javax.servlet.jsp.tagext.JspFragment#invoke
+ * @see javax.servlet.jsp.tagext.Tag#doEndTag
+ * @since 2.0
+ */
+public class SkipPageException extends JspException {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Creates a SkipPageException with no message.
+     */
+    public SkipPageException() {
+        super();
+    }
+
+    /**
+     * Creates a SkipPageException with the provided message.
+     *
+     * @param message
+     *            the detail message
+     */
+    public SkipPageException(String message) {
+        super(message);
+    }
+
+    /**
+     * Creates a SkipPageException with the provided message and root cause.
+     *
+     * @param message
+     *            the detail message
+     * @param rootCause
+     *            the originating cause of this exception
+     */
+    public SkipPageException(String message, Throwable rootCause) {
+        super(message, rootCause);
+    }
+
+    /**
+     * Creates a SkipPageException with the provided root cause.
+     *
+     * @param rootCause
+     *            the originating cause of this exception
+     */
+    public SkipPageException(Throwable rootCause) {
+        super(rootCause);
+    }
+}

java/javax/servlet/jsp/el/ELException.java

@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.jsp.el;
+
+/**
+ * Represents any of the exception conditions that arise during the operation
+ * evaluation of the evaluator.
+ *
+ * @since 2.0
+ * @deprecated As of JSP 2.1, replaced by javax.el.ELException
+ */
+@SuppressWarnings("dep-ann") // TCK signature test fails with annotation
+public class ELException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Creates an ELException with no detail message.
+     **/
+    public ELException() {
+        super();
+    }
+
+    /**
+     * Creates an ELException with the provided detail message.
+     *
+     * @param pMessage
+     *            the detail message
+     **/
+    public ELException(String pMessage) {
+        super(pMessage);
+    }
+
+    /**
+     * Creates an ELException with the given root cause.
+     *
+     * @param pRootCause
+     *            the originating cause of this exception
+     **/
+    public ELException(Throwable pRootCause) {
+        super(pRootCause);
+    }
+
+    // -------------------------------------
+    /**
+     * Creates an ELException with the given detail message and root cause.
+     *
+     * @param pMessage
+     *            the detail message
+     * @param pRootCause
+     *            the originating cause of this exception
+     **/
+    public ELException(String pMessage, Throwable pRootCause) {
+        super(pMessage, pRootCause);
+    }
+
+    // -------------------------------------
+    /**
+     * Returns the root cause.
+     *
+     * @return the root cause of this exception
+     */
+    public Throwable getRootCause() {
+        return getCause();
+    }
+}