@Override
public AsyncContext startAsync(final ServletRequest servletRequest, final ServletResponse servletResponse) throws IllegalStateException {
    final ServletRequestContext servletRequestContext = exchange.getAttachment(ServletRequestContext.ATTACHMENT_KEY);
    if (!servletContext.getDeployment().getDeploymentInfo().isAllowNonStandardWrappers()) {
        if (servletRequestContext.getOriginalRequest() != servletRequest) {
            if (!(servletRequest instanceof ServletRequestWrapper)) {
                throw UndertowServletMessages.MESSAGES.requestWasNotOriginalOrWrapper(servletRequest);
            }
        }
        if (servletRequestContext.getOriginalResponse() != servletResponse) {
            if (!(servletResponse instanceof ServletResponseWrapper)) {
                throw UndertowServletMessages.MESSAGES.responseWasNotOriginalOrWrapper(servletResponse);
            }
        }
    }
    if (!isAsyncSupported()) {
        throw UndertowServletMessages.MESSAGES.startAsyncNotAllowed();
    } else if (asyncStarted) {
        throw UndertowServletMessages.MESSAGES.asyncAlreadyStarted();
    }
    asyncStarted = true;
    servletRequestContext.setServletRequest(servletRequest);
    servletRequestContext.setServletResponse(servletResponse);
    return asyncContext = new AsyncContextImpl(exchange, servletRequest, servletResponse, servletRequestContext, true, asyncContext);
}
 

@Override
public AsyncContext startAsync(final ServletRequest servletRequest, final ServletResponse servletResponse) throws IllegalStateException {
    final ServletRequestContext servletRequestContext = exchange.getAttachment(ServletRequestContext.ATTACHMENT_KEY);
    if (!servletContext.getDeployment().getDeploymentInfo().isAllowNonStandardWrappers()) {
        if (servletRequestContext.getOriginalRequest() != servletRequest) {
            if (!(servletRequest instanceof ServletRequestWrapper)) {
                throw UndertowServletMessages.MESSAGES.requestWasNotOriginalOrWrapper(servletRequest);
            }
        }
        if (servletRequestContext.getOriginalResponse() != servletResponse) {
            if (!(servletResponse instanceof ServletResponseWrapper)) {
                throw UndertowServletMessages.MESSAGES.responseWasNotOriginalOrWrapper(servletResponse);
            }
        }
    }
    if (!isAsyncSupported()) {
        throw UndertowServletMessages.MESSAGES.startAsyncNotAllowed();
    } else if (asyncStarted) {
        throw UndertowServletMessages.MESSAGES.asyncAlreadyStarted();
    }
    asyncStarted = true;
    servletRequestContext.setServletRequest(servletRequest);
    servletRequestContext.setServletResponse(servletResponse);
    return asyncContext = new AsyncContextImpl(exchange, servletRequest, servletResponse, servletRequestContext, true, asyncContext);
}
 

/**
 * Unwrap the response if we have wrapped it.
 */
private void unwrapResponse(State state) {

    if (state.wrapResponse == null)
        return;

    if (state.outerRequest.isAsyncStarted()) {
        if (!state.outerRequest.getAsyncContext().hasOriginalRequestAndResponse()) {
            return;
        }
    }

    ServletResponse previous = null;
    ServletResponse current = state.outerResponse;
    while (current != null) {

        // If we run into the container response we are done
        if ((current instanceof Response)
            || (current instanceof ResponseFacade))
            break;

        // Remove the current response if it is our wrapper
        if (current == state.wrapResponse) {
            ServletResponse next =
              ((ServletResponseWrapper) current).getResponse();
            if (previous == null)
                state.outerResponse = next;
            else
                ((ServletResponseWrapper) previous).setResponse(next);
            break;
        }

        // Advance to the next response in the chain
        previous = current;
        current = ((ServletResponseWrapper) current).getResponse();

    }

}
 

/**
 * Create and return a response wrapper that has been inserted in the
 * appropriate spot in the response chain.
 */
private ServletResponse wrapResponse(State state) {

    // Locate the response we should insert in front of
    ServletResponse previous = null;
    ServletResponse current = state.outerResponse;
    while (current != null) {
        if(state.hresponse == null && (current instanceof HttpServletResponse)) {
            state.hresponse = (HttpServletResponse)current;
            if(!state.including) // Forward only needs hresponse
                return null;
        }
        if (!(current instanceof ServletResponseWrapper))
            break;
        if (current instanceof ApplicationHttpResponse)
            break;
        if (current instanceof ApplicationResponse)
            break;
        previous = current;
        current = ((ServletResponseWrapper) current).getResponse();
    }

    // Instantiate a new wrapper at this point and insert it in the chain
    ServletResponse wrapper = null;
    if ((current instanceof ApplicationHttpResponse) ||
        (current instanceof Response) ||
        (current instanceof HttpServletResponse))
        wrapper =
            new ApplicationHttpResponse((HttpServletResponse) current,
                    state.including);
    else
        wrapper = new ApplicationResponse(current, state.including);
    if (previous == null)
        state.outerResponse = wrapper;
    else
        ((ServletResponseWrapper) previous).setResponse(wrapper);
    state.wrapResponse = wrapper;
    return wrapper;

}
 

@Override
public void service(ServletRequest req, ServletResponse resp)
        throws ServletException, IOException {
    if (DispatcherType.ASYNC != req.getDispatcherType()) {
        AsyncContext asyncContext;
        if ("y".equals(req.getParameter(CUSTOM_REQ_RESP))) {
            asyncContext = req.startAsync(
                    new ServletRequestWrapper(req),
                    new ServletResponseWrapper(resp));
        } else {
            asyncContext = req.startAsync();
        }
        if ("y".equals(req.getParameter(EMPTY_DISPATCH))) {
            asyncContext.dispatch();
        } else {
            asyncContext.dispatch("/target");
        }
        try {
            asyncContext.dispatch("/nonExistingServlet");
            TestAsyncContextImpl.track("FAIL");
        } catch (IllegalStateException e) {
            TestAsyncContextImpl.track("OK");
        }
    } else {
        TestAsyncContextImpl.track("DispatchingGenericServletGet-");
    }
}
 

@Override
public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {
    if (req instanceof ServletRequestWrapper
            && res instanceof ServletResponseWrapper) {
        TestAsyncContextImpl.track("CustomGenericServletGet-");
    }
}
 

/**
 * Return an appropriate response object of the specified type, if available,
 * unwrapping the given response as far as necessary.
 * @param response the servlet response to introspect
 * @param requiredType the desired type of response object
 * @return the matching response object, or {@code null} if none
 * of that type is available
 */
@SuppressWarnings("unchecked")
@Nullable
public static <T> T getNativeResponse(ServletResponse response, @Nullable Class<T> requiredType) {
	if (requiredType != null) {
		if (requiredType.isInstance(response)) {
			return (T) response;
		}
		else if (response instanceof ServletResponseWrapper) {
			return getNativeResponse(((ServletResponseWrapper) response).getResponse(), requiredType);
		}
	}
	return null;
}
 

/**
 * Checks (recursively) if this ServletResponseWrapper wraps the given
 * {@link ServletResponse} instance.
 *
 * @param wrapped the ServletResponse instance to search for
 * @return true if this ServletResponseWrapper wraps the
 *         given ServletResponse instance, false otherwise
 * @since Servlet 3.0
 */
public boolean isWrapperFor(ServletResponse wrapped) {
    if (response == wrapped) {
        return true;
    } else if (response instanceof ServletResponseWrapper) {
        return ((ServletResponseWrapper) response).isWrapperFor(wrapped);
    } else {
        return false;
    }
}
 

/**
 * Checks (recursively) if this ServletResponseWrapper wraps a
 * {@link ServletResponse} of the given class type.
 *
 * @param wrappedType the ServletResponse class type to
 *                    search for
 * @return true if this ServletResponseWrapper wraps a
 *         ServletResponse of the given class type, false otherwise
 * @throws IllegalArgumentException if the given class does not
 *                                  implement {@link ServletResponse}
 * @since Servlet 3.0
 */
public boolean isWrapperFor(Class<?> wrappedType) {
    if (!ServletResponse.class.isAssignableFrom(wrappedType)) {
        throw new IllegalArgumentException("Given class " +
                wrappedType.getName() + " not a subinterface of " +
                ServletResponse.class.getName());
    }
    if (wrappedType.isAssignableFrom(response.getClass())) {
        return true;
    } else if (response instanceof ServletResponseWrapper) {
        return ((ServletResponseWrapper) response).isWrapperFor(wrappedType);
    } else {
        return false;
    }
}
 

/**
 * Return an appropriate response object of the specified type, if available,
 * unwrapping the given response as far as necessary.
 * @param response the servlet response to introspect
 * @param requiredType the desired type of response object
 * @return the matching response object, or {@code null} if none
 * of that type is available
 */
@SuppressWarnings("unchecked")
@Nullable
public static <T> T getNativeResponse(ServletResponse response, @Nullable Class<T> requiredType) {
	if (requiredType != null) {
		if (requiredType.isInstance(response)) {
			return (T) response;
		}
		else if (response instanceof ServletResponseWrapper) {
			return getNativeResponse(((ServletResponseWrapper) response).getResponse(), requiredType);
		}
	}
	return null;
}
 

/**
 * unWrapper
 * @param response response
 * @return ServletHttpServletResponse
 */
public static ServletHttpServletResponse unWrapper(ServletResponse response){
    if(response instanceof ServletResponseWrapper){
        return unWrapper(((ServletResponseWrapper) response).getResponse());
    }
    if(response instanceof ServletHttpServletResponse){
        return (ServletHttpServletResponse) response;
    }
    return null;
}
 

public static HttpServletResponse unwrap(ServletResponse servletResponse)
{
    if (servletResponse instanceof HttpServletResponseWrapper)
    {
        return (HttpServletResponseWrapper)servletResponse;
    }
    if (servletResponse instanceof ServletResponseWrapper)
    {
        return unwrap(((ServletResponseWrapper)servletResponse).getResponse());
    }
    return (HttpServletResponse)servletResponse;
}
 

/**
 * Unwrap the servlet response.
 *
 * @param <T> the type.
 * @param response the response to unwrap.
 * @return the unwrapped response.
 */
@SuppressWarnings("unchecked")
private <T extends ServletResponse> T unwrapFully(ServletResponse response) {
    ServletResponse currentResponse = response;
    while (currentResponse instanceof ServletResponseWrapper) {
        ServletResponseWrapper wrapper = (ServletResponseWrapper) currentResponse;
        currentResponse = wrapper.getResponse();
    }
    return (T) currentResponse;
}
 

/**
 * Unwrap the response if we have wrapped it.
 */
private void unwrapResponse(State state) {

    if (state.wrapResponse == null)
        return;

    if (state.outerRequest.isAsyncStarted()) {
        if (!state.outerRequest.getAsyncContext().hasOriginalRequestAndResponse()) {
            return;
        }
    }

    ServletResponse previous = null;
    ServletResponse current = state.outerResponse;
    while (current != null) {

        // If we run into the container response we are done
        if ((current instanceof Response)
            || (current instanceof ResponseFacade))
            break;

        // Remove the current response if it is our wrapper
        if (current == state.wrapResponse) {
            ServletResponse next =
              ((ServletResponseWrapper) current).getResponse();
            if (previous == null)
                state.outerResponse = next;
            else
                ((ServletResponseWrapper) previous).setResponse(next);
            break;
        }

        // Advance to the next response in the chain
        previous = current;
        current = ((ServletResponseWrapper) current).getResponse();

    }

}
 

/**
 * Create and return a response wrapper that has been inserted in the
 * appropriate spot in the response chain.
 */
private ServletResponse wrapResponse(State state) {

    // Locate the response we should insert in front of
    ServletResponse previous = null;
    ServletResponse current = state.outerResponse;
    while (current != null) {
        if(state.hresponse == null && (current instanceof HttpServletResponse)) {
            state.hresponse = (HttpServletResponse)current;
            if(!state.including) // Forward only needs hresponse
                return null;
        }
        if (!(current instanceof ServletResponseWrapper))
            break;
        if (current instanceof ApplicationHttpResponse)
            break;
        if (current instanceof ApplicationResponse)
            break;
        previous = current;
        current = ((ServletResponseWrapper) current).getResponse();
    }

    // Instantiate a new wrapper at this point and insert it in the chain
    ServletResponse wrapper = null;
    if ((current instanceof ApplicationHttpResponse) ||
        (current instanceof Response) ||
        (current instanceof HttpServletResponse))
        wrapper =
            new ApplicationHttpResponse((HttpServletResponse) current,
                    state.including);
    else
        wrapper = new ApplicationResponse(current, state.including);
    if (previous == null)
        state.outerResponse = wrapper;
    else
        ((ServletResponseWrapper) previous).setResponse(wrapper);
    state.wrapResponse = wrapper;
    return (wrapper);

}
 

