Standard.java

package org.objectweb.jonas.security.realm.web.jetty50;

import java.security.Principal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.mortbay.http.HttpRequest;
import org.mortbay.http.UserRealm;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.security.SecurityService;
import org.objectweb.jonas.security.realm.factory.JResource;
import org.objectweb.jonas.security.realm.principals.User;
import org.objectweb.jonas.service.ServiceManager;

import org.objectweb.security.context.SecurityContext;
import org.objectweb.security.context.SecurityCurrent;

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

public class Standard implements UserRealm {

    private static Logger logger = null;

    private String name;

    private JResource jResource = null;

    private SecurityService securityService = null;

    private Map users = null;

    protected Standard() {
        users = new HashMap();

        if (logger == null) {
            logger = Log.getLogger(Log.JONAS_SECURITY_PREFIX);
        }
    }

    public Standard(String resourceName) throws Exception {
        this();

        // Get the Security Service
        try {
            securityService = (SecurityService) ServiceManager.getInstance().getSecurityService();
        } catch (Exception e) {
            // Can't retrieve Security service
            throw new Exception("can't retrieve Security service", e);
        }

        // Get the resource from the security service
        jResource = securityService.getJResource(resourceName);
        if (jResource == null) {
            throw new Exception("Can't retrieve resource " + resourceName + "from the security service");
        }
    }

    public Standard(String name, String resourceName) throws Exception {
        this(resourceName);
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public Principal authenticate(String username, Object credentials, HttpRequest request) {

        // No authentication can be made with a null username
        if (username == null) {
            return null;
        }

        Principal jettyPrincipal = (Principal) users.get(username);
        // User previously authenticated --> remove from the cache
        if (jettyPrincipal != null) {
            users.remove(username);
        }

        // Does a user with this username exist?
        User user = null;
        try {
            user = jResource.findUser(username);
        } catch (Exception jre) {
            // could not retrieve user
            logger.log(BasicLevel.INFO, jre.getMessage());
            return null;
        }

        // User was not found
        if (user == null) {
            logger.log(BasicLevel.DEBUG, "User " + username + " not found.");
            return null;
        }

        if (!(credentials instanceof String)) {
            logger.log(BasicLevel.ERROR, "Allow only string type as credentials");
            return null;
        }

        boolean validated = jResource.isValidUser(user, (String) credentials);

        if (!validated) {
            logger.log(BasicLevel.INFO, "The password for the user " + username + " is not valid");
            return null;
        }

        ArrayList combinedRoles = null;
        try {
            combinedRoles = jResource.getArrayListCombinedRoles(user);
        } catch (Exception jre) {
            logger.log(BasicLevel.ERROR, jre.getMessage());
            return null;
        }

        Principal principal = new JettyPrincipal(user.getName(), combinedRoles);
        SecurityContext ctx = new SecurityContext(principal.getName(), combinedRoles);
        SecurityCurrent current = SecurityCurrent.getCurrent();
        current.setSecurityContext(ctx);

        // Add to cache
        users.put(username, principal);

        return principal;
    }

    public synchronized boolean isUserInRole(Principal user, String roleName) {
        if (user == null) {
            return false;
        }

        if (user instanceof JettyPrincipal) {
            return ((JettyPrincipal) user).isUserInRole(roleName);
        } else {
            logger.log(BasicLevel.ERROR, "The user '" + user + "' is not instance of JettyPrincipal");
            return false;
        }
    }

    public boolean isAuthenticated(Principal user) {
        if (user == null) {
            return false;
        }

        if (user instanceof JettyPrincipal) {
            return ((JettyPrincipal) user).isAuthenticated();
        } else {
            logger.log(BasicLevel.ERROR, "The user '" + user + "' is not instance of JettyPrincipal");
            return false;
        }
    }

    public Principal getPrincipal(String username) {
        logger.log(BasicLevel.DEBUG, "Get principal with username '" + username + "'.");

        JettyPrincipal principal = (JettyPrincipal) users.get(username);
        SecurityContext ctx = new SecurityContext(principal.getName(), principal.getRoles());
        SecurityCurrent current = SecurityCurrent.getCurrent();
        current.setSecurityContext(ctx);
        return principal;
    }

    public void disassociate(Principal user) {
    }

    public Principal pushRole(Principal user, String role) {
        return user;
    }

    public Principal popRole(Principal user) {
        return user;
    }

    public void logout(Principal user) {
    }

    public boolean reauthenticate(Principal user) {
        if (user instanceof JettyPrincipal) {
            return ((JettyPrincipal) user).isAuthenticated();
        } else {
            return false;
        }
    }

    protected static Logger getLogger() {
        return logger;
    }

    protected Map getUsers() {
        return users;
    }

    protected void removeUser(String username) {
        users.remove(username);
    }

    protected void addUser(String username, Principal principal) {
        users.put(username, principal);
    }

    protected void setName(String name) {
        this.name = name;
    }
}

---