Java > Open Source Codes > org > openejb > server > httpd > HttpRequestImpl


1 /**
2  * Redistribution and use of this software and associated documentation
3  * ("Software"), with or without modification, are permitted provided
4  * that the following conditions are met:
5  *
6  * 1. Redistributions of source code must retain copyright
7  * statements and notices. Redistributions must also contain a
8  * copy of this document.
9  *
10  * 2. Redistributions in binary form must reproduce the
11  * above copyright notice, this list of conditions and the
12  * following disclaimer in the documentation and/or other
13  * materials provided with the distribution.
14  *
15  * 3. The name "OpenEJB" must not be used to endorse or promote
16  * products derived from this Software without prior written
17  * permission of The OpenEJB Group. For written permission,
18  * please contact openejb@openejb.org.
19  *
20  * 4. Products derived from this Software may not be called "OpenEJB"
21  * nor may "OpenEJB" appear in their names without prior written
22  * permission of The OpenEJB Group. OpenEJB is a registered
23  * trademark of The OpenEJB Group.
24  *
25  * 5. Due credit should be given to the OpenEJB Project
26  * (http://openejb.org/).
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE OPENEJB GROUP AND CONTRIBUTORS
29  * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
30  * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
31  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
32  * THE OPENEJB GROUP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
33  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
34  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
35  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
37  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
39  * OF THE POSSIBILITY OF SUCH DAMAGE.
40  *
41  * Copyright 2001 (C) The OpenEJB Group. All Rights Reserved.
42  *
43  * $Id: HttpRequestImpl.java,v 1.8 2005/04/05 08:05:08 dblevins Exp $
44  */
45 package org.openejb.server.httpd;
46
47 import java.io.ByteArrayInputStream ;
48 import java.io.DataInput ;
49 import java.io.DataInputStream ;
50 import java.io.IOException ;
51 import java.io.InputStream ;
52 import java.net.URI ;
53 import java.net.URISyntaxException ;
54 import java.net.URLDecoder ;
55 import java.util.HashMap ;
56 import java.util.Map ;
57 import java.util.StringTokenizer ;
58
59 /**
60  * A class to take care of HTTP Requests. It parses headers, content, form and url
61  * parameters.
62  */
63 public class HttpRequestImpl implements HttpRequest {
64     public static final String FORM_URL_ENCODED = "application/x-www-form-urlencoded";
65     public static final String TEXT_XML = "text/xml";
66     public static final String MULITPART_FORM_DATA = "multipart/form-data";
67     public static final String FILENAME = "filename";
68     public static final String NAME = "name";
69
70     /**
71      * 5.1 Request-Line
72      */
73     private String line;
74     /**
75      * 5.1.1 Method
76      */
77     private int method;
78     /**
79      * 5.1.2 Request-URI
80      */
81     private URI uri;
82     /**
83      * the headers for this page
84      */
85     private HashMap headers;
86     /**
87      * the form parameters for this page
88      */
89     private HashMap formParams = new HashMap ();
90     /**
91      * the URL (or query) parameters for this page
92      */
93     private HashMap queryParams = new HashMap ();
94     private HashMap parameters = new HashMap ();
95
96     protected static final String EJBSESSIONID = "EJBSESSIONID";
97
98     private HashMap cookies;
99
100
101     /**
102      * the content of the body of this page
103      */
104     private byte[] body;
105     private InputStream in;
106     private int length;
107     private String contentType;
108     /** the address the request came in on */
109     private final URI socketURI;
110
111     private HashMap attributes = new HashMap ();
112
113     public HttpRequestImpl(URI socketURI) {
114         this.socketURI = socketURI;
115     }
116
117     /**
118      * Gets a header based the header name passed in.
119      *
120      * @param name The name of the header to get
121      * @return The value of the header
122      */
123     public String getHeader(String name) {
124         return (String ) headers.get(name);
125     }
126
127     /**
128      * Gets a form parameter based on the name passed in.
129      *
130      * @param name The name of the form parameter to get
131      * @return The value of the parameter
132      */
133     public String getFormParameter(String name) {
134         return (String ) formParams.get(name);
135     }
136
137     public Map getFormParameters() {
138         return (Map )formParams.clone();
139     }
140
141     public Map getQueryParameters() {
142         return (Map )queryParams.clone();
143     }
144
145     /**
146      * Gets a URL (or query) parameter based on the name passed in.
147      *
148      * @param name The name of the URL (or query) parameter
149      * @return The value of the URL (or query) parameter
150      */
151     public String getQueryParameter(String name) {
152         return (String ) queryParams.get(name);
153     }
154
155     /**
156      * Gets an integer value of the request method. These values are:
157      * <p/>
158      * OPTIONS = 0
159      * GET = 1
160      * HEAD = 2
161      * POST = 3
162      * PUT = 4
163      * DELETE = 5
164      * TRACE = 6
165      * CONNECT = 7
166      * UNSUPPORTED = 8
167      *
168      * @return The integer value of the method
169      */
170     public int getMethod() {
171         return method;
172     }
173
174     /**
175      * Gets the URI for the current URL page.
176      *
177      * @return The URI
178      */
179     public URI getURI() {
180         return uri;
181     }
182
183     public int getContentLength() {
184         return length;
185     }
186
187     public String getContentType() {
188         return contentType;
189     }
190
191     public InputStream getInputStream() throws IOException {
192         return this.in;
193     }
194
195     /*------------------------------------------------------------*/
196     /* Methods for reading in and parsing a request */
197     /*------------------------------------------------------------*/
198     /**
199      * parses the request into the 3 different parts, request, headers, and body
200      *
201      * @param input the data input for this page
202      * @throws java.io.IOException if an exception is thrown
203      */
204     protected void readMessage(InputStream input) throws IOException {
205         DataInput in = new DataInputStream (input);
206
207         readRequestLine(in);
208         readHeaders(in);
209         readBody(in);
210
211         parameters = new HashMap ();
212         parameters.putAll(this.getFormParameters());
213         parameters.putAll(this.getQueryParameters());
214     }
215
216     /**
217      * reads and parses the request line
218      *
219      * @param in the input to be read
220      * @throws java.io.IOException if an exception is thrown
221      */
222     private void readRequestLine(DataInput in) throws IOException {
223         try {
224             line = in.readLine();
225 // System.out.println(line);
226 } catch (Exception e) {
227             throw new IOException ("Could not read the HTTP Request Line :"
228                     + e.getClass().getName()
229                     + " : "
230                     + e.getMessage());
231         }
232
233         StringTokenizer lineParts = new StringTokenizer (line, " ");
234         /* [1] Parse the method */
235         parseMethod(lineParts);
236         /* [2] Parse the URI */
237         parseURI(lineParts);
238     }
239
240     /**
241      * parses the method for this page
242      *
243      * @param lineParts a StringTokenizer of the request line
244      * @throws java.io.IOException if an exeption is thrown
245      */
246     private void parseMethod(StringTokenizer lineParts) throws IOException {
247         String token = null;
248         try {
249             token = lineParts.nextToken();
250         } catch (Exception e) {
251             throw new IOException ("Could not parse the HTTP Request Method :"
252                     + e.getClass().getName()
253                     + " : "
254                     + e.getMessage());
255         }
256
257         if (token.equalsIgnoreCase("GET")) {
258             method = GET;
259         } else if (token.equalsIgnoreCase("POST")) {
260             method = POST;
261         } else {
262             method = UNSUPPORTED;
263             throw new IOException ("Unsupported HTTP Request Method :" + token);
264         }
265     }
266
267     /**
268      * parses the URI into the different parts
269      *
270      * @param lineParts a StringTokenizer of the URI
271      * @throws java.io.IOException if an exeption is thrown
272      */
273     private void parseURI(StringTokenizer lineParts) throws IOException {
274         String token = null;
275         try {
276             token = lineParts.nextToken();
277         } catch (Exception e) {
278             throw new IOException ("Could not parse the HTTP Request Method :"
279                     + e.getClass().getName()
280                     + " : "
281                     + e.getMessage());
282         }
283
284         try {
285             uri = new URI (socketURI.toString()+token);
286         } catch (URISyntaxException e) {
287             throw new IOException ("Malformed URI :" + token + " Exception: " + e.getMessage());
288         }
289
290         parseQueryParams(uri.getQuery());
291     }
292
293     /**
294      * parses the URL (or query) parameters
295      *
296      * @param query the URL (or query) parameters to be parsed
297      */
298     private void parseQueryParams(String query) {
299         if (query == null)
300             return;
301         StringTokenizer parameters = new StringTokenizer (query, "&");
302
303         while (parameters.hasMoreTokens()) {
304             StringTokenizer param = new StringTokenizer (parameters.nextToken(), "=");
305
306             /* [1] Parse the Name */
307             if (!param.hasMoreTokens())
308                 continue;
309             String name = URLDecoder.decode(param.nextToken());
310             if (name == null)
311                 continue;
312
313             String value;
314             /* [2] Parse the Value */
315             if (!param.hasMoreTokens()){
316                 value = "";
317             } else {
318                 value = URLDecoder.decode(param.nextToken());
319             }
320
321             //System.out.println("[] "+name+" = "+value);
322 queryParams.put(name, value);
323         }
324     }
325
326     /**
327      * reads the headers from the data input sent from the browser
328      *
329      * @param in the data input sent from the browser
330      * @throws java.io.IOException if an exeption is thrown
331      */
332     private void readHeaders(DataInput in) throws IOException {
333 // System.out.println("\nREQUEST");
334 headers = new HashMap ();
335         while (true) {
336             // Header Field
337 String hf = null;
338
339             try {
340                 hf = in.readLine();
341                 //System.out.println(hf);
342 } catch (Exception e) {
343                 throw new IOException ("Could not read the HTTP Request Header Field :"
344                         + e.getClass().getName()
345                         + " : "
346                         + e.getMessage());
347             }
348
349             if (hf == null || hf.equals("")) {
350                 break;
351             }
352
353             /* [1] parse the name */
354             int colonIndex = hf.indexOf((int) ':');
355             String name = hf.substring(0, colonIndex);
356             if (name == null)
357                 break;
358
359             /* [2] Parse the Value */
360             String value = hf.substring(colonIndex + 1, hf.length());
361             if (value == null)
362                 break;
363             value = value.trim();
364             headers.put(name, value);
365         }
366         
367         // Update the URI to be what the client sees the the server as.
368 String host = (String ) headers.get("Host");
369         if( host!=null ) {
370             String hostName = uri.getHost();
371             int port = uri.getPort();
372             int idx = host.indexOf(":");
373             if( idx >= 0 ) {
374                 hostName = host.substring(0, idx);
375                 try {
376                     port = Integer.parseInt(host.substring(idx+1));
377                 }
378                 catch (NumberFormatException ignore) {
379                 }
380             } else {
381                 hostName = host;
382             }
383             
384             try {
385                 uri = new URI (uri.getScheme(),
386                         uri.getUserInfo(), hostName, port,
387                         uri.getPath(), uri.getQuery(),
388                         uri.getFragment());
389             } catch (URISyntaxException ignore) {
390             }
391         }
392         
393         //temp-debug-------------------------------------------
394 //java.util.Iterator myKeys = headers.keySet().iterator();
395 //String temp = null;
396 //while(myKeys.hasNext()) {
397 // temp = (String)myKeys.next();
398 // System.out.println("Test: " + temp + "=" + headers.get(temp));
399 //}
400 //end temp-debug---------------------------------------
401 }
402
403     /**
404      * reads the body from the data input passed in
405      *
406      * @param in the data input with the body of the page
407      * @throws java.io.IOException if an exception is thrown
408      */
409     private void readBody(DataInput in) throws IOException {
410         //System.out.println("Body Length: " + body.length);
411 // Content-type: application/x-www-form-urlencoded
412 // or multipart/form-data
413 length = parseContentLength();
414
415         contentType = getHeader(HttpRequest.HEADER_CONTENT_TYPE);
416
417         if (method == POST && FORM_URL_ENCODED.equals(contentType)) {
418             String rawParams = null;
419
420             try {
421                 byte[] body = new byte[length];
422                 in.readFully(body);
423                 rawParams = new String (body);
424             } catch (Exception e) {
425                 throw (IOException )new IOException ("Could not read the HTTP Request Body: " + e.getMessage()).initCause(e);
426             }
427
428             StringTokenizer parameters = new StringTokenizer (rawParams, "&");
429             String name = null;
430             String value = null;
431
432             while (parameters.hasMoreTokens()) {
433                 StringTokenizer param = new StringTokenizer (parameters.nextToken(), "=");
434
435                 /* [1] Parse the Name */
436                 name = URLDecoder.decode(param.nextToken());
437                 if (name == null)
438                     break;
439
440                 /* [2] Parse the Value */
441                 if (param.hasMoreTokens()) {
442                     value = URLDecoder.decode(param.nextToken());
443                 } else {
444                     value = ""; //if there is no token set value to blank string
445 }
446
447                 if (value == null)
448                     value = "";
449
450                 formParams.put(name, value);
451                     //System.out.println(name + ": " + value);
452 }
453         } else if (method == POST){
454             // TODO This really is terrible
455 byte[] body = new byte[length];
456             in.readFully(body);
457             this.in = new ByteArrayInputStream (body);
458         } else {
459             this.in = new ByteArrayInputStream (new byte[0]);
460         }
461
462     }
463
464     private int parseContentLength() {
465         // Content-length: 384
466 String len = getHeader(HttpRequest.HEADER_CONTENT_LENGTH);
467         //System.out.println("readRequestBody Content-Length: " + len);
468
469         int length = -1;
470         if (len != null) {
471             try {
472                 length = Integer.parseInt(len);
473             } catch (Exception e) {
474                 //don't care
475 }
476         }
477         return length;
478     }
479
480     protected HashMap getCookies() {
481         if (cookies != null) return cookies;
482
483         cookies = new HashMap ();
484
485         String cookieHeader = getHeader(HEADER_COOKIE);
486         if (cookieHeader == null) return cookies;
487
488         StringTokenizer tokens = new StringTokenizer (cookieHeader, ";");
489         while (tokens.hasMoreTokens()) {
490             StringTokenizer token = new StringTokenizer (tokens.nextToken(), "=");
491             String name = token.nextToken();
492             String value = token.nextToken();
493             cookies.put(name, value);
494         }
495         return cookies;
496     }
497
498     protected String getCookie(String name) {
499         return (String ) getCookies().get(name);
500     }
501
502     public HttpSession getSession(boolean create) {
503         return null;
504     }
505
506     public HttpSession getSession() {
507         return getSession(true);
508     }
509     
510     public Object getAttribute(String name) {
511         return attributes.get(name);
512     }
513
514     public void setAttribute(String name, Object value){
515         attributes.put(name, value);
516     }
517
518     public String getParameter(String name) {
519         return (String )parameters.get(name);
520     }
521
522     public Map getParameters() {
523         return (Map )parameters.clone();
524     }
525 }

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags