View Javadoc

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  package org.apache.jetspeed.engine.servlet;
18  
19  import java.io.BufferedReader;
20  import java.io.IOException;
21  import java.io.UnsupportedEncodingException;
22  import java.util.ArrayList;
23  import java.util.Collection;
24  import java.util.Collections;
25  import java.util.Enumeration;
26  import java.util.HashMap;
27  import java.util.HashSet;
28  import java.util.Iterator;
29  import java.util.Locale;
30  import java.util.Map;
31  
32  import javax.portlet.PortletRequest;
33  import javax.servlet.ServletInputStream;
34  import javax.servlet.ServletRequest;
35  import javax.servlet.http.HttpServletRequest;
36  import javax.servlet.http.HttpServletRequestWrapper;
37  
38  import org.apache.commons.logging.Log;
39  import org.apache.commons.logging.LogFactory;
40  import org.apache.jetspeed.Jetspeed;
41  import org.apache.jetspeed.PortalReservedParameters;
42  import org.apache.jetspeed.aggregator.CurrentWorkerContext;
43  import org.apache.jetspeed.aggregator.Worker;
44  import org.apache.jetspeed.container.PortletDispatcherIncludeAware;
45  import org.apache.jetspeed.container.namespace.JetspeedNamespaceMapper;
46  import org.apache.jetspeed.container.namespace.JetspeedNamespaceMapperFactory;
47  import org.apache.jetspeed.container.url.PortalURL;
48  import org.apache.jetspeed.om.common.GenericMetadata;
49  import org.apache.jetspeed.om.common.LocalizedField;
50  import org.apache.jetspeed.om.common.portlet.PortletDefinitionComposite;
51  import org.apache.jetspeed.request.JetspeedRequestContext;
52  import org.apache.jetspeed.request.RequestContext;
53  import org.apache.pluto.om.entity.PortletEntity;
54  import org.apache.pluto.om.portlet.PortletApplicationDefinition;
55  import org.apache.pluto.om.window.PortletWindow;
56  import org.apache.pluto.util.Enumerator;
57  
58  /***
59   * This request wrappers the servlet request and is used within the container to
60   * communicate to the invoked servlet.
61   * 
62   * @author <a href="mailto:taylor@apache.org">David Sean Taylor </a>
63   * @version $Id: ServletRequestImpl.java 554827 2007-07-10 05:12:23Z taylor $
64   */
65  public class ServletRequestImpl extends HttpServletRequestWrapper implements PortletDispatcherIncludeAware
66  {
67      public static final String ACCEPT_LANGUAGE = "Accept-Language";
68      /*** Logger */
69      private static final Log log = LogFactory.getLog(ServletRequestImpl.class);
70  
71      PortletWindow portletWindow = null;
72      private JetspeedNamespaceMapper nameSpaceMapper = null;
73      private ServletRequest currentRequest = null;
74  
75      private Map portletParameters;
76      
77      private boolean included;
78  
79      private static Boolean mergePortalParametersWithPortletParameters;
80      private static Boolean mergePortalParametersBeforePortletParameters;
81      
82      private boolean portletMergePortalParametersWithPortletParameters;
83      private boolean portletMergePortalParametersBeforePortletParameters;
84      
85      private Map portalParameters;
86      
87      private String currentIncludeQueryString;    
88      private String currentForwardQueryString;    
89      
90      // request attributes map which is cached for each paralleled worker.
91      // this should be re-created when it is called for the first time or when some attributes are added/modified/removed.
92      private Map cachedAttributes;
93  
94      public ServletRequestImpl( HttpServletRequest servletRequest, PortletWindow window )
95      {
96          super(servletRequest);
97          nameSpaceMapper = ((JetspeedNamespaceMapperFactory) Jetspeed.getComponentManager().getComponent(
98                  org.apache.pluto.util.NamespaceMapper.class)).getJetspeedNamespaceMapper();
99          this.portletWindow = window;        
100         
101         
102         String encoding = (String) servletRequest.getAttribute(PortalReservedParameters.PREFERED_CHARACTERENCODING_ATTRIBUTE);
103         boolean decode = servletRequest.getAttribute(PortalReservedParameters.PARAMETER_ALREADY_DECODED_ATTRIBUTE) == null
104                 && encoding != null;
105         if (decode)
106         {
107             servletRequest.setAttribute(PortalReservedParameters.PARAMETER_ALREADY_DECODED_ATTRIBUTE,
108                     new Boolean(true));
109         }
110 
111         //get portal servlet params
112         portalParameters = new HashMap();
113         for (Enumeration parameters = servletRequest.getParameterNames(); parameters.hasMoreElements();)
114         {
115             String paramName = (String) parameters.nextElement();
116             String[] paramValues = servletRequest.getParameterValues(paramName);
117 
118             if (decode)
119             {
120                 for (int i = 0; i < paramValues.length; i++)
121                 {
122                     try
123                     {
124                         paramValues[i] = new String(paramValues[i].getBytes("ISO-8859-1"), encoding);
125                     }
126                     catch (UnsupportedEncodingException e)
127                     {
128                         ;
129                     }
130                 }
131             }
132             portalParameters.put(paramName, paramValues);
133         }
134         
135         if (mergePortalParametersWithPortletParameters == null )
136         {
137             mergePortalParametersWithPortletParameters = 
138                 new Boolean(Jetspeed.getContext().getConfiguration().getBoolean("merge.portal.parameters.with.portlet.parameters", false));
139             mergePortalParametersBeforePortletParameters = 
140                 new Boolean(Jetspeed.getContext().getConfiguration().getBoolean("merge.portal.parameters.before.portlet.parameters", false));
141         }
142                 
143         
144         PortletDefinitionComposite portletDef = (PortletDefinitionComposite)portletWindow.getPortletEntity().getPortletDefinition();
145         if(portletDef != null)
146         {
147             GenericMetadata metaData = portletDef.getMetadata();
148 
149             portletMergePortalParametersWithPortletParameters = 
150                 getMetaDataBooleanValue(
151                     metaData,
152                     PortalReservedParameters.PORTLET_EXTENDED_DESCRIPTOR_MERGE_PORTAL_PARAMETERS_WITH_PORTLET_PARAMETERS,
153                     mergePortalParametersWithPortletParameters.booleanValue());
154             portletMergePortalParametersBeforePortletParameters = 
155                 getMetaDataBooleanValue(
156                     metaData,
157                     PortalReservedParameters.PORTLET_EXTENDED_DESCRIPTOR_MERGE_PORTAL_PARAMETERS_BEFORE_PORTLET_PARAMETERS,
158                     mergePortalParametersBeforePortletParameters.booleanValue());
159             
160         }
161         else
162         {
163             // This happens when an entity is referencing a non-existent portlet
164             portletMergePortalParametersWithPortletParameters = mergePortalParametersWithPortletParameters.booleanValue();
165             portletMergePortalParametersBeforePortletParameters = mergePortalParametersBeforePortletParameters.booleanValue();
166         }
167     }
168     
169     private boolean getMetaDataBooleanValue(GenericMetadata metaData, String fieldName, boolean defaultValue )
170     {
171         String value = null;
172         if ( metaData != null )
173         {
174             Collection fields = metaData.getFields(fieldName);
175             if ( fields != null && !fields.isEmpty() )
176             {
177                 value = ((LocalizedField)fields.iterator().next()).getValue();
178             }
179         }
180         if ( value != null )
181         {
182             return Boolean.valueOf(value).booleanValue();
183         }
184         return defaultValue;
185     }
186 
187     protected HttpServletRequest _getHttpServletRequest()
188     {
189         return (HttpServletRequest) super.getRequest();
190     }
191 
192     //  ServletRequestWrapper overlay
193 
194     public String getParameter( String name )
195     {
196         Object value = this.getParameterMap().get(name);
197         if (value == null)
198         {
199             return (null);
200         }
201         else if (value instanceof String[])
202         {
203             return (((String[]) value)[0]);
204         }
205         else if (value instanceof String)
206         {
207             return ((String) value);
208         }
209         else
210         {
211             return (value.toString());
212         }
213     }
214     
215     private boolean isEqual(String one, String two)
216     {
217         return (one == null && two == null) || (one != null && two != null && one.equals(two));
218     }
219     
220     private boolean checkQueryStringChanged()
221     {
222         boolean changed = false;
223         ServletRequest request = getRequest();
224         String includeQueryString = (String)request.getAttribute("javax.servlet.include.query_string");        
225         String forwardQueryString = (String)request.getAttribute("javax.servlet.forward.query_string");
226         
227         if (!isEqual(currentIncludeQueryString,includeQueryString))
228         {
229             currentIncludeQueryString = includeQueryString;
230             changed = true;
231         }
232         if (!isEqual(currentForwardQueryString,forwardQueryString))
233         {
234             currentForwardQueryString = forwardQueryString;
235             changed = true;
236         }        
237         return changed;
238     }
239 
240     public Map getParameterMap()
241     {
242         // if included or forwarded with a query string, parameterMap might have changed
243         // this is/should be the only check needed, and the other "tricky" check below probably
244         // can be removed.
245         // I'll keep it in for now though as it hasn't been tested enough on other app servers
246         boolean queryStringChanged = checkQueryStringChanged();
247         
248         if (queryStringChanged || currentRequest == null || currentRequest != getRequest() )
249         {
250             // Cache the parameters for as long as the wrapped request stays the same.
251             // According to Servlet 2.3 SRV.6.2.2 the passed on ServletRequest object
252             // to an dispatched Servlet must remain the same (this one).
253             // Tomcat solves this by injecting a new ServletRequest of its own above
254             // this one (the getRequest() object).
255             // So, when that one has changed since the last time the parameters have 
256             // been accessed, flush the cache and rebuild the map.
257             currentRequest = getRequest();
258 
259             boolean actionRequest = false;
260             
261             // determine the possible additional query string parameters provided on the RequestDispatcher include path
262             // per the specs, these are prepended to existing parameters or altogether new parameters
263             // as we save the original "portal" parameters, we can find those query string parameters by comparing against those
264             HashMap queryParameters = new HashMap();
265             for ( Iterator iter = getRequest().getParameterMap().entrySet().iterator(); iter.hasNext(); )
266             {
267                 Map.Entry entry = (Map.Entry)iter.next();
268                 String[] values = (String[])entry.getValue();
269                 String[] original = (String[])portalParameters.get(entry.getKey());
270                 String[] diff = null;
271                 if ( original == null )
272                 {
273                     // a new parameter
274                     diff = new String[values.length];
275                     System.arraycopy(values,0,diff,0,values.length);
276                 }
277                 else if ( values.length > original.length )
278                 {
279                     // we've got some additional query string parameter value(s)
280                     diff = new String[values.length - original.length];
281                     System.arraycopy(values,0,diff,0,values.length-original.length);
282                 }
283                 if ( diff != null )
284                 {
285                     queryParameters.put(entry.getKey(), diff);
286                 }
287             }
288 
289             // get portlet navigational params
290             HashMap navParameters = new HashMap();
291             JetspeedRequestContext context = (JetspeedRequestContext) getAttribute("org.apache.jetspeed.request.RequestContext");
292             if (context != null)
293             {
294                 PortalURL url = context.getPortalURL();
295                 actionRequest = context.getActionWindow() != null;
296                 Iterator iter = url.getNavigationalState().getParameterNames(portletWindow);
297                 while (iter.hasNext())
298                 {
299                     String name = (String) iter.next();
300                     String[] values = url.getNavigationalState().getParameterValues(portletWindow, name);
301                     navParameters.put(name, values);
302                 }
303             }
304             
305             // now first merge the keys we have into one unique set
306             HashSet keys = new HashSet();
307             keys.addAll(portalParameters.keySet());
308             keys.addAll(queryParameters.keySet());
309             keys.addAll(navParameters.keySet());
310             
311             // now "merge" the parameters
312             // there are three different options:
313             // 1) query parameters + nav parameters:
314             //        portletMergePortalParametersWithPortletParameters == false && !actionRequest
315             // 2) query parameters + nav parameters + portal parameters
316             //           portletMergePortalParametersWithPortletParameters == true || actionRequest
317             //        && portletMergePortalParametersBeforePortletParameters == false
318             // 3) query parameters + portal parameters + nav parameters (odd use-case but provided because this was the "old" pre-2.1 behavior
319             //           portletMergePortalParametersWithPortletParameters == true || actionRequest
320             //        && portletMergePortalParametersBeforePortletParameters == true
321             portletParameters = new HashMap();
322             for ( Iterator iter = keys.iterator(); iter.hasNext(); )
323             {
324                 String key = (String)iter.next();
325                 String[] first = (String[])queryParameters.get(key);
326                 String[] next = null, last = null, result = null;
327                 
328                 if ( portletMergePortalParametersWithPortletParameters == false && !actionRequest )
329                 {
330                     next = (String[])navParameters.get(key);
331                 }
332                 else if ( portletMergePortalParametersBeforePortletParameters )
333                 {
334                     next = (String[])portalParameters.get(key);
335                     last = (String[])navParameters.get(key);
336                 }
337                 else
338                 {
339                     next = (String[])navParameters.get(key);
340                     last = (String[])portalParameters.get(key);
341                 }
342                 if ( first == null )
343                 {
344                     if ( next == null )
345                     {
346                         first = last;
347                         last = null;
348                     }
349                     else
350                     {
351                         first = next;
352                         next = last;
353                         last = null;
354                     }
355                 }
356                 else if ( next == null )
357                 {
358                     next = last;
359                     last = null;
360                 }
361                 
362                 if ( last == null )
363                 {
364                     if ( next == null && first != null )
365                     {
366                         result = new String[first.length];
367                         System.arraycopy(first,0,result,0,first.length);
368                     }
369                     else if (next != null )
370                     {
371                         result = new String[first.length + next.length];
372                         System.arraycopy(first,0,result,0,first.length);
373                         System.arraycopy(next,0,result,first.length,next.length);
374                     }
375                 }
376                 else
377                 {
378                     result = new String[first.length + next.length + last.length];
379                     System.arraycopy(first,0,result,0,first.length);
380                     System.arraycopy(next,0,result,first.length,next.length);
381                     System.arraycopy(last,0,result,first.length+next.length,last.length);
382                     
383                 }
384                 if ( result != null )
385                 {
386                     portletParameters.put(key, result);
387                 }
388             }
389         }
390         return Collections.unmodifiableMap(portletParameters);
391 
392     }
393 
394     public Enumeration getParameterNames()
395     {
396         return Collections.enumeration(this.getParameterMap().keySet());
397     }
398 
399     public String[] getParameterValues( String name )
400     {
401         return (String[]) this.getParameterMap().get(name);
402     }
403 
404     /***
405      * @see javax.servlet.http.HttpServletRequest#getAttributeNames()
406      */
407     public Enumeration getAttributeNames()
408     {
409         Enumeration attrNames = super.getAttributeNames();
410         
411         // In parallel mode, adjust attributes by the values of the current thread
412         Thread ct = Thread.currentThread();
413 
414         if (ct instanceof Worker || CurrentWorkerContext.getCurrentWorkerContextUsed())
415         {
416             // If cached attributes map is null, it should be re-created.
417             
418             if (cachedAttributes == null)
419             {
420                 HashMap adjustedAttrMap = new HashMap();
421                 
422                 // first, add all attributes of original request.
423                 
424                 while (attrNames.hasMoreElements())
425                 {
426                     String key = (String) attrNames.nextElement();
427                     adjustedAttrMap.put(key, super.getAttribute(key));
428                 }
429                 
430                 // second, add or override all attributes by the current worker context.
431                 
432                 Enumeration cwAttrNames = CurrentWorkerContext.getAttributeNames();
433                 
434                 while (cwAttrNames.hasMoreElements())
435                 {
436                     String key = (String) cwAttrNames.nextElement();
437                     adjustedAttrMap.put(key, CurrentWorkerContext.getAttribute(key));
438                 }
439                 
440                 cachedAttributes = Collections.unmodifiableMap(adjustedAttrMap);
441             }
442             
443             attrNames = Collections.enumeration(cachedAttributes.keySet());
444         }
445         
446         return attrNames;
447     }
448     
449     /***
450      * @see javax.servlet.http.HttpServletRequest#getAttribute(java.lang.String)
451      */
452     public Object getAttribute( String name )
453     {
454         Object value = null;
455 
456         // In parallel mode, first look up from the worker.
457 
458         Thread ct = Thread.currentThread();
459 
460         if (ct instanceof Worker || CurrentWorkerContext.getCurrentWorkerContextUsed())
461         {            
462             value = CurrentWorkerContext.getAttribute(name);
463 
464             // Because PortletRequestImpl class of pluto encodes the name of attribute before calling setAttribute(), 
465             // we have to check the encoded name also.
466             if (null == value)
467             {
468                 // Extra code (2 lines) from Nicolas... not clear to me why this is needed, as "pr" is not used. Commenting out for now...
469                 //PortletRequest pr = (PortletRequest) super.getAttribute("javax.portlet.request");
470                 //if (pr != null)
471                 value = CurrentWorkerContext.getAttribute(nameSpaceMapper.encode(portletWindow.getId(), name));
472             }
473         }
474 
475         // If no attribute found, then look up from the request
476         if (null == value) 
477         {
478             value = getAttributeInternal(name);
479         }
480 
481         return value;
482     }
483 
484     private Object getAttributeInternal( String name )
485     {
486         Object value = super.getAttribute(name);
487         if (name.equals(PortletRequest.USER_INFO))
488         {
489             JetspeedRequestContext context = (JetspeedRequestContext) getAttribute(PortalReservedParameters.REQUEST_CONTEXT_ATTRIBUTE);
490             if (null != context)
491             {
492                 String entityID = "--NULL--";
493                 PortletEntity entity = portletWindow.getPortletEntity();
494                 if (entity != null)
495                 {
496                     entityID = entity.getId().toString();
497                 }
498                 PortletApplicationDefinition portletAppDef = entity.getPortletDefinition()
499                         .getPortletApplicationDefinition();
500 
501                 if (null != portletAppDef)
502                 {
503                     value = context.getUserInfoMap(portletAppDef.getId());
504                     if (log.isDebugEnabled() && (null != value))
505                         log.debug(PortletRequest.USER_INFO + " map size: " + ((Map) value).size());
506                 }
507                 else
508                 {
509                     log.error("Entity is null:" + entityID);
510                 }
511 
512             }
513         }
514         else
515         {
516             if (null == value)
517             {
518                 PortletRequest pr = (PortletRequest) super.getAttribute("javax.portlet.request");
519                 if (pr != null)
520                 {
521                     value = super.getAttribute(nameSpaceMapper.encode(portletWindow.getId(),
522                             name));
523                 }
524             }
525         }
526         return value;
527     }
528 
529     /***
530      * @see javax.servlet.ServletRequest#getLocale()
531      */
532     public Locale getLocale()
533     {
534         //Locale preferedLocale = (Locale) getSession().getAttribute(RequestContext.PREFERED_LOCALE_SESSION_KEY);
535         RequestContext requestContext = (RequestContext) _getHttpServletRequest().getAttribute(PortalReservedParameters.REQUEST_CONTEXT_ATTRIBUTE);
536         Locale preferedLocale = requestContext.getLocale();
537         if (preferedLocale != null)
538         {
539             return preferedLocale;
540         }
541 
542         return super.getLocale();
543     }
544 
545     /***
546      * @see javax.servlet.ServletRequest#getLocales()
547      */
548     public Enumeration getLocales()
549     {
550         RequestContext requestContext = (RequestContext) _getHttpServletRequest().getAttribute(PortalReservedParameters.REQUEST_CONTEXT_ATTRIBUTE);
551         Locale preferedLocale = requestContext.getLocale();
552         if (preferedLocale != null)
553         {
554             return getLocaleEnum(preferedLocale);
555         }
556 
557         return super.getLocales();
558     }
559 
560     /***
561      * <p>
562      * getLocaleEnum
563      * </p>
564      *
565      * @param preferedLocale
566      * @return
567      */
568     protected Enumeration getLocaleEnum( Locale preferedLocale )
569     {
570         ArrayList locales = new ArrayList();
571         locales.add(preferedLocale);
572         Enumeration localeEnums = super.getLocales();
573         while (localeEnums.hasMoreElements())
574         {
575             locales.add(localeEnums.nextElement());
576         }
577         return new Enumerator(locales);
578     }
579 
580     /***
581      * @see javax.servlet.http.HttpServletRequest#getHeader(java.lang.String)
582      */
583     public String getHeader( String name )
584     {
585         if(name.equals(ACCEPT_LANGUAGE))
586         {
587             return getLocale().getLanguage();   
588         }
589         else
590         {
591             return super.getHeader(name);
592         }
593     }
594 
595     /***
596      * @see javax.servlet.http.HttpServletRequest#getHeaders(java.lang.String)
597      */
598     public Enumeration getHeaders( String name )
599     {
600         if(name.equals(ACCEPT_LANGUAGE))
601         {      
602             return getLocaleEnum(getLocale());         
603         }
604         else
605         {
606             return super.getHeaders(name);
607         }        
608 
609     }
610 
611     /***
612      * <p>
613      * setAttribute
614      * </p>
615      * 
616      * @see javax.servlet.ServletRequest#setAttribute(java.lang.String,
617      *      java.lang.Object)
618      * @param arg0
619      * @param arg1
620      */
621     public void setAttribute( String name, Object value )
622     {
623         if (name == null)
624         {
625             throw new IllegalArgumentException("Attribute name == null");
626         }
627         
628         // In parallel mode, put attribute into worker.
629 
630         Thread ct = Thread.currentThread();
631         boolean currentWorkerContextUsed = CurrentWorkerContext.getCurrentWorkerContextUsed();
632 
633         if (ct instanceof Worker || currentWorkerContextUsed) 
634         {
635             // when it is parallel rendering, the cached request attributes should be re-created later by setting it to null.
636             cachedAttributes = null;
637             
638             if (null == value) 
639             {
640                 CurrentWorkerContext.removeAttribute(name);
641             } 
642             else 
643             {
644                 CurrentWorkerContext.setAttribute(name, value);
645             }
646 
647             if (currentWorkerContextUsed || name.startsWith("org.apache.jetspeed"))
648             {
649                 setAttributeInternal(name, value);
650             }
651         }
652         else
653         {
654             // put attribute into request.
655             setAttributeInternal(name, value);
656         }
657     }
658 
659     private void setAttributeInternal( String name, Object value )
660     {
661         // This allows us to make jetpseed objects avaiable to portlets
662         // This makes the portlet non-portable but is a must admin portlets
663         if (name.startsWith("org.apache.jetspeed"))
664         {
665             if (value == null)
666             {
667                 this.removeAttribute(name);
668             }
669             else
670             {
671                 String encodedKey = nameSpaceMapper.encode(portletWindow.getId(), name);
672                 this._getHttpServletRequest().setAttribute(
673                         encodedKey, value);
674             }
675         }
676         super.setAttribute(name, value);
677     }
678 
679     /***
680      * <p>
681      * removeAttribute
682      * </p>
683      * 
684      * @see javax.servlet.ServletRequest#removeAttribute(java.lang.String)
685      * @param arg0
686      */
687     public void removeAttribute( String name )
688     {
689         if (name == null)
690         {
691             throw new IllegalArgumentException("Attribute name == null");
692         }
693         
694         // In parallel mode, remove attribute from worker.
695 
696         Thread ct = Thread.currentThread();
697 
698         if (ct instanceof Worker || CurrentWorkerContext.getCurrentWorkerContextUsed()) 
699         {
700             // when it is parallel rendering, the cached request attributes should be re-created later by setting it to null.
701             cachedAttributes = null;
702             
703             CurrentWorkerContext.removeAttribute(name);
704             
705             if (name.startsWith("org.apache.jetspeed")) {
706                 super.removeAttribute(name);
707             }
708         }
709         else
710         {
711             // remove attribute from request.
712             super.removeAttribute(name);
713         }        
714     }
715 
716     /***
717      * <p>
718      * getHeaderNames
719      * </p>
720      *
721      * @see javax.servlet.http.HttpServletRequest#getHeaderNames()
722      * @return
723      */
724     public Enumeration getHeaderNames()
725     {
726         return super.getHeaderNames();
727     }
728     
729     /***
730      * @param included when true, JSR-168 PLT.16.3.3 rules need to be enforced
731      */
732     public void setPortletDispatcherIncluded(boolean included)
733     {
734         this.included = included;
735     }
736     
737     /*
738      * JSR-168 PLT.16.3.3 cxxix
739      */
740   	public String getProtocol()
741   	{
742         return (included ? null : super.getProtocol() );
743   	}
744 
745     /*
746      * JSR-168 PLT.16.3.3 cxxix
747      */
748   	public String getRemoteAddr()
749   	{
750         return (included ? null : super.getRemoteAddr() );
751   	}
752 
753     /*
754      * JSR-168 PLT.16.3.3 cxxix
755      */
756   	public String getRemoteHost()
757   	{
758         return (included ? null : super.getRemoteHost() );
759   	}
760 
761     /*
762      * JSR-168 PLT.16.3.3 cxxix
763      */
764   	public StringBuffer getRequestURL()
765   	{
766         return (included ? null : super.getRequestURL());
767   	}
768 
769     /*
770      * JSR-168 PLT.16.3.3 cxxx
771      */
772     public String getPathInfo()
773   	{
774         return (included ? (String)super.getAttribute("javax.servlet.include.path_info") : super.getPathInfo());
775   	}
776 
777     /*
778      * JSR-168 PLT.16.3.3 cxxx
779      */
780   	public String getPathTranslated()
781   	{
782         return (included ? null : super.getPathTranslated());
783   	}
784 
785     /*
786      * JSR-168 PLT.16.3.3 cxxx
787      */
788   	public String getQueryString()
789   	{
790         return (included ? (String)super.getAttribute("javax.servlet.include.query_string") : super.getQueryString());
791   	}
792 
793     /*
794      * JSR-168 PLT.16.3.3 cxxx
795      */
796   	public String getRequestURI()
797   	{
798         return (included ? (String)super.getAttribute("javax.servlet.include.request_uri") : super.getRequestURI());
799   	}
800 
801     /*
802      * JSR-168 PLT.16.3.3 cxxx
803      */
804   	public String getServletPath()
805   	{
806         return (included ? (String)super.getAttribute("javax.servlet.include.servlet_path") : super.getServletPath());
807   	}
808 
809     /*
810      * JSR-168 PLT.16.3.3 cxxxi
811      */
812   	public String getContextPath() 
813   	{
814         return (included ? (String)super.getAttribute("javax.servlet.include.context_path") : super.getContextPath());
815   	}
816 
817     /*
818      * JSR-168 PLT.16.3.3 cxxxiv
819      */
820     public int getContentLength()
821     {
822         return (included ? 0 : super.getContentLength());
823     }
824 
825     /*
826      * JSR-168 PLT.16.3.3 cxxix
827      */
828     public String getRealPath(String arg0)
829     {
830         return (included ? null : super.getRealPath(arg0));
831     }
832 
833     /*
834      * JSR-168 PLT.16.3.3 cxxxii
835      */
836     public BufferedReader getReader() throws IOException
837     {
838         return (included ? null : super.getReader());
839     }
840 
841     /*
842      * JSR-168 PLT.16.3.3 cxxxii
843      */
844     public String getCharacterEncoding()
845     {
846         return (included ? null : super.getCharacterEncoding());
847     }
848 
849     /*
850      * JSR-168 PLT.16.3.3 cxxxii
851      */
852     public String getContentType()
853     {
854         return (included ? null : super.getContentType());
855     }
856 
857     /*
858      * JSR-168 PLT.16.3.3 cxxxii
859      */
860     public ServletInputStream getInputStream() throws IOException
861     {
862         return (included ? null : super.getInputStream());
863     }
864 
865     /*
866      * JSR-168 PLT.16.3.3 cxxxii
867      */
868     public void setCharacterEncoding(String arg0) throws UnsupportedEncodingException
869     {
870         if ( !included )
871         {
872             super.setCharacterEncoding(arg0);
873         }
874     }
875 }