/* ------------------------------------------------------------ */
@Override
public void push() {
if (HttpMethod.POST.is(_method) || HttpMethod.PUT.is(_method))
throw new IllegalStateException("Bad Method " + _method);
if (_path == null || _path.length() == 0) throw new IllegalStateException("Bad Path " + _path);
String path = _path;
String query = _queryString;
int q = path.indexOf('?');
if (q >= 0) {
query =
(query != null && query.length() > 0)
? (_path.substring(q + 1) + '&' + query)
: _path.substring(q + 1);
path = _path.substring(0, q);
}
if (!path.startsWith("/")) path = URIUtil.addPaths(_request.getContextPath(), path);
String param = null;
if (_sessionId != null) {
if (_request.isRequestedSessionIdFromURL()) param = "jsessionid=" + _sessionId;
// TODO else
// _fields.add("Cookie","JSESSIONID="+_sessionId);
}
if (_conditional) {
if (_etag != null) _fields.add(HttpHeader.IF_NONE_MATCH, _etag);
else if (_lastModified != null) _fields.add(HttpHeader.IF_MODIFIED_SINCE, _lastModified);
}
HttpURI uri =
HttpURI.createHttpURI(
_request.getScheme(),
_request.getServerName(),
_request.getServerPort(),
_path,
param,
query,
null);
MetaData.Request push = new MetaData.Request(_method, uri, _request.getHttpVersion(), _fields);
if (LOG.isDebugEnabled())
LOG.debug(
"Push {} {} inm={} ims={}",
_method,
uri,
_fields.get(HttpHeader.IF_NONE_MATCH),
_fields.get(HttpHeader.IF_MODIFIED_SINCE));
_request.getHttpChannel().getHttpTransport().push(push);
_path = null;
_etag = null;
_lastModified = null;
}
protected final void train_getContextPath(Request request, String contextPath) {
expect(request.getContextPath()).andReturn(contextPath).atLeastOnce();
}
/*
* @see javax.servlet.RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
*/
protected void forward(ServletRequest request, ServletResponse response, DispatcherType dispatch)
throws ServletException, IOException {
Request baseRequest =
(request instanceof Request)
? ((Request) request)
: HttpChannel.getCurrentHttpChannel().getRequest();
Response base_response = baseRequest.getResponse();
base_response.resetForForward();
if (!(request instanceof HttpServletRequest)) request = new ServletRequestHttpWrapper(request);
if (!(response instanceof HttpServletResponse))
response = new ServletResponseHttpWrapper(response);
final boolean old_handled = baseRequest.isHandled();
final String old_uri = baseRequest.getRequestURI();
final String old_context_path = baseRequest.getContextPath();
final String old_servlet_path = baseRequest.getServletPath();
final String old_path_info = baseRequest.getPathInfo();
final String old_query = baseRequest.getQueryString();
final Attributes old_attr = baseRequest.getAttributes();
final DispatcherType old_type = baseRequest.getDispatcherType();
MultiMap<String> old_params = baseRequest.getParameters();
try {
baseRequest.setHandled(false);
baseRequest.setDispatcherType(dispatch);
if (_named != null)
_contextHandler.handle(
_named, baseRequest, (HttpServletRequest) request, (HttpServletResponse) response);
else {
// process any query string from the dispatch URL
String query = _dQuery;
if (query != null) {
// force parameter extraction
if (old_params == null) {
baseRequest.extractParameters();
old_params = baseRequest.getParameters();
}
baseRequest.mergeQueryString(query);
}
ForwardAttributes attr = new ForwardAttributes(old_attr);
// If we have already been forwarded previously, then keep using the established
// original value. Otherwise, this is the first forward and we need to establish the values.
// Note: the established value on the original request for pathInfo and
// for queryString is allowed to be null, but cannot be null for the other values.
if (old_attr.getAttribute(FORWARD_REQUEST_URI) != null) {
attr._pathInfo = (String) old_attr.getAttribute(FORWARD_PATH_INFO);
attr._query = (String) old_attr.getAttribute(FORWARD_QUERY_STRING);
attr._requestURI = (String) old_attr.getAttribute(FORWARD_REQUEST_URI);
attr._contextPath = (String) old_attr.getAttribute(FORWARD_CONTEXT_PATH);
attr._servletPath = (String) old_attr.getAttribute(FORWARD_SERVLET_PATH);
} else {
attr._pathInfo = old_path_info;
attr._query = old_query;
attr._requestURI = old_uri;
attr._contextPath = old_context_path;
attr._servletPath = old_servlet_path;
}
baseRequest.setRequestURI(_uri);
baseRequest.setContextPath(_contextHandler.getContextPath());
baseRequest.setServletPath(null);
baseRequest.setPathInfo(_uri);
baseRequest.setAttributes(attr);
_contextHandler.handle(
_path, baseRequest, (HttpServletRequest) request, (HttpServletResponse) response);
if (!baseRequest.getHttpChannelState().isAsync()) commitResponse(response, baseRequest);
}
} finally {
baseRequest.setHandled(old_handled);
baseRequest.setRequestURI(old_uri);
baseRequest.setContextPath(old_context_path);
baseRequest.setServletPath(old_servlet_path);
baseRequest.setPathInfo(old_path_info);
baseRequest.setAttributes(old_attr);
baseRequest.setParameters(old_params);
baseRequest.setQueryString(old_query);
baseRequest.setDispatcherType(old_type);
}
}
@Override
public String encodeURL(String url) {
final Request request = _channel.getRequest();
SessionManager sessionManager = request.getSessionManager();
if (sessionManager == null) return url;
HttpURI uri = null;
if (sessionManager.isCheckingRemoteSessionIdEncoding() && URIUtil.hasScheme(url)) {
uri = new HttpURI(url);
String path = uri.getPath();
path = (path == null ? "" : path);
int port = uri.getPort();
if (port < 0) port = HttpScheme.HTTPS.asString().equalsIgnoreCase(uri.getScheme()) ? 443 : 80;
if (!request.getServerName().equalsIgnoreCase(uri.getHost())
|| request.getServerPort() != port
|| !path.startsWith(
request
.getContextPath())) // TODO the root context path is "", with which every non null
// string starts
return url;
}
String sessionURLPrefix = sessionManager.getSessionIdPathParameterNamePrefix();
if (sessionURLPrefix == null) return url;
if (url == null) return null;
// should not encode if cookies in evidence
if (request.isRequestedSessionIdFromCookie()) {
int prefix = url.indexOf(sessionURLPrefix);
if (prefix != -1) {
int suffix = url.indexOf("?", prefix);
if (suffix < 0) suffix = url.indexOf("#", prefix);
if (suffix <= prefix) return url.substring(0, prefix);
return url.substring(0, prefix) + url.substring(suffix);
}
return url;
}
// get session;
HttpSession session = request.getSession(false);
// no session
if (session == null) return url;
// invalid session
if (!sessionManager.isValid(session)) return url;
String id = sessionManager.getNodeId(session);
if (uri == null) uri = new HttpURI(url);
// Already encoded
int prefix = url.indexOf(sessionURLPrefix);
if (prefix != -1) {
int suffix = url.indexOf("?", prefix);
if (suffix < 0) suffix = url.indexOf("#", prefix);
if (suffix <= prefix) return url.substring(0, prefix + sessionURLPrefix.length()) + id;
return url.substring(0, prefix + sessionURLPrefix.length()) + id + url.substring(suffix);
}
// edit the session
int suffix = url.indexOf('?');
if (suffix < 0) suffix = url.indexOf('#');
if (suffix < 0) {
return url
+ ((HttpScheme.HTTPS.is(uri.getScheme()) || HttpScheme.HTTP.is(uri.getScheme()))
&& uri.getPath() == null
? "/"
: "")
+ // if no path, insert the root path
sessionURLPrefix
+ id;
}
return url.substring(0, suffix)
+ ((HttpScheme.HTTPS.is(uri.getScheme()) || HttpScheme.HTTP.is(uri.getScheme()))
&& uri.getPath() == null
? "/"
: "")
+ // if no path so insert the root path
sessionURLPrefix
+ id
+ url.substring(suffix);
}