@Override
public void service(ServletRequest req, ServletResponse resp)
        throws ServletException, IOException {
    if (DispatcherType.ASYNC != req.getDispatcherType()) {
        AsyncContext asyncContext;
        if ("y".equals(req.getParameter(CUSTOM_REQ_RESP))) {
            asyncContext = req.startAsync(
                    new ServletRequestWrapper(req),
                    new ServletResponseWrapper(resp));
        } else {
            asyncContext = req.startAsync();
        }
        if ("y".equals(req.getParameter(EMPTY_DISPATCH))) {
            asyncContext.dispatch();
        } else {
            asyncContext.dispatch("/target");
        }
        try {
            asyncContext.dispatch("/nonExistingServlet");
            TestAsyncContextImpl.track("FAIL");
        } catch (IllegalStateException e) {
            TestAsyncContextImpl.track("OK");
        }
    } else {
        TestAsyncContextImpl.track("DispatchingGenericServletGet-");
    }
}
 

@Override
public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {
    if (req instanceof ServletRequestWrapper
            && res instanceof ServletResponseWrapper) {
        TestAsyncContextImpl.track("CustomGenericServletGet-");
    }
}
 

/**
 * Return an appropriate response object of the specified type, if available,
 * unwrapping the given response as far as necessary.
 * @param response the servlet response to introspect
 * @param requiredType the desired type of response object
 * @return the matching response object, or {@code null} if none
 * of that type is available
 */
@SuppressWarnings("unchecked")
public static <T> T getNativeResponse(ServletResponse response, Class<T> requiredType) {
	if (requiredType != null) {
		if (requiredType.isInstance(response)) {
			return (T) response;
		}
		else if (response instanceof ServletResponseWrapper) {
			return getNativeResponse(((ServletResponseWrapper) response).getResponse(), requiredType);
		}
	}
	return null;
}
 

/**
 * Return an appropriate response object of the specified type, if available,
 * unwrapping the given response as far as necessary.
 * @param response the servlet response to introspect
 * @param requiredType the desired type of response object
 * @return the matching response object, or {@code null} if none
 * of that type is available
 */
@SuppressWarnings("unchecked")
public static <T> T getNativeResponse(ServletResponse response, Class<T> requiredType) {
	if (requiredType != null) {
		if (requiredType.isInstance(response)) {
			return (T) response;
		}
		else if (response instanceof ServletResponseWrapper) {
			return getNativeResponse(((ServletResponseWrapper) response).getResponse(), requiredType);
		}
	}
	return null;
}
 

/**
 * Unwrap the response if we have wrapped it.
 */
private void unwrapResponse(State state) {

    if (state.wrapResponse == null)
        return;

    if (state.outerRequest.isAsyncStarted()) {
        if (!state.outerRequest.getAsyncContext().hasOriginalRequestAndResponse()) {
            return;
        }
    }

    ServletResponse previous = null;
    ServletResponse current = state.outerResponse;
    while (current != null) {

        // If we run into the container response we are done
        if ((current instanceof Response)
            || (current instanceof ResponseFacade))
            break;

        // Remove the current response if it is our wrapper
        if (current == state.wrapResponse) {
            ServletResponse next =
              ((ServletResponseWrapper) current).getResponse();
            if (previous == null)
                state.outerResponse = next;
            else
                ((ServletResponseWrapper) previous).setResponse(next);
            break;
        }

        // Advance to the next response in the chain
        previous = current;
        current = ((ServletResponseWrapper) current).getResponse();

    }

}
 

/**
 * Create and return a response wrapper that has been inserted in the
 * appropriate spot in the response chain.
 */
