/*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed 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.catalina.connector.warp;
import java.io.IOException;
import java.security.Principal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Locale;
import java.util.TreeMap;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import org.apache.catalina.Context;
import org.apache.catalina.Globals;
import org.apache.catalina.Host;
import org.apache.catalina.util.RequestUtil;
import org.apache.catalina.util.StringParser;
public class WarpRequestHandler {
private StringParser parser = new StringParser();
private static final String match=";"+Globals.SESSION_PARAMETER_NAME+"=";
/* ==================================================================== */
/* Constructor */
/* ==================================================================== */
public WarpRequestHandler() {
super();
}
public boolean handle(WarpConnection connection, WarpPacket packet)
throws IOException {
WarpLogger logger=new WarpLogger(this);
WarpConnector connector=connection.getConnector();
logger.setContainer(connector.getContainer());
WarpRequest request=new WarpRequest();
WarpResponse response=new WarpResponse();
response.setRequest(request);
response.setConnection(connection);
response.setPacket(packet);
request.setConnection(connection);
request.setConnector(connector);
// Prepare the Proceed packet
packet.reset();
packet.setType(Constants.TYPE_CONF_PROCEED);
connection.send(packet);
// Loop for configuration packets
while (true) {
connection.recv(packet);
switch (packet.getType()) {
case Constants.TYPE_REQ_INIT: {
int id=packet.readInteger();
String meth=packet.readString();
String ruri=packet.readString();
String args=packet.readString();
String prot=packet.readString();
if (Constants.DEBUG)
logger.debug("Request ID="+id+" \""+meth+" "+ruri+
"?"+args+" "+prot+"\"");
request.recycle();
response.recycle();
response.setRequest(request);
response.setConnection(connection);
response.setPacket(packet);
request.setMethod(meth);
this.processUri(logger,request,ruri);
if (args.length()>0) request.setQueryString(args);
else request.setQueryString(null);
request.setProtocol(prot);
request.setConnection(connection);
Context ctx=connector.applicationContext(id);
if (ctx!=null) {
request.setContext(ctx);
request.setContextPath(ctx.getPath());
request.setHost((Host)ctx.getParent());
}
break;
}
case Constants.TYPE_REQ_CONTENT: {
String ctyp=packet.readString();
int clen=packet.readInteger();
if (Constants.DEBUG)
logger.debug("Request content type="+ctyp+" length="+
clen);
if (ctyp.length()>0) request.setContentType(ctyp);
if (clen>0) request.setContentLength(clen);
break;
}
case Constants.TYPE_REQ_SCHEME: {
String schm=packet.readString();
if (Constants.DEBUG)
logger.debug("Request scheme="+schm);
request.setScheme(schm);
if (schm.equals("https"))
request.setSecure(true);
break;
}
case Constants.TYPE_REQ_AUTH: {
String user=packet.readString();
String auth=packet.readString();
if (Constants.DEBUG)
logger.debug("Request user="+user+" auth="+auth);
request.setAuthType(auth);
// What to do for user name?
if(user != null && auth != null && auth.equals("Basic")) {
Principal prin = new BasicPrincipal(user);
request.setUserPrincipal(prin);
}
break;
}
case Constants.TYPE_REQ_HEADER: {
String hnam=packet.readString();
String hval=packet.readString();
this.processHeader(logger,request,hnam,hval);
break;
}
case Constants.TYPE_REQ_SERVER: {
String host=packet.readString();
String addr=packet.readString();
int port=packet.readUnsignedShort();
if (Constants.DEBUG)
logger.debug("Server detail "+host+":"+port+
" ("+addr+")");
request.setServerName(host);
request.setServerPort(port);
break;
}
case Constants.TYPE_REQ_CLIENT: {
String host=packet.readString();
String addr=packet.readString();
int port=packet.readUnsignedShort();
if (Constants.DEBUG)
logger.debug("Client detail "+host+":"+port+
" ("+addr+")");
request.setRemoteHost(host);
request.setRemoteAddr(addr);
break;
}
case Constants.TYPE_REQ_PROCEED: {
if (Constants.DEBUG)
logger.debug("Request is about to be processed");
try {
connector.getContainer().invoke(request,response);
} catch (Exception e) {
logger.log(e);
}
request.finishRequest();
response.finishResponse();
if (Constants.DEBUG)
logger.debug("Request has been processed");
break;
}
default: {
String msg="Invalid packet "+packet.getType();
logger.log(msg);
packet.reset();
packet.setType(Constants.TYPE_FATAL);
packet.writeString(msg);
connection.send(packet);
return(false);
}
}
}
}
private void processUri(WarpLogger logger, WarpRequest req, String uri) {
// Parse any requested session ID out of the request URI
int semicolon = uri.indexOf(match);
if (semicolon >= 0) {
String rest = uri.substring(semicolon + match.length());
int semicolon2 = rest.indexOf(';');
if (semicolon2 >= 0) {
req.setRequestedSessionId(rest.substring(0, semicolon2));
rest = rest.substring(semicolon2);
} else {
req.setRequestedSessionId(rest);
rest = "";
}
req.setRequestedSessionURL(true);
uri = uri.substring(0, semicolon) + rest;
if (Constants.DEBUG) {
logger.log("Requested URL session id is " +
((HttpServletRequest) req.getRequest())
.getRequestedSessionId());
}
} else {
req.setRequestedSessionId(null);
req.setRequestedSessionURL(false);
}
req.setRequestURI(uri);
}
private void processHeader(WarpLogger logger, WarpRequest req,
String name, String value) {
if (Constants.DEBUG)
logger.debug("Request header "+name+": "+value);
if ("cookie".equalsIgnoreCase(name)) {
Cookie cookies[] = RequestUtil.parseCookieHeader(value);
for (int i = 0; i < cookies.length; i++) {
if (cookies[i].getName().equals
(Globals.SESSION_COOKIE_NAME)) {
// Override anything requested in the URL
if (!req.isRequestedSessionIdFromCookie()) {
// Accept only the first session id cookie
req.setRequestedSessionId
(cookies[i].getValue());
req.setRequestedSessionCookie(true);
req.setRequestedSessionURL(false);
if (Constants.DEBUG) {
logger.debug("Requested cookie session id is " +
((HttpServletRequest) req.getRequest())
.getRequestedSessionId());
}
}
}
if (Constants.DEBUG) {
logger.debug("Adding cookie "+cookies[i].getName()+"="+
cookies[i].getValue());
}
req.addCookie(cookies[i]);
}
}
if (name.equalsIgnoreCase("Accept-Language"))
parseAcceptLanguage(logger,req,value);
if (name.equalsIgnoreCase("Authorization"))
req.setAuthorization(value);
req.addHeader(name,value);
}
/**
* Parse the value of an <code>Accept-Language</code> header, and add
* the corresponding Locales to the current request.
*
* @param value The value of the <code>Accept-Language</code> header.
*/
private void parseAcceptLanguage(WarpLogger logger, WarpRequest request,
String value) {
// Store the accumulated languages that have been requested in
// a local collection, sorted by the quality value (so we can
// add Locales in descending order). The values will be ArrayLists
// containing the corresponding Locales to be added
TreeMap locales = new TreeMap();
// Preprocess the value to remove all whitespace
int white = value.indexOf(' ');
if (white < 0)
white = value.indexOf('\t');
if (white >= 0) {
StringBuffer sb = new StringBuffer();
int len = value.length();
for (int i = 0; i < len; i++) {
char ch = value.charAt(i);
if ((ch != ' ') && (ch != '\t'))
sb.append(ch);
}
value = sb.toString();
}
// Process each comma-delimited language specification
parser.setString(value); // ASSERT: parser is available to us
int length = parser.getLength();
while (true) {
// Extract the next comma-delimited entry
int start = parser.getIndex();
if (start >= length)
break;
int end = parser.findChar(',');
String entry = parser.extract(start, end).trim();
parser.advance(); // For the following entry
// Extract the quality factor for this entry
double quality = 1.0;
int semi = entry.indexOf(";q=");
if (semi >= 0) {
try {
quality = Double.parseDouble(entry.substring(semi + 3));
} catch (NumberFormatException e) {
quality = 0.0;
}
entry = entry.substring(0, semi);
}
// Skip entries we are not going to keep track of
if (quality < 0.00005)
continue; // Zero (or effectively zero) quality factors
if ("*".equals(entry))
continue; // FIXME - "*" entries are not handled
// Extract the language and country for this entry
String language = null;
String country = null;
int dash = entry.indexOf('-');
if (dash < 0) {
language = entry;
country = "";
} else {
language = entry.substring(0, dash);
country = entry.substring(dash + 1);
}
// Add a new Locale to the list of Locales for this quality level
Locale locale = new Locale(language, country);
Double key = new Double(-quality); // Reverse the order
ArrayList values = (ArrayList) locales.get(key);
if (values == null) {
values = new ArrayList();
locales.put(key, values);
}
values.add(locale);
}
// Process the quality values in highest->lowest order (due to
// negating the Double value when creating the key)
Iterator keys = locales.keySet().iterator();
while (keys.hasNext()) {
Double key = (Double) keys.next();
ArrayList list = (ArrayList) locales.get(key);
Iterator values = list.iterator();
while (values.hasNext()) {
Locale locale = (Locale) values.next();
if (Constants.DEBUG) {
logger.debug("Adding locale '" + locale + "'");
}
request.addLocale(locale);
}
}
}
class BasicPrincipal implements Principal {
private String user;
BasicPrincipal(String user) {
this.user = user;
}
public boolean equals(Object another) {
return (another instanceof Principal &&
((Principal)another).getName().equals(user));
}
public String getName() {
return user;
}
public String toString() {
return getName();
}
}
}