Java Globals.IS_SECURITY_ENABLED属性代码示例

/**
 * Obtain the declared methods for a class taking account of any security
 * manager that may be configured.
 */
public static Method[] getDeclaredMethods(final Class<?> clazz) {
    Method[] methods = null;
    if (Globals.IS_SECURITY_ENABLED) {
        methods = AccessController.doPrivileged(
                new PrivilegedAction<Method[]>(){
            @Override
            public Method[] run(){
                return clazz.getDeclaredMethods();
            }
        });
    } else {
        methods = clazz.getDeclaredMethods();
    }
    return methods;
}
 

/**
 * Forward this request and response to another resource for processing.
 * Any runtime exception, IOException, or ServletException thrown by the
 * called servlet will be propogated to the caller.
 *
 * @param request The servlet request to be forwarded
 * @param response The servlet response to be forwarded
 *
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet exception occurs
 */
public void forward(ServletRequest request, ServletResponse response)
    throws ServletException, IOException
{
    if (Globals.IS_SECURITY_ENABLED) {
        try {
            PrivilegedForward dp = new PrivilegedForward(request,response);
            AccessController.doPrivileged(dp);
        } catch (PrivilegedActionException pe) {
            Exception e = pe.getException();
            if (e instanceof ServletException)
                throw (ServletException) e;
            throw (IOException) e;
        }
    } else {
        doForward(request,response);
    }
}
 

/**
 * Obtain the declared fields for a class taking account of any security
 * manager that may be configured.
 */
public static Field[] getDeclaredFields(final Class<?> clazz) {
    Field[] fields = null;
    if (Globals.IS_SECURITY_ENABLED) {
        fields = AccessController.doPrivileged(
                new PrivilegedAction<Field[]>(){
            @Override
            public Field[] run(){
                return clazz.getDeclaredFields();
            }
        });
    } else {
        fields = clazz.getDeclaredFields();
    }
    return fields;
}
 

@Override
public boolean check(Permission permission) {
	if (!Globals.IS_SECURITY_ENABLED) {
		return true;
	}
	Policy currentPolicy = Policy.getPolicy();
	if (currentPolicy != null) {
		ResourceEntry entry = findResourceInternal("/", "/", false);
		if (entry != null) {
			CodeSource cs = new CodeSource(entry.codeBase, (java.security.cert.Certificate[]) null);
			PermissionCollection pc = currentPolicy.getPermissions(cs);
			if (pc.implies(permission)) {
				return true;
			}
		}
	}
	return false;
}
 

/**
 * Return the <code>SecurityManager</code> only if Security is enabled AND
 * package protection mechanism is enabled.
 */
public static boolean isPackageProtectionEnabled(){
    if (packageDefinitionEnabled && Globals.IS_SECURITY_ENABLED){
        return true;
    }
    return false;
}
 

@Override
public Enumeration<String> getParameterNames() {

    if (request == null) {
        throw new IllegalStateException(
                        sm.getString("requestFacade.nullRequest"));
    }

    if (Globals.IS_SECURITY_ENABLED){
        return AccessController.doPrivileged(
            new GetParameterNamesPrivilegedAction());
    } else {
        return request.getParameterNames();
    }
}
 

@Override
public void setDateHeader(String name, long date) {

    if (isCommitted()) {
        return;
    }

    if(Globals.IS_SECURITY_ENABLED) {
        AccessController.doPrivileged(new DateHeaderPrivilegedAction
                                         (name, date, false));
    } else {
        response.setDateHeader(name, date);
    }

}
 

/**
 * Invoke the next filter in this chain, passing the specified request
 * and response.  If there are no more filters in this chain, invoke
 * the <code>service()</code> method of the servlet itself.
 *
 * @param request The servlet request we are processing
 * @param response The servlet response we are creating
 *
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet exception occurs
 */