private ServletResponse wrapResponse(State state) {

    // Locate the response we should insert in front of
    ServletResponse previous = null;
    ServletResponse current = state.outerResponse;
    while (current != null) {
        if(state.hresponse == null && (current instanceof HttpServletResponse)) {
            state.hresponse = (HttpServletResponse)current;
            if(!state.including) // Forward only needs hresponse
                return null;
        }
        if (!(current instanceof ServletResponseWrapper))
            break;
        if (current instanceof ApplicationHttpResponse)
            break;
        if (current instanceof ApplicationResponse)
            break;
        previous = current;
        current = ((ServletResponseWrapper) current).getResponse();
    }

    // Instantiate a new wrapper at this point and insert it in the chain
    ServletResponse wrapper = null;
    if ((current instanceof ApplicationHttpResponse) ||
        (current instanceof Response) ||
        (current instanceof HttpServletResponse))
        wrapper =
            new ApplicationHttpResponse((HttpServletResponse) current,
                    state.including);
    else
        wrapper = new ApplicationResponse(current, state.including);
    if (previous == null)
        state.outerResponse = wrapper;
    else
        ((ServletResponseWrapper) previous).setResponse(wrapper);
    state.wrapResponse = wrapper;
    return (wrapper);

}
 

@Override
public void service(ServletRequest req, ServletResponse resp)
        throws ServletException, IOException {
    if (DispatcherType.ASYNC != req.getDispatcherType()) {
        AsyncContext asyncContext;
        if ("y".equals(req.getParameter(CUSTOM_REQ_RESP))) {
            asyncContext = req.startAsync(
                    new ServletRequestWrapper(req),
                    new ServletResponseWrapper(resp));
        } else {
            asyncContext = req.startAsync();
        }
        if ("y".equals(req.getParameter(EMPTY_DISPATCH))) {
            asyncContext.dispatch();
        } else {
            asyncContext.dispatch("/target");
        }
        try {
            asyncContext.dispatch("/nonExistingServlet");
            TestAsyncContextImpl.track("FAIL");
        } catch (IllegalStateException e) {
            TestAsyncContextImpl.track("OK");
        }
    } else {
        TestAsyncContextImpl.track("DispatchingGenericServletGet-");
    }
}
 

@Override
public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {
    if (req instanceof ServletRequestWrapper
            && res instanceof ServletResponseWrapper) {
        TestAsyncContextImpl.track("CustomGenericServletGet-");
    }
}
 

private void checkSameObjects(ServletRequest appRequest,
        ServletResponse appResponse) throws ServletException {
    ServletRequest originalRequest =
        ApplicationFilterChain.getLastServicedRequest();
    ServletResponse originalResponse =
        ApplicationFilterChain.getLastServicedResponse();

    // Some forwards, eg from valves will not set original values
    if (originalRequest == null || originalResponse == null) {
        return;
    }

    boolean same = false;
    ServletRequest dispatchedRequest = appRequest;

    //find the request that was passed into the service method
    while (originalRequest instanceof ServletRequestWrapper &&
            ((ServletRequestWrapper) originalRequest).getRequest()!=null ) {
        originalRequest =
            ((ServletRequestWrapper) originalRequest).getRequest();
    }
    //compare with the dispatched request
    while (!same) {
        if (originalRequest.equals(dispatchedRequest)) {
            same = true;
        }
        if (!same && dispatchedRequest instanceof ServletRequestWrapper) {
            dispatchedRequest =
                ((ServletRequestWrapper) dispatchedRequest).getRequest();
        } else {
            break;
        }
    }
    if (!same) {
        throw new ServletException(sm.getString(
                "applicationDispatcher.specViolation.request"));
    }

    same = false;
    ServletResponse dispatchedResponse = appResponse;

    //find the response that was passed into the service method
    while (originalResponse instanceof ServletResponseWrapper &&
            ((ServletResponseWrapper) originalResponse).getResponse() !=
                null ) {
        originalResponse =
            ((ServletResponseWrapper) originalResponse).getResponse();
    }
    //compare with the dispatched response
    while (!same) {
        if (originalResponse.equals(dispatchedResponse)) {
            same = true;
        }

        if (!same && dispatchedResponse instanceof ServletResponseWrapper) {
            dispatchedResponse =
                ((ServletResponseWrapper) dispatchedResponse).getResponse();
        } else {
            break;
        }
    }

    if (!same) {
        throw new ServletException(sm.getString(
                "applicationDispatcher.specViolation.response"));
    }
}
 

