gt: 		if (SecurityUtil.isPackageProtectionEnabled()) {
context: /*
   * JBoss, Home of Professional Open Source Copyright 2009, JBoss Inc., and
   * individual contributors as indicated by the @authors tag. See the
   * copyright.txt in the distribution for a full listing of individual
   * contributors.
   * 
   * This is free software; you can redistribute it and/or modify it under the
   * terms of the GNU Lesser General Public License as published by the Free
   * Software Foundation; either version 2.1 of the License, or (at your option)
   * any later version.
   * 
   * This software is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   * details.
   * 
   * You should have received a copy of the GNU Lesser General Public License
   * along with this software; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA, or see the FSF
   * site: http://www.fsf.org.
   * 
   * 
   * This file incorporates work covered by the following copyright and permission
   * notice:
   * 
   * Copyright 1999-2009 The Apache Software Foundation
   * 
   * 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.catalina.core;
  
  import java.io.InputStream;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.security.AccessController;
  import java.security.PrivilegedActionException;
  import java.security.PrivilegedExceptionAction;
  import java.util.EnumSet;
  import java.util.Enumeration;
  import java.util.EventListener;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Set;
  
  import javax.servlet.Filter;
  import javax.servlet.FilterRegistration;
  import javax.servlet.RequestDispatcher;
  import javax.servlet.Servlet;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.ServletRegistration;
  import javax.servlet.SessionCookieConfig;
  import javax.servlet.SessionTrackingMode;
  import javax.servlet.descriptor.JspConfigDescriptor;
  
  import org.apache.catalina.Globals;
  import org.apache.catalina.security.SecurityUtil;
  
  /**
   * Facade object which masks the internal <code>ApplicationContext</code> object
   * from the web application.
   * 
   * @author Remy Maucherat
   * @author Jean-Francois Arcand
   * @version $Revision: 1236 $ $Date: 2009-11-02 23:17:08 +0100 (Mon, 02 Nov
   *          2009) $
   */
  
  public final class ApplicationContextFacade implements ServletContext {
  
  	// ---------------------------------------------------------- Attributes
  	/**
  	 * Cache Class object used for reflection.
  	 */
  	private HashMap<Object, Object> classCache;
  
  	/**
  	 * Cache method object.
  	 */
  	private HashMap<Object, Object> objectCache;
  
  	// ----------------------------------------------------------- Constructors
  
  	/**
  	 * Construct a new instance of this class, associated with the specified
  	 * Context instance.
  	 * 
  	 * @param context
  	 *            The associated Context instance
  	 */
  	public ApplicationContextFacade(ApplicationContext context) {
  		super();
  		this.context = context;
  
  		classCache = new HashMap();
  		objectCache = new HashMap();
  		initClassCache();
  	}
  
  	private void initClassCache() {
  		// FIXME: redo method list
  		Class<?>[] clazz = new Class<?>[] { String.class };
  		classCache.put("getContext", clazz);
  		classCache.put("getMimeType", clazz);
  		classCache.put("getResourcePaths", clazz);
  		classCache.put("getResource", clazz);
  		classCache.put("getResourceAsStream", clazz);
  		classCache.put("getRequestDispatcher", clazz);
  		classCache.put("getNamedDispatcher", clazz);
  		classCache.put("getServlet", clazz);
  		classCache.put("getInitParameter", clazz);
  		classCache.put("setAttribute", new Class[] { String.class, Object.class });
  		classCache.put("removeAttribute", clazz);
  		classCache.put("getRealPath", clazz);
  		classCache.put("getAttribute", clazz);
  		classCache.put("log", clazz);
  		classCache.put("setSessionTrackingModes", new Class[] { EnumSet.class });
  		classCache.put("setSessionCookieConfig", new Class[] { SessionCookieConfig.class });
  	}
  
  	// ----------------------------------------------------- Instance Variables
  
  	/**
  	 * Wrapped application context.
  	 */
  	private ApplicationContext context = null;
  
  	// ------------------------------------------------- ServletContext Methods
  
  	public ServletContext getContext(String uripath) {
  		ServletContext theContext = null;
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			theContext = (ServletContext) doPrivileged("getContext", new Object[] { uripath });
  		} else {
  			theContext = context.getContext(uripath);
  		}
  		if ((theContext != null) && (theContext instanceof ApplicationContext)) {
  			theContext = ((ApplicationContext) theContext).getFacade();
  		}
  		return (theContext);
  	}
  
  	public int getMajorVersion() {
  		return context.getMajorVersion();
  	}
  
  	public int getMinorVersion() {
  		return context.getMinorVersion();
  	}
  
  	public String getMimeType(String file) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (String) doPrivileged("getMimeType", new Object[] { file });
  		} else {
  			return context.getMimeType(file);
  		}
  	}
  
  	public Set<String> getResourcePaths(String path) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (Set<String>) doPrivileged("getResourcePaths", new Object[] { path });
  		} else {
  			return context.getResourcePaths(path);
  		}
  	}
  
  	public URL getResource(String path) throws MalformedURLException {
  		if (Globals.IS_SECURITY_ENABLED) {
  			try {
  				return (URL) invokeMethod(context, "getResource", new Object[] { path });
  			} catch (Throwable t) {
  				if (t instanceof MalformedURLException) {
  					throw (MalformedURLException) t;
  				}
  				return null;
  			}
  		} else {
  			return context.getResource(path);
  		}
  	}
  
  	public InputStream getResourceAsStream(String path) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (InputStream) doPrivileged("getResourceAsStream", new Object[] { path });
  		} else {
  			return context.getResourceAsStream(path);
  		}
  	}
  
  	public RequestDispatcher getRequestDispatcher(final String path) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (RequestDispatcher) doPrivileged("getRequestDispatcher", new Object[] { path });
  		} else {
  			return context.getRequestDispatcher(path);
  		}
  	}
  
  	public RequestDispatcher getNamedDispatcher(String name) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (RequestDispatcher) doPrivileged("getNamedDispatcher", new Object[] { name });
  		} else {
  			return context.getNamedDispatcher(name);
  		}
  	}
  
  	public Servlet getServlet(String name) throws ServletException {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			try {
  				return (Servlet) invokeMethod(context, "getServlet", new Object[] { name });
  			} catch (Throwable t) {
  				if (t instanceof ServletException) {
  					throw (ServletException) t;
  				}
  				return null;
  			}
  		} else {
  			return context.getServlet(name);
  		}
  	}
  
  	public Enumeration getServlets() {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (Enumeration) doPrivileged("getServlets", null);
  		} else {
  			return context.getServlets();
  		}
  	}
  
  	public Enumeration getServletNames() {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (Enumeration) doPrivileged("getServletNames", null);
  		} else {
  			return context.getServletNames();
  		}
  	}
  
  	public void log(String msg) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			doPrivileged("log", new Object[] { msg });
  		} else {
  			context.log(msg);
  		}
  	}
  
  	public void log(Exception exception, String msg) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			doPrivileged("log", new Class[] { Exception.class, String.class }, new Object[] {
  					exception, msg });
  		} else {
  			context.log(exception, msg);
  		}
  	}
  
  	public void log(String message, Throwable throwable) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			doPrivileged("log", new Class[] { String.class, Throwable.class }, new Object[] {
  					message, throwable });
  		} else {
  			context.log(message, throwable);
  		}
  	}
  
  	public String getRealPath(String path) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (String) doPrivileged("getRealPath", new Object[] { path });
  		} else {
  			return context.getRealPath(path);
  		}
  	}
  
  	public String getServerInfo() {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (String) doPrivileged("getServerInfo", null);
  		} else {
  			return context.getServerInfo();
  		}
  	}
  
  	public String getInitParameter(String name) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (String) doPrivileged("getInitParameter", new Object[] { name });
  		} else {
  			return context.getInitParameter(name);
  		}
  	}
  
  	public Enumeration getInitParameterNames() {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (Enumeration) doPrivileged("getInitParameterNames", null);
  		} else {
  			return context.getInitParameterNames();
  		}
  	}
  
  	public Object getAttribute(String name) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return doPrivileged("getAttribute", new Object[] { name });
  		} else {
  			return context.getAttribute(name);
  		}
  	}
  
  	public Enumeration getAttributeNames() {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (Enumeration) doPrivileged("getAttributeNames", null);
  		} else {
  			return context.getAttributeNames();
  		}
  	}
  
  	public void setAttribute(String name, Object object) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			doPrivileged("setAttribute", new Object[] { name, object });
  		} else {
  			context.setAttribute(name, object);
  		}
  	}
  
  	public void removeAttribute(String name) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			doPrivileged("removeAttribute", new Object[] { name });
  		} else {
  			context.removeAttribute(name);
  		}
  	}
  
  	public String getServletContextName() {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (String) doPrivileged("getServletContextName", null);
  		} else {
  			return context.getServletContextName();
  		}
  	}
  
  	public String getContextPath() {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (String) doPrivileged("getContextPath", null);
  		} else {
  			return context.getContextPath();
  		}
  	}
  
  	public FilterRegistration.Dynamic addFilter(String filterName, String className)
  			throws IllegalArgumentException, IllegalStateException {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (FilterRegistration.Dynamic) doPrivileged("addFilter", new Object[] {
  					filterName, className });
  		} else {
  			return context.addFilter(filterName, className);
  		}
  	}
  
  	public FilterRegistration.Dynamic addFilter(String filterName, Filter filter) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (FilterRegistration.Dynamic) doPrivileged("addFilter", new Object[] {
  					filterName, filter });
  		} else {
  			return context.addFilter(filterName, filter);
  		}
  	}
  
  	public FilterRegistration.Dynamic addFilter(String filterName,
  			Class<? extends Filter> filterClass) {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (FilterRegistration.Dynamic) doPrivileged("addFilter", new Object[] {
  					filterName, filterClass });
  		} else {
  			return context.addFilter(filterName, filterClass);
  		}
  	}
  
  	public ServletRegistration.Dynamic addServlet(String servletName, String className)
  			throws IllegalArgumentException, IllegalStateException {
  		if (SecurityUtil.isPackageProtectionEnabled()) {
  			return (ServletRegistration.Dynamic) doPrivileged("addServlet", new Object[] {
  					servletName, className });
  		} else {
  			return context.addServlet(servletName, className);
  		}
  	}
  
  	public ServletRegistration.Dynamic addServlet(String servletName, Class<? extends Servlet> clazz)
  			throws IllegalArgumentException, IllegalStateException {
  