/*
* 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 org.apache.tomcat.lite.http;
import java.io.IOException;
import java.util.logging.Logger;
import org.apache.tomcat.lite.http.HttpChannel.HttpService;
import org.apache.tomcat.lite.io.CBuffer;
import org.apache.tomcat.lite.io.FileConnector;
import org.apache.tomcat.lite.io.BBucket;
/**
* Mapper, which implements the servlet API mapping rules (which are derived
* from the HTTP rules).
*
* This class doesn't use JNDI.
*/
public class BaseMapper {
private static Logger logger =
Logger.getLogger(BaseMapper.class.getName());
// TODO:
/**
* Mapping should be done on bytes - as received from net, before
* translation to chars. This would allow setting the default charset
* for the context - or even executing the servlet and letting it specify
* the charset to use for further decoding.
*
*/
public static interface Mapper {
public void map(BBucket host, BBucket url, MappingData md);
}
/**
* Like BaseMapper, for a Context.
*/
public static class ServiceMapper extends BaseMapper {
/**
* Context associated with this wrapper, used for wrapper mapping.
*/
public BaseMapper.Context contextMapElement = new BaseMapper.Context(this);
/**
* Set context, used for wrapper mapping (request dispatcher).
*
* @param welcomeResources Welcome files defined for this context
*/
public void setContext(String path, String[] welcomeResources) {
contextMapElement.name = path;
contextMapElement.welcomeResources = welcomeResources;
}
/**
* Add a wrapper to the context associated with this wrapper.
*
* @param path Wrapper mapping
* @param wrapper The Wrapper object
*/
public void addWrapper(String path, Object wrapper) {
addWrapper(contextMapElement, path, wrapper);
}
public void addWrapper(String path, Object wrapper, boolean jspWildCard) {
addWrapper(contextMapElement, path, wrapper, jspWildCard);
}
/**
* Remove a wrapper from the context associated with this wrapper.
*
* @param path Wrapper mapping
*/
public void removeWrapper(String path) {
removeWrapper(contextMapElement, path);
}
// /**
// * Map the specified URI relative to the context,
// * mutating the given mapping data.
// *
// * @param uri URI
// * @param mappingData This structure will contain the result of the mapping
// * operation
// */
// public void map(CBuffer uri, MappingData mappingData)
// throws Exception {
//
// CBuffer uricc = uri.getCharBuffer();
// internalMapWrapper(contextMapElement, uricc, mappingData);
//
// }
}
/**
* Array containing the virtual hosts definitions.
*/
Host[] hosts = new Host[0];
/**
* If no other host is found.
* For single-host servers ( most common ) this is the only one
* used.
*/
Host defaultHost = new Host();
public BaseMapper() {
defaultHost.contextList = new ContextList();
}
// --------------------------------------------------------- Public Methods
public synchronized Host addHost(String name) {
if (name == null) {
name = "localhost";
}
Host[] newHosts = new Host[hosts.length + 1];
Host newHost = new Host();
newHost.name = name;
newHost.contextList = new ContextList();
if (insertMap(hosts, newHosts, newHost)) {
hosts = newHosts;
}
return newHost;
}
/**
* Remove a host from the mapper.
*
* @param name Virtual host name
*/
public synchronized void removeHost(String name) {
// Find and remove the old host
int pos = find(hosts, name);
if (pos < 0) {
return;
}
Object host = hosts[pos].object;
Host[] newHosts = new Host[hosts.length - 1];
if (removeMap(hosts, newHosts, name)) {
hosts = newHosts;
}
// Remove all aliases (they will map to the same host object)
for (int i = 0; i < newHosts.length; i++) {
if (newHosts[i].object == host) {
Host[] newHosts2 = new Host[hosts.length - 1];
if (removeMap(hosts, newHosts2, newHosts[i].name)) {
hosts = newHosts2;
}
}
}
}
/**
* Add an alias to an existing host.
* @param name The name of the host
* @param alias The alias to add
*/
public synchronized void addHostAlias(String name, String alias) {
int pos = find(hosts, name);
if (pos < 0) {
// Should not be adding an alias for a host that doesn't exist but
// just in case...
return;
}
Host realHost = hosts[pos];
Host[] newHosts = new Host[hosts.length + 1];
Host newHost = new Host();
newHost.name = alias;
newHost.contextList = realHost.contextList;
newHost.object = realHost;
if (insertMap(hosts, newHosts, newHost)) {
hosts = newHosts;
}
}
private Host getHost(String host) {
return getHost(CBuffer.newInstance().append(host));
}
private Host getHost(CBuffer host) {
if (hosts == null || hosts.length <= 1 || host == null
|| host.length() == 0 || host.equals("")) {
return defaultHost;
} else {
Host[] hosts = this.hosts;
// TODO: if hosts.length == 1 or defaultHost ?
int pos = findIgnoreCase(hosts, host);
if ((pos != -1) && (host.equalsIgnoreCase(hosts[pos].name))) {
return hosts[pos];
} else {
return defaultHost;
}
}
}
private Host getOrCreateHost(String hostName) {
Host host = getHost(CBuffer.newInstance().append(hostName));
if (host == null) {
host = addHost(hostName);
}
return host;
}
// Contexts
/**
* Add a new Context to an existing Host.
*
* @param hostName Virtual host name this context belongs to
* @param path Context path
* @param context Context object
* @param welcomeResources Welcome files defined for this context
* @param resources Static resources of the context
* @param ctxService
*/
public BaseMapper.Context addContext(String hostName, String path, Object context,
String[] welcomeResources, FileConnector resources,
HttpChannel.HttpService ctxService) {
if (path == null) {
path = "/";
}
Host host = getOrCreateHost(hostName);
int slashCount = slashCount(path);
synchronized (host) {
BaseMapper.Context[] contexts = host.contextList.contexts;
// Update nesting
if (slashCount > host.contextList.nesting) {
host.contextList.nesting = slashCount;
}
for (int i = 0; i < contexts.length; i++) {
if (path.equals(contexts[i].name)) {
return contexts[i];
}
}
BaseMapper.Context[] newContexts = new BaseMapper.Context[contexts.length + 1];
BaseMapper.Context newContext = new BaseMapper.Context(this);
newContext.name = path;
newContext.object = context;
if (welcomeResources != null) {
newContext.welcomeResources = welcomeResources;
}
newContext.resources = resources;
if (ctxService != null) {
newContext.defaultWrapper = new BaseMapper.ServiceMapping();
newContext.defaultWrapper.object = ctxService;
}
if (insertMap(contexts, newContexts, newContext)) {
host.contextList.contexts = newContexts;
}
return newContext;
}
}
/**
* Remove a context from an existing host.
*
* @param hostName Virtual host name this context belongs to
* @param path Context path
*/
public void removeContext(String hostName, String path) {
Host host = getHost(hostName);
synchronized (host) {
BaseMapper.Context[] contexts = host.contextList.contexts;
if( contexts.length == 0 ){
return;
}
BaseMapper.Context[] newContexts = new BaseMapper.Context[contexts.length - 1];
if (removeMap(contexts, newContexts, path)) {
host.contextList.contexts = newContexts;
// Recalculate nesting
host.contextList.nesting = 0;
for (int i = 0; i < newContexts.length; i++) {
int slashCount = slashCount(newContexts[i].name);
if (slashCount > host.contextList.nesting) {
host.contextList.nesting = slashCount;
}
}
}
}
}
/**
* Add a new Wrapper to an existing Context.
*
* @param hostName Virtual host name this wrapper belongs to
* @param contextPath Context path this wrapper belongs to
* @param path Wrapper mapping
* @param wrapper Wrapper object
*/
public void addWrapper(String hostName, String contextPath, String path,
Object wrapper) {
addWrapper(hostName, contextPath, path, wrapper, false);
}
public void addWrapper(String hostName, String contextPath, String path,
Object wrapper, boolean jspWildCard) {
Host host = getHost(hostName);
BaseMapper.Context[] contexts = host.contextList.contexts;
int pos2 = find(contexts, contextPath);
if( pos2<0 ) {
logger.severe("No context found: " + contextPath );
return;
}
BaseMapper.Context context = contexts[pos2];
if (context.name.equals(contextPath)) {
addWrapper(context, path, wrapper, jspWildCard);
}
}
public void addWrapper(BaseMapper.Context context, String path, Object wrapper) {
addWrapper(context, path, wrapper, false);
}
/**
* Adds a wrapper to the given context.
*
* @param context The context to which to add the wrapper
* @param path Wrapper mapping
* @param wrapper The Wrapper object
* @param jspWildCard true if the wrapper corresponds to the JspServlet
* and the mapping path contains a wildcard; false otherwise
*/
protected void addWrapper(BaseMapper.Context context, String path, Object wrapper,
boolean jspWildCard) {
synchronized (context) {
BaseMapper.ServiceMapping newWrapper = new BaseMapper.ServiceMapping();
newWrapper.object = wrapper;
newWrapper.jspWildCard = jspWildCard;
if (path.endsWith("/*")) {
// Wildcard wrapper
newWrapper.name = path.substring(0, path.length() - 2);
BaseMapper.ServiceMapping[] oldWrappers = context.wildcardWrappers;
BaseMapper.ServiceMapping[] newWrappers =
new BaseMapper.ServiceMapping[oldWrappers.length + 1];
if (insertMap(oldWrappers, newWrappers, newWrapper)) {
context.wildcardWrappers = newWrappers;
int slashCount = slashCount(newWrapper.name);
if (slashCount > context.nesting) {
context.nesting = slashCount;
}
}
} else if (path.startsWith("*.")) {
// Extension wrapper
newWrapper.name = path.substring(2);
BaseMapper.ServiceMapping[] oldWrappers = context.extensionWrappers;
BaseMapper.ServiceMapping[] newWrappers =
new BaseMapper.ServiceMapping[oldWrappers.length + 1];
if (insertMap(oldWrappers, newWrappers, newWrapper)) {
context.extensionWrappers = newWrappers;
}
} else if (path.equals("/")) {
// Default wrapper
newWrapper.name = "";
context.defaultWrapper = newWrapper;
} else {
// Exact wrapper
newWrapper.name = path;
BaseMapper.ServiceMapping[] oldWrappers = context.exactWrappers;
BaseMapper.ServiceMapping[] newWrappers =
new BaseMapper.ServiceMapping[oldWrappers.length + 1];
if (insertMap(oldWrappers, newWrappers, newWrapper)) {
context.exactWrappers = newWrappers;
}
}
}
}
/**
* Remove a wrapper from an existing context.
*
* @param hostName Virtual host name this wrapper belongs to
* @param contextPath Context path this wrapper belongs to
* @param path Wrapper mapping
*/
public void removeWrapper(String hostName, String contextPath,
String path) {
Host host = getHost(hostName);
BaseMapper.Context[] contexts = host.contextList.contexts;
int pos2 = find(contexts, contextPath);
if (pos2 < 0) {
return;
}
BaseMapper.Context context = contexts[pos2];
if (context.name.equals(contextPath)) {
removeWrapper(context, path);
}
}
protected void removeWrapper(BaseMapper.Context context, String path) {
synchronized (context) {
if (path.endsWith("/*")) {
// Wildcard wrapper
String name = path.substring(0, path.length() - 2);
BaseMapper.ServiceMapping[] oldWrappers = context.wildcardWrappers;
BaseMapper.ServiceMapping[] newWrappers =
new BaseMapper.ServiceMapping[oldWrappers.length - 1];
if (removeMap(oldWrappers, newWrappers, name)) {
// Recalculate nesting
context.nesting = 0;
for (int i = 0; i < newWrappers.length; i++) {
int slashCount = slashCount(newWrappers[i].name);
if (slashCount > context.nesting) {
context.nesting = slashCount;
}
}
context.wildcardWrappers = newWrappers;
}
} else if (path.startsWith("*.")) {
// Extension wrapper
String name = path.substring(2);
BaseMapper.ServiceMapping[] oldWrappers = context.extensionWrappers;
BaseMapper.ServiceMapping[] newWrappers =
new BaseMapper.ServiceMapping[oldWrappers.length - 1];
if (removeMap(oldWrappers, newWrappers, name)) {
context.extensionWrappers = newWrappers;
}
} else if (path.equals("/")) {
// Default wrapper
context.defaultWrapper = null;
} else {
// Exact wrapper
String name = path;
BaseMapper.ServiceMapping[] oldWrappers = context.exactWrappers;
BaseMapper.ServiceMapping[] newWrappers =
new BaseMapper.ServiceMapping[oldWrappers.length - 1];
if (removeMap(oldWrappers, newWrappers, name)) {
context.exactWrappers = newWrappers;
}
}
}
}
/**
* Map the specified host name and URI, mutating the given mapping data.
*
* @param host Virtual host name
* @param uri URI
* @param mappingData This structure will contain the result of the mapping
* operation
*/
public void map(CBuffer host, CBuffer uri,
MappingData mappingData)
throws Exception {
internalMap(host.length() == 0 ? null :
host, uri, mappingData);
}
// -------------------------------------------------------- Private Methods
// public Context mapContext(CBuffer host, CBuffer url);
/**
* Map the specified URI.
*/
private final void internalMap(CBuffer host, CBuffer uri,
MappingData mappingData)
throws Exception {
BaseMapper.Context[] contexts = null;
BaseMapper.Context context = null;
int nesting = 0;
// Virtual host mapping
Host mappedHost = getHost(host);
contexts = mappedHost.contextList.contexts;
nesting = mappedHost.contextList.nesting;
// Context mapping
if (contexts.length == 0) {
return;
}
if (mappingData.context == null) {
if (nesting < 1 || contexts.length == 1 && "".equals(contexts[0].name)) {
// if 1 context (default) -> fast return
context = contexts[0];
} else if (nesting == 1) {
// if all contexts are 1-component-only
int nextSlash = uri.indexOf('/', 1);
if (nextSlash == -1) {
nextSlash = uri.length();
}
mappingData.contextPath.set(uri, 0, nextSlash);
int pos = find(contexts, uri);
if (pos == -1) {
pos = find(contexts, "/");
}
if (pos >= 0) {
context = contexts[pos];
}
} else {
int pos = find(contexts, uri);
if (pos >= 0) {
int lastSlash = -1;
int length = -1;
boolean found = false;
CBuffer tmp = mappingData.tmpPrefix;
tmp.wrap(uri, 0, uri.length());
while (pos >= 0) {
if (tmp.startsWith(contexts[pos].name)) {
length = contexts[pos].name.length();
if (tmp.length() == length) {
found = true;
break;
} else if (tmp.startsWithIgnoreCase("/", length)) {
found = true;
break;
}
}
if (lastSlash == -1) {
lastSlash = tmp.nthSlash(nesting + 1);
} else {
lastSlash = tmp.lastIndexOf('/');
}
tmp.delete(lastSlash);
pos = find(contexts, tmp);
}
if (!found) {
if (contexts[0].name.equals("")) {
context = contexts[0];
}
} else {
context = contexts[pos];
}
}
}
if (context != null) {
mappingData.context = context.object;
mappingData.contextPath.set(context.name);
}
}
// Wrapper mapping
if ((context != null) && (mappingData.getServiceObject() == null)) {
internalMapWrapper(context, uri, mappingData);
}
}
/**
* Wrapper mapping, using servlet rules.
*/
protected final void internalMapWrapper(
BaseMapper.Context context,
CBuffer url,
MappingData mappingData)
throws Exception {
boolean noServletPath = false;
if (url.length() < context.name.length()) {
throw new IOException("Invalid mapping " + context.name + " " +
url);
}
try {
// Set the servlet path.
mappingData.tmpServletPath.set(url,
context.name.length(),
url.length() - context.name.length());
if (mappingData.tmpServletPath.length() == 0) {
mappingData.tmpServletPath.append('/');
// This is just the context /example or /
if (!context.name.equals("/")) {
noServletPath = true;
}
}
mapAfterContext(context, url, mappingData.tmpServletPath, mappingData,
noServletPath);
} catch (ArrayIndexOutOfBoundsException ex) {
System.err.println(1);
}
}
void mapAfterContext(BaseMapper.Context context,
CBuffer url, CBuffer urlNoContext,
MappingData mappingData, boolean noServletPath)
throws Exception {
// Rule 1 -- Exact Match
BaseMapper.ServiceMapping[] exactWrappers = context.exactWrappers;
internalMapExactWrapper(exactWrappers, urlNoContext, mappingData);
// Rule 2 -- Prefix Match
boolean checkJspWelcomeFiles = false;
BaseMapper.ServiceMapping[] wildcardWrappers = context.wildcardWrappers;
if (mappingData.getServiceObject() == null) {
internalMapWildcardWrapper(wildcardWrappers, context.nesting,
urlNoContext, mappingData);
if (mappingData.getServiceObject() != null
&& mappingData.service.jspWildCard) {
if (urlNoContext.lastChar() == '/') {
/*
* Path ending in '/' was mapped to JSP servlet based on
* wildcard match (e.g., as specified in url-pattern of a
* jsp-property-group.
* Force the context's welcome files, which are interpreted
* as JSP files (since they match the url-pattern), to be
* considered. See Bugzilla 27664.
*/
mappingData.service = null;
checkJspWelcomeFiles = true;
} else {
// See Bugzilla 27704
mappingData.wrapperPath.set(urlNoContext);
mappingData.pathInfo.recycle();
}
}
}
if(mappingData.getServiceObject() == null && noServletPath) {
// The path is empty, redirect to "/"
mappingData.redirectPath.set(context.name);
mappingData.redirectPath.append("/");
return;
}
// Rule 3 -- Extension Match
BaseMapper.ServiceMapping[] extensionWrappers = context.extensionWrappers;
if (mappingData.getServiceObject() == null && !checkJspWelcomeFiles) {
internalMapExtensionWrapper(extensionWrappers, urlNoContext, mappingData);
}
// Rule 4 -- Welcome resources processing for servlets
if (mappingData.getServiceObject() == null) {
boolean checkWelcomeFiles = checkJspWelcomeFiles;
if (!checkWelcomeFiles) {
checkWelcomeFiles = (urlNoContext.lastChar() == '/');
}
if (checkWelcomeFiles) {
for (int i = 0; (i < context.welcomeResources.length)
&& (mappingData.getServiceObject() == null); i++) {
CBuffer wpath = mappingData.tmpWelcome;
wpath.set(urlNoContext);
wpath.append(context.welcomeResources[i]);
// Rule 4a -- Welcome resources processing for exact macth
internalMapExactWrapper(exactWrappers, urlNoContext, mappingData);
// Rule 4b -- Welcome resources processing for prefix match
if (mappingData.getServiceObject() == null) {
internalMapWildcardWrapper
(wildcardWrappers, context.nesting,
urlNoContext, mappingData);
}
// Rule 4c -- Welcome resources processing
// for physical folder
if (mappingData.getServiceObject() == null
&& context.resources != null) {
String pathStr = urlNoContext.toString();
mapWelcomResource(context, urlNoContext, mappingData,
extensionWrappers, pathStr);
}
}
}
}
// Rule 7 -- Default servlet
if (mappingData.getServiceObject() == null && !checkJspWelcomeFiles) {
if (context.defaultWrapper != null) {
mappingData.service = context.defaultWrapper;
mappingData.requestPath.set(urlNoContext);
mappingData.wrapperPath.set(urlNoContext);
}
// Redirection to a folder
if (context.resources != null && urlNoContext.lastChar() != '/') {
String pathStr = urlNoContext.toString();
mapDefaultServlet(context, urlNoContext, mappingData,
url,
pathStr);
}
}
}
/**
* Filesystem-dependent method:
* if pathStr corresponds to a directory, we'll need to redirect with /
* at end.
*/
protected void mapDefaultServlet(BaseMapper.Context context,
CBuffer path,
MappingData mappingData,
CBuffer url,
String pathStr) throws IOException {
if (context.resources != null
&& context.resources.isDirectory(pathStr)) {
mappingData.redirectPath.set(url);
mappingData.redirectPath.append("/");
} else {
mappingData.requestPath.set(pathStr);
mappingData.wrapperPath.set(pathStr);
}
}
/**
* Filesystem dependent method:
* check if a resource exists in filesystem.
*/
protected void mapWelcomResource(BaseMapper.Context context, CBuffer path,
MappingData mappingData,
BaseMapper.ServiceMapping[] extensionWrappers, String pathStr) {
if (context.resources != null &&
context.resources.isFile(pathStr)) {
internalMapExtensionWrapper(extensionWrappers,
path, mappingData);
if (mappingData.getServiceObject() == null
&& context.defaultWrapper != null) {
mappingData.service = context.defaultWrapper;
mappingData.requestPath.set(path);
mappingData.wrapperPath.set(path);
mappingData.requestPath.set(pathStr);
mappingData.wrapperPath.set(pathStr);
}
}
}
/**
* Exact mapping.
*/
private final void internalMapExactWrapper
(BaseMapper.ServiceMapping[] wrappers, CBuffer path, MappingData mappingData) {
int pos = find(wrappers, path);
if ((pos != -1) && (path.equals(wrappers[pos].name))) {
mappingData.requestPath.set(wrappers[pos].name);
mappingData.wrapperPath.set(wrappers[pos].name);
mappingData.service = wrappers[pos];
}
}
/**
* Prefix mapping. ( /foo/* )
*/
private final void internalMapWildcardWrapper
(BaseMapper.ServiceMapping[] wrappers, int nesting, CBuffer path,
MappingData mappingData) {
int lastSlash = -1;
int length = -1;
CBuffer tmp = mappingData.tmpPrefix;
tmp.wrap(path, 0, path.length());
int pos = find(wrappers, tmp);
if (pos != -1) {
boolean found = false;
while (pos >= 0) {
if (tmp.startsWith(wrappers[pos].name)) {
length = wrappers[pos].name.length();
if (tmp.length() == length) {
found = true;
break;
} else if (tmp.startsWithIgnoreCase("/", length)) {
found = true;
break;
}
}
if (lastSlash == -1) {
lastSlash = tmp.nthSlash(nesting + 1);
} else {
lastSlash = tmp.lastIndexOf('/');
}
tmp.delete(lastSlash);
pos = find(wrappers, tmp);
}
if (found) {
mappingData.wrapperPath.set(wrappers[pos].name);
if (path.length() > length) {
mappingData.pathInfo.set
(path, length, path.length() - length);
}
mappingData.requestPath.set(path);
mappingData.service = wrappers[pos];
}
}
}
/**
* Extension mappings.
*/
protected final void internalMapExtensionWrapper
(BaseMapper.ServiceMapping[] wrappers, CBuffer path, MappingData mappingData) {
int dot = path.getExtension(mappingData.ext, '/', '.');
if (dot >= 0) {
int pos = find(wrappers, mappingData.ext);
if ((pos != -1)
&& (mappingData.ext.equals(wrappers[pos].name))) {
mappingData.wrapperPath.set(path);
mappingData.requestPath.set(path);
mappingData.service = wrappers[pos];
}
}
}
/**
* Find a map elemnt given its name in a sorted array of map elements.
* This will return the index for the closest inferior or equal item in the
* given array.
*/
private static final int find(BaseMapper.Mapping[] map, CBuffer name) {
int a = 0;
int b = map.length - 1;
// Special cases: -1 and 0
if (b == -1) {
return -1;
}
if (name.compare(map[0].name) < 0 ) {
return -1;
}
if (b == 0) {
return 0;
}
int i = 0;
while (true) {
i = (b + a) / 2;
int result = name.compare(map[i].name);
if (result == 1) {
a = i;
} else if (result == 0) {
return i;
} else {
b = i;
}
if ((b - a) == 1) {
int result2 = name.compare(map[b].name);
if (result2 < 0) {
return a;
} else {
return b;
}
}
}
}
/**
* Find a map elemnt given its name in a sorted array of map elements.
* This will return the index for the closest inferior or equal item in the
* given array.
*/
private static final int findIgnoreCase(BaseMapper.Mapping[] map,
CBuffer name) {
int a = 0;
int b = map.length - 1;
// Special cases: -1 and 0
if (b == -1) {
return -1;
}
if (name.compareIgnoreCase(map[0].name) < 0 ) {
return -1;
}
if (b == 0) {
return 0;
}
int i = 0;
while (true) {
i = (b + a) / 2;
int result = name.compareIgnoreCase(map[i].name);
if (result == 1) {
a = i;
} else if (result == 0) {
return i;
} else {
b = i;
}
if ((b - a) == 1) {
int result2 = name.compareIgnoreCase(map[b].name);
if (result2 < 0) {
return a;
} else {
return b;
}
}
}
}
/**
* Find a map element given its name in a sorted array of map elements.
* This will return the index for the closest inferior or equal item in the
* given array.
*/
private static final int find(BaseMapper.Mapping[] map, String name) {
int a = 0;
int b = map.length - 1;
// Special cases: -1 and 0
if (b == -1) {
return -1;
}
if (name.compareTo(map[0].name) < 0) {
return -1;
}
if (b == 0) {
return 0;
}
int i = 0;
while (true) {
i = (b + a) / 2;
int result = name.compareTo(map[i].name);
if (result > 0) {
a = i;
} else if (result == 0) {
return i;
} else {
b = i;
}
if ((b - a) == 1) {
int result2 = name.compareTo(map[b].name);
if (result2 < 0) {
return a;
} else {
return b;
}
}
}
}
/**
* Return the slash count in a given string.
*/
private static final int slashCount(String name) {
int pos = -1;
int count = 0;
while ((pos = name.indexOf('/', pos + 1)) != -1) {
count++;
}
return count;
}
/**
* Insert into the right place in a sorted MapElement array, and prevent
* duplicates.
*/
private static final boolean insertMap
(BaseMapper.Mapping[] oldMap, BaseMapper.Mapping[] newMap, BaseMapper.Mapping newElement) {
int pos = find(oldMap, newElement.name);
if ((pos != -1) && (newElement.name.equals(oldMap[pos].name))) {
return false;
}
System.arraycopy(oldMap, 0, newMap, 0, pos + 1);
newMap[pos + 1] = newElement;
System.arraycopy
(oldMap, pos + 1, newMap, pos + 2, oldMap.length - pos - 1);
return true;
}
/**
* Insert into the right place in a sorted MapElement array.
*/
private static final boolean removeMap
(BaseMapper.Mapping[] oldMap, BaseMapper.Mapping[] newMap, String name) {
int pos = find(oldMap, name);
if ((pos != -1) && (name.equals(oldMap[pos].name))) {
System.arraycopy(oldMap, 0, newMap, 0, pos);
System.arraycopy(oldMap, pos + 1, newMap, pos,
oldMap.length - pos - 1);
return true;
}
return false;
}
// ------------------------------------------------- MapElement Inner Class
protected static final class Host
extends BaseMapper.Mapping {
//Map<String, Context> contexts = new HashMap();
//Context rootContext;
public ContextList contextList = null;
}
// ------------------------------------------------ ContextList Inner Class
// Shared among host aliases.
protected static final class ContextList {
public BaseMapper.Context[] contexts = new BaseMapper.Context[0];
public int nesting = 0;
}
public static final class Context extends BaseMapper.Mapping {
Context(BaseMapper mapper) {
this.mapper = mapper;
}
public BaseMapper mapper;
public String[] welcomeResources = new String[0];
public FileConnector resources = null;
public BaseMapper.ServiceMapping defaultWrapper = null;
public BaseMapper.ServiceMapping[] exactWrappers = new BaseMapper.ServiceMapping[0];
public BaseMapper.ServiceMapping[] wildcardWrappers = new BaseMapper.ServiceMapping[0];
public BaseMapper.ServiceMapping[] extensionWrappers = new BaseMapper.ServiceMapping[0];
public int nesting = 0;
public void addWrapper(String path, HttpService service) {
mapper.addWrapper(this, path, service);
}
}
public static class ServiceMapping extends BaseMapper.Mapping {
public boolean jspWildCard = false;
// If set, the service will run in the selector thread ( should
// be non-blocking )
public boolean selectorThread = false;
}
protected static abstract class Mapping {
public String name = null;
public Object object = null;
public String toString() {
if (name == null || "".equals(name)) {
return "DEFAULT";
}
return name;
}
}
// ---------------------------------------------------- Context Inner Class
}