private void checkSameObjects(ServletRequest appRequest,
        ServletResponse appResponse) throws ServletException {
    ServletRequest originalRequest =
        ApplicationFilterChain.getLastServicedRequest();
    ServletResponse originalResponse =
        ApplicationFilterChain.getLastServicedResponse();
    
    // Some forwards, eg from valves will not set original values 
    if (originalRequest == null || originalResponse == null) {
        return;
    }
    
    boolean same = false;
    ServletRequest dispatchedRequest = appRequest;
    
    //find the request that was passed into the service method
    while (originalRequest instanceof ServletRequestWrapper &&
            ((ServletRequestWrapper) originalRequest).getRequest()!=null ) {
        originalRequest =
            ((ServletRequestWrapper) originalRequest).getRequest();
    }
    //compare with the dispatched request
    while (!same) {
        if (originalRequest.equals(dispatchedRequest)) {
            same = true;
        }
        if (!same && dispatchedRequest instanceof ServletRequestWrapper) {
            dispatchedRequest =
                ((ServletRequestWrapper) dispatchedRequest).getRequest();
        } else {
            break;
        }
    }
    if (!same) {
        throw new ServletException(sm.getString(
                "applicationDispatcher.specViolation.request"));
    }
    
    same = false;
    ServletResponse dispatchedResponse = appResponse;
    
    //find the response that was passed into the service method
    while (originalResponse instanceof ServletResponseWrapper &&
            ((ServletResponseWrapper) originalResponse).getResponse() != 
                null ) {
        originalResponse =
            ((ServletResponseWrapper) originalResponse).getResponse();
    }
    //compare with the dispatched response
    while (!same) {
        if (originalResponse.equals(dispatchedResponse)) {
            same = true;
        }
        
        if (!same && dispatchedResponse instanceof ServletResponseWrapper) {
            dispatchedResponse =
                ((ServletResponseWrapper) dispatchedResponse).getResponse();
        } else {
            break;
        }
    }

    if (!same) {
        throw new ServletException(sm.getString(
                "applicationDispatcher.specViolation.response"));
    }
}
 

private void checkSameObjects(ServletRequest appRequest,
        ServletResponse appResponse) throws ServletException {
    ServletRequest originalRequest =
        ApplicationFilterChain.getLastServicedRequest();
    ServletResponse originalResponse =
        ApplicationFilterChain.getLastServicedResponse();
    
    // Some forwards, eg from valves will not set original values 
    if (originalRequest == null || originalResponse == null) {
        return;
    }
    
    boolean same = false;
    ServletRequest dispatchedRequest = appRequest;
    
    //find the request that was passed into the service method
    while (originalRequest instanceof ServletRequestWrapper &&
            ((ServletRequestWrapper) originalRequest).getRequest()!=null ) {
        originalRequest =
            ((ServletRequestWrapper) originalRequest).getRequest();
    }
    //compare with the dispatched request
    while (!same) {
        if (originalRequest.equals(dispatchedRequest)) {
            same = true;
        }
        if (!same && dispatchedRequest instanceof ServletRequestWrapper) {
            dispatchedRequest =
                ((ServletRequestWrapper) dispatchedRequest).getRequest();
        } else {
            break;
        }
    }
    if (!same) {
        throw new ServletException(sm.getString(
                "applicationDispatcher.specViolation.request"));
    }
    
    same = false;
    ServletResponse dispatchedResponse = appResponse;
    
    //find the response that was passed into the service method
    while (originalResponse instanceof ServletResponseWrapper &&
            ((ServletResponseWrapper) originalResponse).getResponse() != 
                null ) {
        originalResponse =
            ((ServletResponseWrapper) originalResponse).getResponse();
    }
    //compare with the dispatched response
    while (!same) {
        if (originalResponse.equals(dispatchedResponse)) {
            same = true;
        }
        
        if (!same && dispatchedResponse instanceof ServletResponseWrapper) {
            dispatchedResponse =
                ((ServletResponseWrapper) dispatchedResponse).getResponse();
        } else {
            break;
        }
    }

    if (!same) {
        throw new ServletException(sm.getString(
                "applicationDispatcher.specViolation.response"));
    }
}