public void doFilter(ServletRequest request, ServletResponse response)
    throws IOException, ServletException {

    if( Globals.IS_SECURITY_ENABLED ) {
        final ServletRequest req = request;
        final ServletResponse res = response;
        try {
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedExceptionAction() {
                    public Object run() 
                        throws ServletException, IOException {
                        internalDoFilter(req,res);
                        return null;
                    }
                }
            );
        } catch( PrivilegedActionException pe) {
            Exception e = pe.getException();
            if (e instanceof ServletException)
                throw (ServletException) e;
            else if (e instanceof IOException)
                throw (IOException) e;
            else if (e instanceof RuntimeException)
                throw (RuntimeException) e;
            else
                throw new ServletException(e.getMessage(), e);
        }
    } else {
        internalDoFilter(request,response);
    }
}
 

/**
 * Release all object references, and initialize instance variables, in
 * preparation for reuse of this object.
 */
public void recycle() {

    outputBuffer.recycle();
    usingOutputStream = false;
    usingWriter = false;
    appCommitted = false;
    included = false;
    errorState.set(0);
    isCharacterEncodingSet = false;

    if (Globals.IS_SECURITY_ENABLED || Connector.RECYCLE_FACADES) {
        if (facade != null) {
            facade.clear();
            facade = null;
        }
        if (outputStream != null) {
            outputStream.clear();
            outputStream = null;
        }
        if (writer != null) {
            writer.clear();
            writer = null;
        }
    } else {
        writer.recycle();
    }

}
 

@Override
public Map<String,String[]> getParameterMap() {

    if (request == null) {
        throw new IllegalStateException(
                        sm.getString("requestFacade.nullRequest"));
    }

    if (Globals.IS_SECURITY_ENABLED){
        return AccessController.doPrivileged(
            new GetParameterMapPrivilegedAction());
    } else {
        return request.getParameterMap();
    }
}
 

/**
 * Process the event, using the security manager if the option is enabled.
 * 
 * @param event the event to process
 * 
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet exception occurs
 */
@Override
public void doFilterEvent(CometEvent event)
    throws IOException, ServletException {

    if( Globals.IS_SECURITY_ENABLED ) {
        final CometEvent ev = event;
        try {
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedExceptionAction<Void>() {
                    @Override
                    public Void run() 
                        throws ServletException, IOException {
                        internalDoFilterEvent(ev);
                        return null;
                    }
                }
            );
        } catch( PrivilegedActionException pe) {
            Exception e = pe.getException();
            if (e instanceof ServletException)
                throw (ServletException) e;
            else if (e instanceof IOException)
                throw (IOException) e;
            else if (e instanceof RuntimeException)
                throw (RuntimeException) e;
            else
                throw new ServletException(e.getMessage(), e);
        }
    } else {
        internalDoFilterEvent(event);
    }
}
 

public String getCharacterEncoding() {

        if (request == null) {
            throw new IllegalStateException(
                            sm.getString("requestFacade.nullRequest"));
        }

        if (Globals.IS_SECURITY_ENABLED){
            return (String)AccessController.doPrivileged(
                new GetCharacterEncodingPrivilegedAction());
        } else {
            return request.getCharacterEncoding();
        }         
    }
 

@Override
public void setDateHeader(String name, long date) {

	if (isCommitted()) {
		return;
	}

	if (Globals.IS_SECURITY_ENABLED) {
		AccessController.doPrivileged(new DateHeaderPrivilegedAction(name, date, false));
	} else {
		response.setDateHeader(name, date);
	}

}
 

public ELContextImpl() {
    this(ELResolverImpl.getDefaultResolver());
    if (Globals.IS_SECURITY_ENABLED) {
        functionMapper = new FunctionMapper() {
            public Method resolveFunction(String prefix, String localName) {
                return null;
            }
        };
    } else {
        functionMapper = NullFunctionMapper;
    }
}
 

@Override
public String getCharacterEncoding() {

    if (request == null) {
        throw new IllegalStateException(
                        sm.getString("requestFacade.nullRequest"));
    }

    if (Globals.IS_SECURITY_ENABLED){
        return AccessController.doPrivileged(
            new GetCharacterEncodingPrivilegedAction());
    } else {
        return request.getCharacterEncoding();
    }
}