HttpUtils


1   /*
2   * Licensed to the Apache Software Foundation (ASF) under one or more
3   * contributor license agreements.  See the NOTICE file distributed with
4   * this work for additional information regarding copyright ownership.
5   * The ASF licenses this file to You under the Apache License, Version 2.0
6   * (the "License"); you may not use this file except in compliance with
7   * the License.  You may obtain a copy of the License at
8   *
9   *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17  
18  package javax.servlet.http;
19  
20  import javax.servlet.ServletInputStream  ;
21  import java.util.Hashtable  ;
22  import java.util.ResourceBundle  ;
23  import java.util.StringTokenizer  ;
24  import java.io.IOException  ;
25  
26  /**
27   * @deprecated      As of Java(tm) Servlet API 2.3. 
28   *          These methods were only useful
29   *          with the default encoding and have been moved
30   *          to the request interfaces.
31   *
32  */
33  
34  
35  public class HttpUtils {
36  
37      private static final String   LSTRING_FILE =
38      "javax.servlet.http.LocalStrings";
39      private static ResourceBundle   lStrings =
40      ResourceBundle.getBundle(LSTRING_FILE);
41          
42      
43      
44      /**
45       * Constructs an empty <code>HttpUtils</code> object.
46       *
47       */
48  
49      public HttpUtils() {}
50      
51      
52      
53      
54  
55      /**
56       *
57       * Parses a query string passed from the client to the
58       * server and builds a <code>HashTable</code> object
59       * with key-value pairs. 
60       * The query string should be in the form of a string
61       * packaged by the GET or POST method, that is, it
62       * should have key-value pairs in the form <i>key=value</i>,
63       * with each pair separated from the next by a &amp; character.
64       *
65       * <p>A key can appear more than once in the query string
66       * with different values. However, the key appears only once in 
67       * the hashtable, with its value being
68       * an array of strings containing the multiple values sent
69       * by the query string.
70       * 
71       * <p>The keys and values in the hashtable are stored in their
72       * decoded form, so
73       * any + characters are converted to spaces, and characters
74       * sent in hexadecimal notation (like <i>%xx</i>) are
75       * converted to ASCII characters.
76       *
77       * @param s     a string containing the query to be parsed
78       *
79       * @return      a <code>HashTable</code> object built
80       *          from the parsed key-value pairs
81       *
82       * @exception IllegalArgumentException  if the query string 
83       *                      is invalid
84       *
85       */
86  
87      static public Hashtable   parseQueryString(String   s) {
88  
89      String   valArray[] = null;
90      
91      if (s == null) {
92          throw new IllegalArgumentException  ();
93      }
94      Hashtable   ht = new Hashtable  ();
95      StringBuffer   sb = new StringBuffer  ();
96      StringTokenizer   st = new StringTokenizer  (s, "&");
97      while (st.hasMoreTokens()) {
98          String   pair = (String  )st.nextToken();
99          int pos = pair.indexOf('=');
100         if (pos == -1) {
101         // XXX
102         // should give more detail about the illegal argument
103         throw new IllegalArgumentException  ();
104         }
105         String   key = parseName(pair.substring(0, pos), sb);
106         String   val = parseName(pair.substring(pos+1, pair.length()), sb);
107         if (ht.containsKey(key)) {
108         String   oldVals[] = (String   []) ht.get(key);
109         valArray = new String  [oldVals.length + 1];
110         for (int i = 0; i < oldVals.length; i++) 
111             valArray[i] = oldVals[i];
112         valArray[oldVals.length] = val;
113         } else {
114         valArray = new String  [1];
115         valArray[0] = val;
116         }
117         ht.put(key, valArray);
118     }
119     return ht;
120     }
121 
122 
123 
124 
125     /**
126      *
127      * Parses data from an HTML form that the client sends to 
128      * the server using the HTTP POST method and the 
129      * <i>application/x-www-form-urlencoded</i> MIME type.
130      *
131      * <p>The data sent by the POST method contains key-value
132      * pairs. A key can appear more than once in the POST data
133      * with different values. However, the key appears only once in 
134      * the hashtable, with its value being
135      * an array of strings containing the multiple values sent
136      * by the POST method.
137      *
138      * <p>The keys and values in the hashtable are stored in their
139      * decoded form, so
140      * any + characters are converted to spaces, and characters
141      * sent in hexadecimal notation (like <i>%xx</i>) are
142      * converted to ASCII characters.
143      *
144      *
145      *
146      * @param len   an integer specifying the length,
147      *          in characters, of the 
148      *          <code>ServletInputStream</code>
149      *          object that is also passed to this
150      *          method
151      *
152      * @param in    the <code>ServletInputStream</code>
153      *          object that contains the data sent
154      *          from the client
155      * 
156      * @return      a <code>HashTable</code> object built
157      *          from the parsed key-value pairs
158      *
159      *
160      * @exception IllegalArgumentException  if the data
161      *          sent by the POST method is invalid
162      *
163      */
164      
165 
166     static public Hashtable   parsePostData(int len, 
167                       ServletInputStream   in)
168     {
169     // XXX
170     // should a length of 0 be an IllegalArgumentException
171     
172     if (len <=0)
173         return new Hashtable  (); // cheap hack to return an empty hash
174 
175     if (in == null) {
176         throw new IllegalArgumentException  ();
177     }
178     
179     //
180     // Make sure we read the entire POSTed body.
181     //
182         byte[] postedBytes = new byte [len];
183         try {
184             int offset = 0;
185        
186         do {
187         int inputLen = in.read (postedBytes, offset, len - offset);
188         if (inputLen <= 0) {
189             String   msg = lStrings.getString("err.io.short_read");
190             throw new IllegalArgumentException   (msg);
191         }
192         offset += inputLen;
193         } while ((len - offset) > 0);
194 
195     } catch (IOException   e) {
196         throw new IllegalArgumentException  (e.getMessage());
197     }
198 
199         // XXX we shouldn't assume that the only kind of POST body
200         // is FORM data encoded using ASCII or ISO Latin/1 ... or
201         // that the body should always be treated as FORM data.
202         //
203 
204         try {
205             String   postedBody = new String  (postedBytes, 0, len, "8859_1");
206             return parseQueryString(postedBody);
207         } catch (java.io.UnsupportedEncodingException   e) {
208             // XXX function should accept an encoding parameter & throw this
209             // exception.  Otherwise throw something expected.
210             throw new IllegalArgumentException  (e.getMessage());
211         }
212     }
213 
214 
215 
216 
217     /*
218      * Parse a name in the query string.
219      */
220 
221     static private String   parseName(String   s, StringBuffer   sb) {
222     sb.setLength(0);
223     for (int i = 0; i < s.length(); i++) {
224         char c = s.charAt(i); 
225         switch (c) {
226         case '+':
227         sb.append(' ');
228         break;
229         case '%':
230         try {
231             sb.append((char) Integer.parseInt(s.substring(i+1, i+3), 
232                               16));
233             i += 2;
234         } catch (NumberFormatException   e) {
235             // XXX
236             // need to be more specific about illegal arg
237             throw new IllegalArgumentException  ();
238         } catch (StringIndexOutOfBoundsException   e) {
239             String   rest  = s.substring(i);
240             sb.append(rest);
241             if (rest.length()==2)
242             i++;
243         }
244         
245         break;
246         default:
247         sb.append(c);
248         break;
249         }
250     }
251     return sb.toString();
252     }
253 
254 
255 
256 
257     /**
258      *
259      * Reconstructs the URL the client used to make the request,
260      * using information in the <code>HttpServletRequest</code> object.
261      * The returned URL contains a protocol, server name, port
262      * number, and server path, but it does not include query
263      * string parameters.
264      * 
265      * <p>Because this method returns a <code>StringBuffer</code>,
266      * not a string, you can modify the URL easily, for example,
267      * to append query parameters.
268      *
269      * <p>This method is useful for creating redirect messages
270      * and for reporting errors.
271      *
272      * @param req   a <code>HttpServletRequest</code> object
273      *          containing the client's request
274      * 
275      * @return      a <code>StringBuffer</code> object containing
276      *          the reconstructed URL
277      *
278      */
279 
280     public static StringBuffer   getRequestURL (HttpServletRequest   req) {
281     StringBuffer   url = new StringBuffer   ();
282     String   scheme = req.getScheme ();
283     int port = req.getServerPort ();
284     String   urlPath = req.getRequestURI();
285     
286     //String        servletPath = req.getServletPath ();
287     //String        pathInfo = req.getPathInfo ();
288 
289     url.append (scheme);        // http, https
290     url.append ("://");
291     url.append (req.getServerName ());
292     if ((scheme.equals ("http") && port != 80)
293         || (scheme.equals ("https") && port != 443)) {
294         url.append (':');
295         url.append (req.getServerPort ());
296     }
297     //if (servletPath != null)
298     //    url.append (servletPath);
299     //if (pathInfo != null)
300     //    url.append (pathInfo);
301     url.append(urlPath);
302     return url;
303     }
304 }
305 
306 
307 
308
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags