servletapi/jsr154/src/share/javax/servlet/http/HttpUtils.java - tomcat55 - Git at Google

 /*
 * 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.
  *
 */


 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 &amp; 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;
     }
 }
	/*
	* 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.
	*
	*/


	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;
	}
	}