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