001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.kernel.servlet.HttpMethods;
020    import com.liferay.portal.kernel.servlet.ServletInputStreamAdapter;
021    import com.liferay.portal.kernel.util.ClassLoaderUtil;
022    import com.liferay.portal.kernel.util.GetterUtil;
023    import com.liferay.portal.kernel.util.JavaConstants;
024    import com.liferay.portal.kernel.util.ServerDetector;
025    import com.liferay.portal.kernel.util.Validator;
026    
027    import java.io.BufferedReader;
028    import java.io.IOException;
029    import java.io.InputStream;
030    import java.io.UnsupportedEncodingException;
031    
032    import java.lang.reflect.Constructor;
033    
034    import java.security.Principal;
035    
036    import java.util.Enumeration;
037    import java.util.Locale;
038    import java.util.Map;
039    
040    import javax.portlet.ClientDataRequest;
041    import javax.portlet.EventRequest;
042    import javax.portlet.PortletRequest;
043    
044    import javax.servlet.RequestDispatcher;
045    import javax.servlet.ServletInputStream;
046    import javax.servlet.http.Cookie;
047    import javax.servlet.http.HttpServletRequest;
048    import javax.servlet.http.HttpServletRequestWrapper;
049    import javax.servlet.http.HttpSession;
050    
051    /**
052     * @author Brian Wing Shun Chan
053     * @author Brian Myunghun Kim
054     */
055    public class PortletServletRequest extends HttpServletRequestWrapper {
056    
057            public PortletServletRequest(
058                    HttpServletRequest request, PortletRequest portletRequest,
059                    String pathInfo, String queryString, String requestURI,
060                    String servletPath, boolean named, boolean include) {
061    
062                    super(request);
063    
064                    _request = request;
065                    _portletRequest = portletRequest;
066                    _portletRequestImpl = PortletRequestImpl.getPortletRequestImpl(
067                            _portletRequest);
068                    _pathInfo = pathInfo;
069                    _queryString = queryString;
070                    _requestURI = GetterUtil.getString(requestURI);
071                    _servletPath = GetterUtil.getString(servletPath);
072                    _named = named;
073                    _include = include;
074    
075                    _lifecycle = _portletRequestImpl.getLifecycle();
076    
077                    if (Validator.isNotNull(_queryString)) {
078                            _portletRequestImpl.setPortletRequestDispatcherRequest(request);
079                    }
080            }
081    
082            @Override
083            public Object getAttribute(String name) {
084                    if (_include || (name == null)) {
085                            return _request.getAttribute(name);
086                    }
087    
088                    if (name.equals(JavaConstants.JAVAX_SERVLET_FORWARD_CONTEXT_PATH)) {
089                            if (_named) {
090                                    return null;
091                            }
092                            else {
093                                    return _portletRequest.getContextPath();
094                            }
095                    }
096    
097                    if (name.equals(JavaConstants.JAVAX_SERVLET_FORWARD_PATH_INFO)) {
098                            if (_named) {
099                                    return null;
100                            }
101                            else {
102                                    return _pathInfo;
103                            }
104                    }
105    
106                    if (name.equals(JavaConstants.JAVAX_SERVLET_FORWARD_QUERY_STRING)) {
107                            if (_named) {
108                                    return null;
109                            }
110                            else {
111                                    return _queryString;
112                            }
113                    }
114    
115                    if (name.equals(JavaConstants.JAVAX_SERVLET_FORWARD_REQUEST_URI)) {
116                            if (_named) {
117                                    return null;
118                            }
119                            else {
120                                    return _requestURI;
121                            }
122                    }
123    
124                    if (name.equals(JavaConstants.JAVAX_SERVLET_FORWARD_SERVLET_PATH)) {
125                            if (_named) {
126                                    return null;
127                            }
128                            else {
129                                    return _servletPath;
130                            }
131                    }
132    
133                    return _request.getAttribute(name);
134            }
135    
136            @Override
137            public Enumeration<String> getAttributeNames() {
138                    return _request.getAttributeNames();
139            }
140    
141            @Override
142            public String getAuthType() {
143                    return _request.getAuthType();
144            }
145    
146            @Override
147            public String getCharacterEncoding() {
148                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
149                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
150    
151                            return _request.getCharacterEncoding();
152                    }
153                    else {
154                            return null;
155                    }
156            }
157    
158            @Override
159            public int getContentLength() {
160                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
161                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
162    
163                            return _request.getContentLength();
164                    }
165                    else {
166                            return 0;
167                    }
168            }
169    
170            @Override
171            public String getContentType() {
172                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
173                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
174    
175                            return _request.getContentType();
176                    }
177                    else {
178                            return null;
179                    }
180            }
181    
182            @Override
183            public String getContextPath() {
184                    return _portletRequest.getContextPath();
185            }
186    
187            @Override
188            public Cookie[] getCookies() {
189                    return _request.getCookies();
190            }
191    
192            @Override
193            public long getDateHeader(String name) {
194                    return GetterUtil.getLong(getHeader(name), -1);
195            }
196    
197            @Override
198            public String getHeader(String name) {
199                    return _request.getHeader(name);
200            }
201    
202            @Override
203            public Enumeration<String> getHeaderNames() {
204                    return _request.getHeaderNames();
205            }
206    
207            @Override
208            public Enumeration<String> getHeaders(String name) {
209                    return _request.getHeaders(name);
210            }
211    
212            @Override
213            public ServletInputStream getInputStream() throws IOException {
214                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
215                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
216    
217                            ClientDataRequest clientDataRequest = _getClientDataRequest();
218    
219                            InputStream portletInputStream =
220                                    clientDataRequest.getPortletInputStream();
221    
222                            ServletInputStream servletInputStream =
223                                    new ServletInputStreamAdapter(portletInputStream);
224    
225                            return servletInputStream;
226                    }
227                    else {
228                            return null;
229                    }
230            }
231    
232            @Override
233            public int getIntHeader(String name) {
234                    return GetterUtil.getInteger(getHeader(name));
235            }
236    
237            @Override
238            public String getLocalAddr() {
239                    return null;
240            }
241    
242            @Override
243            public Locale getLocale() {
244                    return _portletRequest.getLocale();
245            }
246    
247            @Override
248            public Enumeration<Locale> getLocales() {
249                    return _portletRequest.getLocales();
250            }
251    
252            @Override
253            public String getLocalName() {
254                    return null;
255            }
256    
257            @Override
258            public int getLocalPort() {
259                    return 0;
260            }
261    
262            @Override
263            public String getMethod() {
264                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
265                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
266    
267                            ClientDataRequest clientDataRequest = _getClientDataRequest();
268    
269                            return clientDataRequest.getMethod();
270                    }
271    
272                    if (_lifecycle.equals(PortletRequest.RENDER_PHASE)) {
273                            return HttpMethods.GET;
274                    }
275    
276                    EventRequest eventRequest = _getEventRequest();
277    
278                    return eventRequest.getMethod();
279            }
280    
281            @Override
282            public String getParameter(String name) {
283                    return _portletRequest.getParameter(name);
284            }
285    
286            @Override
287            public Map<String, String[]> getParameterMap() {
288                    return _portletRequest.getParameterMap();
289            }
290    
291            @Override
292            public Enumeration<String> getParameterNames() {
293                    return _portletRequest.getParameterNames();
294            }
295    
296            @Override
297            public String[] getParameterValues(String name) {
298                    return _portletRequest.getParameterValues(name);
299            }
300    
301            @Override
302            public String getPathInfo() {
303                    return _pathInfo;
304            }
305    
306            @Override
307            public String getPathTranslated() {
308                    return _request.getPathTranslated();
309            }
310    
311            @Override
312            public String getProtocol() {
313                    return "HTTP/1.1";
314            }
315    
316            @Override
317            public String getQueryString() {
318                    return _queryString;
319            }
320    
321            @Override
322            public BufferedReader getReader() throws IOException {
323                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
324                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
325    
326                            ClientDataRequest clientDataRequest = _getClientDataRequest();
327    
328                            return clientDataRequest.getReader();
329                    }
330                    else {
331                            return null;
332                    }
333            }
334    
335            /**
336             * @deprecated As of 7.0.0
337             */
338            @Deprecated
339            @Override
340            public String getRealPath(String path) {
341                    return null;
342            }
343    
344            @Override
345            public String getRemoteAddr() {
346                    return null;
347            }
348    
349            @Override
350            public String getRemoteHost() {
351                    return null;
352            }
353    
354            @Override
355            public int getRemotePort() {
356                    return 0;
357            }
358    
359            @Override
360            public String getRemoteUser() {
361                    return _portletRequest.getRemoteUser();
362            }
363    
364            @Override
365            public RequestDispatcher getRequestDispatcher(String path) {
366                    return _request.getRequestDispatcher(path);
367            }
368    
369            @Override
370            public String getRequestedSessionId() {
371                    return _portletRequest.getRequestedSessionId();
372            }
373    
374            @Override
375            public String getRequestURI() {
376                    return _requestURI;
377            }
378    
379            @Override
380            public StringBuffer getRequestURL() {
381                    return null;
382            }
383    
384            @Override
385            public String getScheme() {
386                    return _portletRequest.getScheme();
387            }
388    
389            @Override
390            public String getServerName() {
391                    return _portletRequest.getServerName();
392            }
393    
394            @Override
395            public int getServerPort() {
396                    return _portletRequest.getServerPort();
397            }
398    
399            @Override
400            public String getServletPath() {
401                    return _servletPath;
402            }
403    
404            @Override
405            public HttpSession getSession() {
406                    return getSession(true);
407            }
408    
409            @Override
410            public HttpSession getSession(boolean create) {
411                    HttpSession session = _request.getSession(create);
412    
413                    if (session == null) {
414                            return null;
415                    }
416    
417                    session = new PortletServletSession(session, _portletRequestImpl);
418    
419                    if (ServerDetector.isJetty()) {
420                            try {
421                                    session = wrapJettySession(session);
422                            }
423                            catch (Exception e) {
424                                    _log.error(e, e);
425                            }
426                    }
427    
428                    return session;
429            }
430    
431            @Override
432            public Principal getUserPrincipal() {
433                    return _portletRequest.getUserPrincipal();
434            }
435    
436            @Override
437            public boolean isRequestedSessionIdFromCookie() {
438                    return _request.isRequestedSessionIdFromCookie();
439            }
440    
441            /**
442             * @deprecated As of 6.1.0
443             */
444            @Deprecated
445            @Override
446            public boolean isRequestedSessionIdFromUrl() {
447                    return _request.isRequestedSessionIdFromUrl();
448            }
449    
450            @Override
451            public boolean isRequestedSessionIdFromURL() {
452                    return _request.isRequestedSessionIdFromURL();
453            }
454    
455            @Override
456            public boolean isRequestedSessionIdValid() {
457                    return _portletRequest.isRequestedSessionIdValid();
458            }
459    
460            @Override
461            public boolean isSecure() {
462                    return _portletRequest.isSecure();
463            }
464    
465            @Override
466            public boolean isUserInRole(String role) {
467                    return _portletRequest.isUserInRole(role);
468            }
469    
470            @Override
471            public void removeAttribute(String name) {
472                    _portletRequest.removeAttribute(name);
473            }
474    
475            @Override
476            public void setAttribute(String name, Object obj) {
477                    _portletRequest.setAttribute(name, obj);
478            }
479    
480            @Override
481            public void setCharacterEncoding(String encoding)
482                    throws UnsupportedEncodingException {
483    
484                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
485                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
486    
487                            ClientDataRequest clientDataRequest = _getClientDataRequest();
488    
489                            clientDataRequest.setCharacterEncoding(encoding);
490                    }
491            }
492    
493            protected HttpSession wrapJettySession(HttpSession session)
494                    throws Exception {
495    
496                    // This must be called through reflection because Resin tries to load
497                    // org/mortbay/jetty/servlet/AbstractSessionManager$SessionIf
498    
499                    ClassLoader classLoader = ClassLoaderUtil.getPortalClassLoader();
500    
501                    Class<?> jettyHttpSessionWrapperClass = classLoader.loadClass(
502                            "com.liferay.portal.servlet.JettyHttpSessionWrapper");
503    
504                    Constructor<?> constructor =
505                            jettyHttpSessionWrapperClass.getConstructor(
506                                    new Class[] {HttpSession.class});
507    
508                    return(HttpSession)constructor.newInstance(new Object[] {session});
509            }
510    
511            private ClientDataRequest _getClientDataRequest() {
512                    return (ClientDataRequest)_portletRequest;
513            }
514    
515            private EventRequest _getEventRequest() {
516                    return (EventRequest)_portletRequest;
517            }
518    
519            private static final Log _log = LogFactoryUtil.getLog(
520                    PortletServletRequest.class);
521    
522            private final boolean _include;
523            private final String _lifecycle;
524            private final boolean _named;
525            private final String _pathInfo;
526            private final PortletRequest _portletRequest;
527            private final PortletRequestImpl _portletRequestImpl;
528            private final String _queryString;
529            private final HttpServletRequest _request;
530            private final String _requestURI;
531            private final String _servletPath;
532    
533    }