JPolicyConfiguration.java

package org.objectweb.jonas_lib.security.jacc;

import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Principal;
import java.security.SecurityPermission;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

import javax.security.jacc.PolicyConfiguration;
import javax.security.jacc.PolicyContextException;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

import org.objectweb.jonas_lib.I18n;

import org.objectweb.common.TraceCore;

public class JPolicyConfiguration implements PolicyConfiguration {

    private static final int NB_STATES = 3;

    private static final int OPEN = 0;


    private static final int IN_SERVICE = 1;

    private static final int DELETED = 2;

    private static I18n i18n = I18n.getInstance(JPolicyConfiguration.class);

    private static String[] states = null;

    private int state;

    private String contextID = null;

    private static Logger logger = null;


    private PermissionCollection excludedPermissions = null;

    private PermissionCollection uncheckedPermissions = null;

    private Map rolePermissions = null;

    public JPolicyConfiguration(String contextID) {
        this.contextID = contextID;

        // init logger
        logger = TraceCore.sec;

        // init string representation
        if (states == null) {
            // 3 states
            states = new String[NB_STATES];
            states[OPEN] = i18n.getMessage("JPolicyConfiguration.openState");
            states[IN_SERVICE] = i18n.getMessage("JPolicyConfiguration.inServiceState");
            states[DELETED] = i18n.getMessage("JPolicyConfiguration.deletedState");
        }

        // initial state is open
        resetState();

        // init permissions
        excludedPermissions = new Permissions();
        uncheckedPermissions = new Permissions();
        rolePermissions = new HashMap();
    }

