/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements.  See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.pluto.internal.impl;import java.io.BufferedReader;import java.io.IOException;import java.io.UnsupportedEncodingException;import java.security.Principal;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Collections;import java.util.Date;import java.util.Enumeration;import java.util.HashMap;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java.util.Locale;import java.util.Map;import java.util.Set;import java.util.Vector;import javax.ccpp.Profile;import javax.portlet.PortalContext;import javax.portlet.PortletMode;import javax.portlet.PortletPreferences;import javax.portlet.PortletRequest;import javax.portlet.PortletSession;import javax.portlet.WindowState;import javax.servlet.RequestDispatcher;import javax.servlet.ServletException;import javax.servlet.ServletInputStream;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse;import javax.servlet.http.Cookie;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletRequestWrapper;import javax.servlet.http.HttpSession;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.apache.pluto.Constants;import org.apache.pluto.OptionalContainerServices;import org.apache.pluto.PortletContainer;import org.apache.pluto.PortletEntity;import org.apache.pluto.PortletWindow;import org.apache.pluto.internal.InternalPortletContext;import org.apache.pluto.internal.InternalPortletRequest;import org.apache.pluto.internal.InternalPortletSession;import org.apache.pluto.om.portlet.PortletDefinition;import org.apache.pluto.om.portlet.SecurityRoleRef;import org.apache.pluto.om.portlet.Supports;import org.apache.pluto.spi.PortletURLProvider;import org.apache.pluto.spi.optional.PortletEnvironmentService;import org.apache.pluto.spi.optional.RequestAttributeService;import org.apache.pluto.util.ArgumentUtility;import org.apache.pluto.util.Enumerator;import org.apache.pluto.util.StringManager;import org.apache.pluto.util.StringUtils;/** * Abstract <code>javax.portlet.PortletRequest</code> implementation. * This class also implements InternalPortletRequest. * */public abstract class PortletRequestImpl extends HttpServletRequestWrapper                implements PortletRequest, InternalPortletRequest {    private static final Log LOG = LogFactory.getLog(PortletRequestImpl.class);        private static final StringManager EXCEPTIONS =            StringManager.getManager(PortletRequestImpl.class.getPackage().getName());        /**     * Cache for parsed dateHeader values.     */    protected static final HashMap<String,Long> dateHeaderParseCache = new HashMap<String,Long>();        /**     * The set of SimpleDateFormat formats to use in getDateHeader().     *     * Notice that because SimpleDateFormat is not thread-safe, we can't     * declare formats[] as a static variable.     */    protected SimpleDateFormat dateHeaderFormats[] = {        new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US),        new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss zzz", Locale.US),        new SimpleDateFormat("EEE MMMM d HH:mm:ss yyyy", Locale.US)    };        // Private Member Variables ------------------------------------------------        /** The parent container within which this request was created. */    protected PortletContainer container;        /** The portlet window which is the target of this portlet request. */    protected PortletWindow portletWindow;    /**     * The PortletContext associated with this Request. This PortletContext must     * be initialized from within the <code>PortletServlet</code>.     */    protected InternalPortletContext portletContext;    /** The PortalContext within which this request is occuring. */    protected PortalContext portalContext;    /** The portlet session. */    private InternalPortletSession portletSession;    /** Response content types. */    protected Vector<String> contentTypes;        /** FIXME: do we really need this?     * Flag indicating if the HTTP-Body has been accessed. */    protected boolean bodyAccessed = false;    /** True if we are in an include call. */    protected boolean included = false;        /** True if we are in an forwarded call. */    protected boolean forwarded = false;        protected boolean namedRequestDispatcher;        /** The corresponding servlet request. */    protected HttpServletRequest servletRequest = null;           protected PortletPreferences portletPreferences;    protected PortletURLProvider urlProvider;        protected Map<String, String[]> parameters = null;        protected String queryString = null;        // Constructors ------------------------------------------------------------    public PortletRequestImpl(InternalPortletRequest internalPortletRequest)     {        this(internalPortletRequest.getPortletContainer(),             internalPortletRequest.getPortletWindow(),             internalPortletRequest.getHttpServletRequest());    }    /**     * Creates a PortletRequestImpl instance.     * @param container  the portlet container.     * @param portletWindow  the internal portlet window.     * @param servletRequest  the underlying servlet request.     */    public PortletRequestImpl(PortletContainer container,                              PortletWindow portletWindow,                              HttpServletRequest servletRequest)     {        super(servletRequest);        this.container = container;        this.portletWindow = portletWindow;        this.portalContext = container.getRequiredContainerServices().getPortalContext();        this.servletRequest = servletRequest;        this.urlProvider = container        .getRequiredContainerServices()        .getPortalCallbackService()        .getPortletURLProvider(getHttpServletRequest(), portletWindow);            }        protected abstract Integer getRequestMethod();    // PortletRequest Impl -----------------------------------------------------    /* (non-Javadoc)	 * @see javax.portlet.PortletRequest#getWindowId()	 */	public String getWindowId() 	{		return portletWindow.getId().getStringId();	}        /**     * Determine whether or not the specified WindowState is allowed for this     * portlet.     *     * @param state the state in question     * @return true if the state is allowed.     */    public boolean isWindowStateAllowed(WindowState state)     {    	for (Enumeration<WindowState> en = portalContext.getSupportedWindowStates();    			en.hasMoreElements(); )     	{            if (en.nextElement().toString().equalsIgnoreCase(state.toString()))             {                return true;            }        }        return false;    }        public boolean isPortletModeAllowed(PortletMode mode)     {        return (isPortletModeAllowedByPortlet(mode)                && isPortletModeAllowedByPortal(mode));    }        public PortletMode getPortletMode()     {        return portletWindow.getPortletMode();    }        public WindowState getWindowState()     {        return portletWindow.getWindowState();    }        public PortletSession getPortletSession()     {        return getPortletSession(true);    }        /**     * Returns the portlet session.     * <p>     * Note that since portlet request instance is created everytime the portlet     * container receives an incoming request, the portlet session instance held     * by the request instance is also re-created for each incoming request.     * </p>     */    public PortletSession getPortletSession(boolean create)     {        if (LOG.isDebugEnabled())         {            LOG.debug("Retreiving portlet session (create=" + create + ")");        }        //        // It is critical that we don't retrieve the portlet session until the        //   cross context dispatch has been completed.  If we do then we risk        //   having a cached version which is invalid for the context within        //   which it exists.        //        if (portletContext == null)         {            throw new IllegalStateException(                    EXCEPTIONS.getString("error.session.illegalState"));        }        //        // We must make sure that if the session has been invalidated (perhaps        //   through setMaxIntervalTimeout()) and the underlying request        //   returns null that we no longer use the cached version.        // We have to check (ourselves) if the session has exceeded its max        //   inactive interval. If so, we should invalidate the underlying        //   HttpSession and recreate a new one (if the create flag is set to        //   true) -- We just cannot depend on the implementation of        //   javax.servlet.http.HttpSession!        //        HttpSession httpSession = getHttpServletRequest().getSession(create);        if (httpSession != null)         {        	// HttpSession is not null does NOT mean that it is valid.            int maxInactiveInterval = httpSession.getMaxInactiveInterval();            long lastAccesstime = httpSession.getLastAccessedTime();//lastAccesstime checks added for PLUTO-436            if (maxInactiveInterval >= 0 && lastAccesstime > 0)             {    // < 0 => Never expires.                long maxInactiveTime = httpSession.getMaxInactiveInterval() * 1000L;                long currentInactiveTime = System.currentTimeMillis() - lastAccesstime;                if (currentInactiveTime > maxInactiveTime)                 {                    if (LOG.isDebugEnabled())                     {                        LOG.debug("The underlying HttpSession is expired and "                            + "should be invalidated.");                    }                    httpSession.invalidate();                    httpSession = getHttpServletRequest().getSession(create);                    //Added for PLUTO-436                    // a cached portletSession is no longer useable.                    // a new one will be created below.                    portletSession = null;                }            }        }        if (httpSession == null)         {            if (LOG.isDebugEnabled())             {                LOG.debug("The underlying HttpSession is not available: "                		+ "no session will be returned.");            }            return null;        }        //        // If we reach here, we are sure that the underlying HttpSession is        //   available. If we haven't created and cached a portlet session        //   instance, we will create and cache one now.        //        if (portletSession == null)         {        	if (LOG.isDebugEnabled())         	{        		LOG.debug("Creating new portlet session...");        	}            final OptionalContainerServices optionalContainerServices = container.getOptionalContainerServices();            final PortletEnvironmentService portletEnvironmentService = optionalContainerServices.getPortletEnvironmentService();                        portletSession = portletEnvironmentService.createPortletSession(container,                                                                             getHttpServletRequest(),                                                                            portletContext,                                                                             httpSession,                                                                             portletWindow);        }                return portletSession;    }        public String getProperty(String name)    {    	ArgumentUtility.validateNotNull("propertyName", name);        String property = this.getHttpServletRequest().getHeader(name);        if (property == null)         {            Map<String, String[]> propertyMap = container.getRequiredContainerServices()                    .getPortalCallbackService().getRequestPropertyProvider()                    .getProperties(                    		getHttpServletRequest(),                    		portletWindow);            if (propertyMap != null)             {                String[] properties = (String[]) propertyMap.get(name);                if (properties != null && properties.length > 0)                 {                	property = properties[0];                }            }        }        return property;    }    public Enumeration<String> getProperties(String name)     {    	ArgumentUtility.validateNotNull("propertyName", name);        Set<String> v = new HashSet<String>();        Enumeration<String> props = this.getHttpServletRequest().getHeaders(name);        if (props != null)         {            while (props.hasMoreElements())             {                v.add(props.nextElement());            }        }        // get properties from PropertyManager        Map<String, String[]> map = container.getRequiredContainerServices()                .getPortalCallbackService().getRequestPropertyProvider().getProperties(getHttpServletRequest(), portletWindow);        if (map != null)         {            String[] properties = (String[]) map.get(name);            if (properties != null)             {                // add properties to vector                for (int i = 0; i < properties.length; i++)                 {                    v.add(properties[i]);                }            }        }        return new Enumerator(v.iterator());    }    public Enumeration<String> getPropertyNames()     {        Set<String> v = new HashSet<String>();        // get properties from PropertyManager        Map<String, String[]> map = container.getRequiredContainerServices()                .getPortalCallbackService().getRequestPropertyProvider()                .getProperties(getHttpServletRequest(), portletWindow);        if (map != null)         {            v.addAll(map.keySet());        }        // get properties from request header        Enumeration<String> props = this.getHttpServletRequest().getHeaderNames();        if (props != null)         {            while (props.hasMoreElements())             {                v.add(props.nextElement());            }        }        return new Enumerator(v.iterator());    }    public PortalContext getPortalContext()     {        return container.getRequiredContainerServices().getPortalContext();    }    public String getAuthType()     {        return this.getHttpServletRequest().getAuthType();    }    public String getContextPath()     {        return portletContext.getContextPath();    }    public String getRemoteUser()     {        return this.getHttpServletRequest().getRemoteUser();    }    public Principal getUserPrincipal()     {        return this.getHttpServletRequest().getUserPrincipal();    }