001    /**
002     * Copyright (c) 2000-2013 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.GetterUtil;
022    import com.liferay.portal.kernel.util.JavaConstants;
023    import com.liferay.portal.kernel.util.ServerDetector;
024    import com.liferay.portal.kernel.util.Validator;
025    import com.liferay.portal.util.ClassLoaderUtil;
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            @Override
336            public String getRealPath(String path) {
337                    return null;
338            }
339    
340            @Override
341            public String getRemoteAddr() {
342                    return null;
343            }
344    
345            @Override
346            public String getRemoteHost() {
347                    return null;
348            }
349    
350            @Override
351            public int getRemotePort() {
352                    return 0;
353            }
354    
355            @Override
356            public String getRemoteUser() {
357                    return _portletRequest.getRemoteUser();
358            }
359    
360            @Override
361            public RequestDispatcher getRequestDispatcher(String path) {
362                    return _request.getRequestDispatcher(path);
363            }
364    
365            @Override
366            public String getRequestedSessionId() {
367                    return _portletRequest.getRequestedSessionId();
368            }
369    
370            @Override
371            public String getRequestURI() {
372                    return _requestURI;
373            }
374    
375            @Override
376            public StringBuffer getRequestURL() {
377                    return null;
378            }
379    
380            @Override
381            public String getScheme() {
382                    return _portletRequest.getScheme();
383            }
384    
385            @Override
386            public String getServerName() {
387                    return _portletRequest.getServerName();
388            }
389    
390            @Override
391            public int getServerPort() {
392                    return _portletRequest.getServerPort();
393            }
394    
395            @Override
396            public String getServletPath() {
397                    return _servletPath;
398            }
399    
400            @Override
401            public HttpSession getSession() {
402                    return getSession(true);
403            }
404    
405            @Override
406            public HttpSession getSession(boolean create) {
407                    HttpSession session = _request.getSession(create);
408    
409                    if (session == null) {
410                            return null;
411                    }
412    
413                    session = new PortletServletSession(session, _portletRequestImpl);
414    
415                    if (ServerDetector.isJetty()) {
416                            try {
417                                    session = wrapJettySession(session);
418                            }
419                            catch (Exception e) {
420                                    _log.error(e, e);
421                            }
422                    }
423    
424                    return session;
425            }
426    
427            @Override
428            public Principal getUserPrincipal() {
429                    return _portletRequest.getUserPrincipal();
430            }
431    
432            @Override
433            public boolean isRequestedSessionIdFromCookie() {
434                    return _request.isRequestedSessionIdFromCookie();
435            }
436    
437            /**
438             * @deprecated As of 6.1.0
439             */
440            @Override
441            public boolean isRequestedSessionIdFromUrl() {
442                    return _request.isRequestedSessionIdFromUrl();
443            }
444    
445            @Override
446            public boolean isRequestedSessionIdFromURL() {
447                    return _request.isRequestedSessionIdFromURL();
448            }
449    
450            @Override
451            public boolean isRequestedSessionIdValid() {
452                    return _portletRequest.isRequestedSessionIdValid();
453            }
454    
455            @Override
456            public boolean isSecure() {
457                    return _portletRequest.isSecure();
458            }
459    
460            @Override
461            public boolean isUserInRole(String role) {
462                    return _portletRequest.isUserInRole(role);
463            }
464    
465            @Override
466            public void removeAttribute(String name) {
467                    _portletRequest.removeAttribute(name);
468            }
469    
470            @Override
471            public void setAttribute(String name, Object obj) {
472                    _portletRequest.setAttribute(name, obj);
473            }
474    
475            @Override
476            public void setCharacterEncoding(String encoding)
477                    throws UnsupportedEncodingException {
478    
479                    if (_lifecycle.equals(PortletRequest.ACTION_PHASE) ||
480                            _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
481    
482                            ClientDataRequest clientDataRequest = _getClientDataRequest();
483    
484                            clientDataRequest.setCharacterEncoding(encoding);
485                    }
486            }
487    
488            protected HttpSession wrapJettySession(HttpSession session)
489                    throws Exception {
490    
491                    // This must be called through reflection because Resin tries to load
492                    // org/mortbay/jetty/servlet/AbstractSessionManager$SessionIf
493    
494                    ClassLoader classLoader = ClassLoaderUtil.getPortalClassLoader();
495    
496                    Class<?> jettyHttpSessionWrapperClass = classLoader.loadClass(
497                            "com.liferay.portal.servlet.JettyHttpSessionWrapper");
498    
499                    Constructor<?> constructor =
500                            jettyHttpSessionWrapperClass.getConstructor(
501                                    new Class[] {HttpSession.class});
502    
503                    return(HttpSession)constructor.newInstance(new Object[] {session});
504            }
505    
506            private ClientDataRequest _getClientDataRequest() {
507                    return (ClientDataRequest)_portletRequest;
508            }
509    
510            private EventRequest _getEventRequest() {
511                    return (EventRequest)_portletRequest;
512            }
513    
514            private static Log _log = LogFactoryUtil.getLog(
515                    PortletServletRequest.class);
516    
517            private boolean _include;
518            private String _lifecycle;
519            private boolean _named;
520            private String _pathInfo;
521            private PortletRequest _portletRequest;
522            private PortletRequestImpl _portletRequestImpl;
523            private String _queryString;
524            private HttpServletRequest _request;
525            private String _requestURI;
526            private String _servletPath;
527    
528    }