Java tutorial
/* * Copyright (c) 1997-2018 Oracle and/or its affiliates. All rights reserved. * Copyright 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 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. * */ @Deprecated 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 */ public static Hashtable<String, String[]> parseQueryString(String s) { String valArray[] = null; if (s == null) { throw new IllegalArgumentException(); } Hashtable<String, String[]> ht = new Hashtable<String, String[]>(); 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 if (len <= 0) { // cheap hack to return an empty hash return new Hashtable<String, String[]>(); } 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. */ 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(); //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; } }