/**
*
* Copyright 2003-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.
*/
//
// This source code implements specifications defined by the Java
// Community Process. In order to remain compliant with the specification
// DO NOT add / change / or delete method signatures!
//
package javax.servlet.http;
import java.io.IOException;
import java.util.Hashtable;
import java.util.ResourceBundle;
import java.util.StringTokenizer;
import javax.servlet.ServletInputStream;
/**
* @deprecated As of Java(tm) Servlet API 2.3. These methods were only useful
* with the default encoding and have been moved to the request interfaces.
*
* @version $Rev: 46019 $ $Date: 2004-09-14 03:56:06 -0600 (Tue, 14 Sep 2004) $
*/
public class HttpUtils {
private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
private static ResourceBundle lStrings = ResourceBundle.getBundle(LSTRING_FILE);
/**
* Constructs an empty <code>HttpUtils</code> object.
*/
public HttpUtils() {
}
/**
* Parses a query string passed from the client to the server and builds a
* <code>HashTable</code> object with key-value pairs. The query string
* should be in the form of a string packaged by the GET or POST method,
* that is, it should have key-value pairs in the form <i>key=value</i>,
* with each pair separated from the next by a & character.
*
* <p>A key can appear more than once in the query string with different
* values. However, the key appears only once in the hashtable, with its
* value being an array of strings containing the multiple values sent
* by the query string.
*
* <p>The keys and values in the hashtable are stored in their decoded
* form, so any + characters are converted to spaces, and characters
* sent in hexadecimal notation (like <i>%xx</i>) are converted to ASCII
* characters.
*
* @param s a string containing the query to be parsed
*
* @return a <code>HashTable</code> object built from the parsed key-value
* pairs
*
* @exception IllegalArgumentException if the query string is invalid
*/
static public Hashtable parseQueryString(String s) {
String valArray[] = null;
if (s == null) {
throw new IllegalArgumentException();
}
Hashtable ht = new Hashtable();
StringBuffer sb = new StringBuffer();
StringTokenizer st = new StringTokenizer(s, "&");
while (st.hasMoreTokens()) {
String pair = (String) st.nextToken();
int pos = pair.indexOf('=');
if (pos == -1) {
// XXX
// should give more detail about the illegal argument
throw new IllegalArgumentException();
}
String key = parseName(pair.substring(0, pos), sb);
String val = parseName(pair.substring(pos + 1, pair.length()), sb);
if (ht.containsKey(key)) {
String oldVals[] = (String[]) ht.get(key);
valArray = new String[oldVals.length + 1];
for (int i = 0; i < oldVals.length; i++)
valArray[i] = oldVals[i];
valArray[oldVals.length] = val;
} else {
valArray = new String[1];
valArray[0] = val;
}
ht.put(key, valArray);
}
return ht;
}
/**
* Parses data from an HTML form that the client sends to the server using
* the HTTP POST method and the <i>application/x-www-form-urlencoded</i>
* MIME type.
*
* <p>The data sent by the POST method contains key-value pairs. A key can
* appear more than once in the POST data with different values. However,
* the key appears only once in the hashtable, with its value being an
* array of strings containing the multiple values sent by the POST method.
*
* <p>The keys and values in the hashtable are stored in their decoded
* form, so any + characters are converted to spaces, and characters sent
* in hexadecimal notation (like <i>%xx</i>) are converted to ASCII
* characters.
*
* @param len an integer specifying the length, in characters, of the
* <code>ServletInputStream</code> object that is also passed to this
* method
*
* @param in the <code>ServletInputStream</code> object that contains the
* data sent from the client
*
* @return a <code>HashTable</code> object built from the parsed key-value
* pairs
*
* @exception IllegalArgumentException if the data sent by the POST
* method is invalid
*/
static public Hashtable parsePostData(int len, ServletInputStream in) {
// XXX
// should a length of 0 be an IllegalArgumentException
if (len <= 0) {
return new Hashtable(); // cheap hack to return an empty hash
}
if (in == null) {
throw new IllegalArgumentException();
}
//
// Make sure we read the entire POSTed body.
//
byte[] postedBytes = new byte[len];
try {
int offset = 0;
do {
int inputLen = in.read(postedBytes, offset, len - offset);
if (inputLen <= 0) {
String msg = lStrings.getString("err.io.short_read");
throw new IllegalArgumentException(msg);
}
offset += inputLen;
} while ((len - offset) > 0);
} catch (IOException e) {
throw new IllegalArgumentException(e.getMessage());
}
// XXX we shouldn't assume that the only kind of POST body
// is FORM data encoded using ASCII or ISO Latin/1 ... or
// that the body should always be treated as FORM data.
//
try {
String postedBody = new String(postedBytes, 0, len, "8859_1");
return parseQueryString(postedBody);
} catch (java.io.UnsupportedEncodingException e) {
// XXX function should accept an encoding parameter & throw this
// exception. Otherwise throw something expected.
throw new IllegalArgumentException(e.getMessage());
}
}
/**
* Parse a name in the query string.
*/
static private String parseName(String s, StringBuffer sb) {
sb.setLength(0);
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
switch (c) {
case '+':
sb.append(' ');
break;
case '%':
try {
sb.append((char) Integer.parseInt(s.substring(i + 1, i + 3),
16));
i += 2;
} catch (NumberFormatException e) {
// XXX
// need to be more specific about illegal arg
throw new IllegalArgumentException();
} catch (StringIndexOutOfBoundsException e) {
String rest = s.substring(i);
sb.append(rest);
if (rest.length() == 2)
i++;
}
break;
default:
sb.append(c);
break;
}
}
return sb.toString();
}
/**
* Reconstructs the URL the client used to make the request, using
* information in the <code>HttpServletRequest</code> object. The returned
* URL contains a protocol, server name, port number, and server path, but
* it does not include query string parameters.
*
* <p>Because this method returns a <code>StringBuffer</code>, not a
* string, you can modify the URL easily, for example, to append query
* parameters.
*
* <p>This method is useful for creating redirect messages and for
* reporting errors.
*
* @param req a <code>HttpServletRequest</code> object containing the
* client's request
*
* @return a <code>StringBuffer</code> object containing the reconstructed
* URL
*/
public static StringBuffer getRequestURL(HttpServletRequest req) {
StringBuffer url = new StringBuffer();
String scheme = req.getScheme();
int port = req.getServerPort();
String urlPath = req.getRequestURI();
//String servletPath = req.getServletPath ();
//String pathInfo = req.getPathInfo ();
url.append(scheme); // http, https
url.append("://");
url.append(req.getServerName());
if ((scheme.equals("http") && port != 80)
|| (scheme.equals("https") && port != 443)) {
url.append(':');
url.append(req.getServerPort());
}
//if (servletPath != null)
// url.append (servletPath);
//if (pathInfo != null)
// url.append (pathInfo);
url.append(urlPath);
return url;
}
}