init
This commit is contained in:
281
java/javax/servlet/http/HttpUtils.java
Normal file
281
java/javax/servlet/http/HttpUtils.java
Normal file
@@ -0,0 +1,281 @@
|
||||
/*
|
||||
* 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 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.
|
||||
*/
|
||||
@SuppressWarnings("dep-ann") // Spec API does not use @Deprecated
|
||||
public class HttpUtils {
|
||||
|
||||
private static final String LSTRING_FILE =
|
||||
"javax.servlet.http.LocalStrings";
|
||||
private static final ResourceBundle lStrings =
|
||||
ResourceBundle.getBundle(LSTRING_FILE);
|
||||
|
||||
|
||||
/**
|
||||
* Constructs an empty <code>HttpUtils</code> object.
|
||||
*
|
||||
*/
|
||||
public HttpUtils() {
|
||||
// NOOP
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* 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
|
||||
*
|
||||
*/
|
||||
public static Hashtable<String,String[]> parseQueryString(String s) {
|
||||
|
||||
String valArray[] = null;
|
||||
|
||||
if (s == null) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
Hashtable<String,String[]> ht = new Hashtable<>();
|
||||
StringBuilder sb = new StringBuilder();
|
||||
StringTokenizer st = new StringTokenizer(s, "&");
|
||||
while (st.hasMoreTokens()) {
|
||||
String pair = 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[] = 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
|
||||
*
|
||||
*/
|
||||
public static Hashtable<String,String[]> parsePostData(int len,
|
||||
ServletInputStream in) {
|
||||
// XXX
|
||||
// should a length of 0 be an IllegalArgumentException
|
||||
|
||||
// cheap hack to return an empty hash
|
||||
if (len <=0)
|
||||
return new Hashtable<>();
|
||||
|
||||
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(), e);
|
||||
}
|
||||
|
||||
// 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(), e);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Parse a name in the query string.
|
||||
*/
|
||||
private static String parseName(String s, StringBuilder 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();
|
||||
|
||||
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 ());
|
||||
}
|
||||
|
||||
url.append(urlPath);
|
||||
return url;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user