    public void addToExcludedPolicy(Permission permission)
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Adding permission '" + permission + "' as excluded policy.");
        }

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Add permission
        if (permission != null) {
            excludedPermissions.add(permission);
        }

    }

    public void addToExcludedPolicy(PermissionCollection permissions)
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Adding permissions '" + permissions + "' as excluded policy.");
        }

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Add permissions
        if (permissions != null) {
            for (Enumeration e = permissions.elements(); e.hasMoreElements();) {
                excludedPermissions.add((Permission) e.nextElement());
            }
        }

    }

    public void addToRole(String roleName, Permission permission)
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Adding permission '" + permission + "' to role '" + roleName + "'.");
        }

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Fail if roleName is null
        if (roleName == null) {
            throw new PolicyContextException(i18n.getMessage("JPolicyConfiguration.addToRole"));
        }


        // Break if permission is null
        if (permission == null) {
            return;
        }
        PermissionCollection permissionsOfRole = (PermissionCollection) rolePermissions.get(roleName);

        //create permission object if no previous permission for the given role
        if (permissionsOfRole == null) {
            permissionsOfRole = new Permissions();
        }
        permissionsOfRole.add(permission);

        // add to the list
        rolePermissions.put(roleName, permissionsOfRole);

    }

    public void addToRole(String roleName, PermissionCollection permissions)
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Adding permissions '" + permissions + "' to role '" + roleName + "'.");
        }

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Fail if roleName is null
        if (roleName == null) {
            throw new PolicyContextException(i18n.getMessage("JPolicyConfiguration.addToRole"));
        }


        // Break if permission is null
        if (permissions == null) {
            return;
        }
        PermissionCollection permissionsOfRole = (PermissionCollection) rolePermissions.get(roleName);

        //create permission object if no previous permission for the given role
        if (permissionsOfRole == null) {
            permissionsOfRole = new Permissions();
        }

        for (Enumeration e = permissions.elements(); e.hasMoreElements();) {
            permissionsOfRole.add((Permission) e.nextElement());
        }

        // add to the list
        rolePermissions.put(roleName, permissionsOfRole);

    }

    public void addToUncheckedPolicy(Permission permission)
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Adding permission '" + permission + "' as unchecked policy.");
        }

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Add permission
        if (permission != null) {
            uncheckedPermissions.add(permission);
        }

    }

    public void addToUncheckedPolicy(PermissionCollection permissions)
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Adding permissions '" + permissions + "' as unchecked policy.");
        }

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Add permissions
        if (permissions != null) {
            for (Enumeration e = permissions.elements(); e.hasMoreElements();) {
                uncheckedPermissions.add((Permission) e.nextElement());
            }
        }

    }


    public void commit() throws PolicyContextException, SecurityException, UnsupportedOperationException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Deleted state refused
        checkCurrentStateNotInState(DELETED);

        // Now state is in service
        state = IN_SERVICE;

        // add the configuration of this object
        JPolicyConfigurationKeeper.addConfiguration(this);
   }

    public void delete() throws PolicyContextException, SecurityException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // all policy statements are deleted
        excludedPermissions = new Permissions();
        uncheckedPermissions = new Permissions();
        rolePermissions = new HashMap();

        // change state to DELETED
        state = DELETED;

        // remove the configuration of this object
        JPolicyConfigurationKeeper.removeConfiguration(this);

    }

    public String getContextID() throws PolicyContextException, SecurityException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        return contextID;
    }

    public boolean inService() throws PolicyContextException, SecurityException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        return (state == IN_SERVICE);
    }

    public void linkConfiguration(PolicyConfiguration link)
        throws IllegalArgumentException, PolicyContextException, SecurityException, UnsupportedOperationException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Equivalent to this PolicyConfiguration object ?
        if (this.equals(link)) {
            throw new IllegalArgumentException(i18n.getMessage("JPolicyConfiguration.linkConfiguration.equivalent", this, link));
        }

        //TODO : link objects together.

    }

    public void removeExcludedPolicy()
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // reinit
        excludedPermissions = new Permissions();
    }

    public void removeRole(String roleName)
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Remove role permissions
        rolePermissions.remove(roleName);
    }

    public void removeUncheckedPolicy()
        throws PolicyContextException, SecurityException, UnsupportedOperationException {

        // Section 3.3 - Check permissions
        checkSetPolicy();

        // Open state required
        checkCurrentStateIsInState(OPEN);

        // Remove unckecked policy
        uncheckedPermissions = new Permissions();
    }

    private void checkCurrentStateNotInState(int s) throws UnsupportedOperationException {
        if (this.state == s) {
            String err = i18n.getMessage("JPolicyConfiguration.checkCurrentStateNotInState.notValidState", states[s], states[state]);
            throw new UnsupportedOperationException(err);
        }
    }

    private void checkCurrentStateIsInState(int s) throws UnsupportedOperationException {
        if (this.state != s) {
            String err = i18n.getMessage("JPolicyConfiguration.checkCurrentStateNotInState.notValidState", states[state], states[s]);
            throw new UnsupportedOperationException(err);
        }
    }

    private void checkSetPolicy() throws SecurityException {
        SecurityManager securityManager = System.getSecurityManager();
        if (securityManager != null) {
            securityManager.checkPermission(new SecurityPermission("setPolicy"));
        }
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof PolicyConfiguration)) {
            if (logger.isLoggable(BasicLevel.ERROR)) {
                logger.log(BasicLevel.ERROR, i18n.getMessage("JPolicyConfiguration.equals.notInstanceOf"));
            }
            return false;
        } else {
            try {
                return (this.contextID == ((PolicyConfiguration) obj).getContextID());
            } catch (PolicyContextException pce) {
                if (logger.isLoggable(BasicLevel.ERROR)) {
                    logger.log(BasicLevel.ERROR, i18n.getMessage("JPolicyConfiguration.equals.canNotCheck", pce.getMessage()));
                }
                return false;
            }
        }
    }

     public int hashCode() {
         return contextID.hashCode();
     }


    protected void resetState() {
        this.state = OPEN;
    }



    public PermissionCollection getExcludedPermissions() {
        // Works only if state is in service
        if (state != IN_SERVICE) {
            return new Permissions();
        } else {
            return excludedPermissions;
        }
    }


    public PermissionCollection getUncheckedPermissions() {
        // Works only if state is in service
        if (state != IN_SERVICE) {
            return new Permissions();
        } else {
            return uncheckedPermissions;
        }
    }


    public PermissionCollection getPermissionsForPrincipal(Principal principal) {

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "principal = " + principal);
        }

        // Works only if state is in service and if principal is not null
        if (principal == null || state != IN_SERVICE) {
            return new Permissions();
        }

        PermissionCollection permissionsOfRole = (PermissionCollection) rolePermissions.get(principal.getName());

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Permissions found = " + permissionsOfRole);
        }

        //create permission object if no previous permission for the given role
        if (permissionsOfRole == null) {
            permissionsOfRole = new Permissions();
        }

        return permissionsOfRole;
    }

}

---