Examples with MappingData org.apache.tomcat.util.http.mapper.MappingData used on opensource projects

Example 1 with MappingData

use of org.apache.tomcat.util.http.mapper.MappingData in project tomcat70 by apache.

the class ApplicationContext method getContext.

/**
 * Return a <code>ServletContext</code> object that corresponds to a
 * specified URI on the server.  This method allows servlets to gain
 * access to the context for various parts of the server, and as needed
 * obtain <code>RequestDispatcher</code> objects or resources from the
 * context.  The given path must be absolute (beginning with a "/"),
 * and is interpreted based on our virtual host's document root.
 *
 * @param uri Absolute URI of a resource on the server
 */
@Override
public ServletContext getContext(String uri) {
    // Validate the format of the specified argument
    if (uri == null || !uri.startsWith("/")) {
        return null;
    }
    Context child = null;
    try {
        // Look for an exact match
        Container host = context.getParent();
        child = (Context) host.findChild(uri);
        // Non-running contexts should be ignored.
        if (child != null && !child.getState().isAvailable()) {
            child = null;
        }
        // Remove any version information and use the mapper
        if (child == null) {
            int i = uri.indexOf("##");
            if (i > -1) {
                uri = uri.substring(0, i);
            }
            // Note: This could be more efficient with a dedicated Mapper
            // method but such an implementation would require some
            // refactoring of the Mapper to avoid copy/paste of
            // existing code.
            MessageBytes hostMB = MessageBytes.newInstance();
            hostMB.setString(host.getName());
            MessageBytes pathMB = MessageBytes.newInstance();
            pathMB.setString(uri);
            MappingData mappingData = new MappingData();
            ((Engine) host.getParent()).getService().findConnectors()[0].getMapper().map(hostMB, pathMB, null, mappingData);
            child = (Context) mappingData.context;
        }
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        return null;
    }
    if (child == null) {
        return null;
    }
    if (context.getCrossContext()) {
        // If crossContext is enabled, can always return the context
        return child.getServletContext();
    } else if (child == context) {
        // Can still return the current context
        return context.getServletContext();
    } else {
        // Nothing to return
        return null;
    }
}

Example 2 with MappingData

use of org.apache.tomcat.util.http.mapper.MappingData in project tomcat70 by apache.

the class ApplicationContext method getRequestDispatcher.

/**
 * Return a <code>RequestDispatcher</code> instance that acts as a
 * wrapper for the resource at the given path.  The path must begin
 * with a "/" and is interpreted as relative to the current context root.
 *
 * @param path The path to the desired resource.
 */
@Override
public RequestDispatcher getRequestDispatcher(final String path) {
    // Validate the path argument
    if (path == null) {
        return (null);
    }
    if (!path.startsWith("/")) {
        throw new IllegalArgumentException(sm.getString("applicationContext.requestDispatcher.iae", path));
    }
    // Need to separate the query string and the uri. This is required for
    // the ApplicationDispatcher constructor. Mapping also requires the uri
    // without the query string.
    String uri;
    String queryString;
    int pos = path.indexOf('?');
    if (pos >= 0) {
        uri = path.substring(0, pos);
        queryString = path.substring(pos + 1);
    } else {
        uri = path;
        queryString = null;
    }
    String normalizedPath = RequestUtil.normalize(uri);
    if (normalizedPath == null) {
        return (null);
    }
    if (getContext().getDispatchersUseEncodedPaths()) {
        // Decode
        String decodedPath;
        try {
            decodedPath = URLDecoder.decode(normalizedPath, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            // Impossible
            return null;
        }
        // Security check to catch attempts to encode /../ sequences
        normalizedPath = RequestUtil.normalize(decodedPath);
        if (!decodedPath.equals(normalizedPath)) {
            getContext().getLogger().warn(sm.getString("applicationContext.illegalDispatchPath", path), new IllegalArgumentException());
            return null;
        }
        // URI needs to include the context path
        uri = URLEncoder.DEFAULT.encode(getContextPath(), "UTF-8") + uri;
    } else {
        // uri is passed to the constructor for ApplicationDispatcher and is
        // ultimately used as the value for getRequestURI() which returns
        // encoded values. Therefore, since the value passed in for path
        // was decoded, encode uri here.
        uri = URLEncoder.DEFAULT.encode(getContextPath() + uri, "UTF-8");
    }
    pos = normalizedPath.length();
    // Use the thread local URI and mapping data
    DispatchData dd = dispatchData.get();
    if (dd == null) {
        dd = new DispatchData();
        dispatchData.set(dd);
    }
    MessageBytes uriMB = dd.uriMB;
    uriMB.recycle();
    // Use the thread local mapping data
    MappingData mappingData = dd.mappingData;
    // Map the URI
    CharChunk uriCC = uriMB.getCharChunk();
    try {
        uriCC.append(context.getPath(), 0, context.getPath().length());
        /*
             * Ignore any trailing path params (separated by ';') for mapping
             * purposes
             */
        int semicolon = normalizedPath.indexOf(';');
        if (pos >= 0 && semicolon > pos) {
            semicolon = -1;
        }
        uriCC.append(normalizedPath, 0, semicolon > 0 ? semicolon : pos);
        context.getMapper().map(uriMB, mappingData);
        if (mappingData.wrapper == null) {
            return (null);
        }
        /*
             * Append any trailing path params (separated by ';') that were
             * ignored for mapping purposes, so that they're reflected in the
             * RequestDispatcher's requestURI
             */
        if (semicolon > 0) {
            uriCC.append(normalizedPath, semicolon, pos - semicolon);
        }
    } catch (Exception e) {
        // Should never happen
        log(sm.getString("applicationContext.mapping.error"), e);
        return (null);
    }
    Wrapper wrapper = (Wrapper) mappingData.wrapper;
    String wrapperPath = mappingData.wrapperPath.toString();
    String pathInfo = mappingData.pathInfo.toString();
    mappingData.recycle();
    // Construct a RequestDispatcher to process this request
    return new ApplicationDispatcher(wrapper, uri, wrapperPath, pathInfo, queryString, null);
}