javax.servlet.http.HttpUtils Maven / Gradle / Ivy
/*
* JBoss, Home of Professional Open Source.
* Copyright 2007, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package javax.servlet.http;
import javax.servlet.ServletInputStream;
import java.util.Hashtable;
import java.util.ResourceBundle;
import java.util.StringTokenizer;
import java.io.IOException;
/**
* @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.
*/
public class HttpUtils
{
private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
private static ResourceBundle lStrings = ResourceBundle.getBundle(LSTRING_FILE);
/**
* Constructs an empty HttpUtils object.
*/
public HttpUtils()
{
}
/**
* Parses a query string passed from the client to the server and builds a
* HashTable 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 key=value, with
* each pair separated from the next by a & character.
*
* 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.
*
* 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 %xx) are converted to ASCII characters.
*
* @param s
* a string containing the query to be parsed
* @return a HashTable 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 application/x-www-form-urlencoded
* MIME type.
*
* 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.
*
* 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 %xx) are converted to ASCII characters.
*
* @param len
* an integer specifying the length, in characters, of the
* ServletInputStream object that is also passed to
* this method
* @param in
* the ServletInputStream object that contains the
* data sent from the client
* @return a HashTable 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 HttpServletRequest object. The returned
* URL contains a protocol, server name, port number, and server path, but it
* does not include query string parameters.
*
* Because this method returns a StringBuffer, not a string,
* you can modify the URL easily, for example, to append query parameters.
*
* This method is useful for creating redirect messages and for reporting
* errors.
*
* @param req
* a HttpServletRequest object containing the
* client's request
* @return a StringBuffer 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;
}
}