/*
* JFolder, Copyright 2001-2006 Gary Steinmetz
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jfolder.security.lifecycle;
//base classes
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
//project specific classes
import org.jfolder.common.UnexpectedSystemException;
import org.jfolder.common.entity.properties.SimpleSystemEntityProperties;
import org.jfolder.common.entity.properties.SystemEntityProperties;
import org.jfolder.common.utils.web.ParameterSet;
import org.jfolder.common.utils.xml.LinearXPath;
import org.jfolder.common.web.template.ConsoleTemplateContext;
import org.jfolder.common.web.template.SubmitActionContext;
import org.jfolder.config.instance.ConfigInstance;
import org.jfolder.config.instance.ConfigInstanceConfig;
import org.jfolder.config.instance.ConfigInstanceTagHelper;
import org.jfolder.platforms.stores.base.SystemStoreSession;
import org.jfolder.platforms.stores.base.SystemStoreSessionManager;
import org.jfolder.security.model.GroupHolder;
import org.jfolder.security.model.SimpleGroupHolder;
import org.jfolder.security.model.SimpleUserHolder;
import org.jfolder.security.model.SimpleUserIdentity;
import org.jfolder.security.model.SystemGroups;
import org.jfolder.security.model.UserHolder;
import org.jfolder.security.model.UserHolderContext;
import org.jfolder.security.model.UserIdentity;
import org.jfolder.services.config.ConfigService;
import org.jfolder.services.config.ConfigServiceCaller;
import org.jfolder.services.config.ConfigServiceCallerFactory;
//other classes
public class GenericConfigLifecycleSecurityLifecycle
implements SecurityLifecycle {
public final static String DEFAULT_CONFIG =
ConfigInstanceTagHelper.DEFAULT_CONFIG;
//private final static String USER_BASE = "";
private final static LinearXPath XPATH_GENERIC = LinearXPath.r("generic");
private static HashMap cachedGroupsInGroups = null;
private static long cachedGroupsInGroupsTime = 0;
private static HashMap cachedUsersInGroups = null;
private static long cachedUsersInGroupsTime = 0;
//
private static HashMap cachedUsers = null;
private static long cachedUsersTime = 0;
protected GenericConfigLifecycleSecurityLifecycle() {
}
public String getSecurityType() {
return DEFAULT_CONFIG;
}
public GroupHolder getSystemGroup(String inGroup) {
SimpleGroupHolder outValue = null;
if (inGroup.equals(SystemGroups.DEVELOPERS)) {
outValue = SimpleGroupHolder.newInstance(
SystemGroups.DEVELOPERS, DEFAULT_CONFIG);
//outValue = SimpleGroupHolder.newInstance(SystemGroups.DEVELOPERS);
//outValue.setSecurityClass(this.getClass().getName());
}
else if (inGroup.equals(SystemGroups.ADMINISTRATORS)) {
outValue = SimpleGroupHolder.newInstance(
SystemGroups.ADMINISTRATORS, DEFAULT_CONFIG);
//outValue = new GenericGroupHolder(SystemGroups.ADMINISTRATORS);
//outValue.setSecurityClass(this.getClass().getName());
}
else {
throw new UnexpectedSystemException(
"Not implemented for group '" + inGroup + "'");
}
return outValue;
}
public ConsoleTemplateContext getFailedLoginPage(
HttpServletRequest inRequest, ParameterSet inPs,
SubmitActionContext inSac, UserHolder inUser) {
return new GenericConfigFailedLoginPageContext(inUser);
}
public UserHolder getUser(UserHolderContext inContext) {
UserHolder outValue = null;
//UserIdentity ui = null;
//SystemEntityProperties sep = null;
if (inContext.isNamePresent()) {
if (!inContext.isSecurityClassPresent()) {
//
UserIdentity ui = SimpleUserIdentity.newInstance(
inContext.getName(), DEFAULT_CONFIG, true, false);
SimpleSystemEntityProperties ssep =
SimpleSystemEntityProperties.newInstance();
outValue = SimpleUserHolder.newInstance(ui, ssep);
}
else {
//
UserIdentity ui = SimpleUserIdentity.newInstance(
inContext.getName(), DEFAULT_CONFIG, false, false);
SimpleSystemEntityProperties ssep =
SimpleSystemEntityProperties.newInstance();
outValue = SimpleUserHolder.newInstance(ui, ssep);
}
}
else {
//
String userName = null;
String password = null;
//
//HttpServletRequest request = null;
SystemStoreSession requestSss = null;
if (inContext.isRequestPresent()) {
HttpServletRequest r = inContext.getRequest();
requestSss = SystemStoreSessionManager.getSystemStoreSession(r);
}
//
if (inContext.isParameterSetPresent()
&& inContext.getParameterSet().isParameterPresent(
SecurityLifecycleHelper.USERNAME)
&& inContext.getParameterSet().isParameterString(
SecurityLifecycleHelper.USERNAME)
&& inContext.getParameterSet().isParameterPresent(
SecurityLifecycleHelper.PASSWORD)
&& inContext.getParameterSet().isParameterString(
SecurityLifecycleHelper.PASSWORD)) {
ParameterSet ps = inContext.getParameterSet();
userName = ps.getParameter(SecurityLifecycleHelper.USERNAME);
password = ps.getParameter(SecurityLifecycleHelper.PASSWORD);
}
else if (requestSss != null && requestSss.isUserHolderPresent()) {
outValue = requestSss.getUserHolder();
}
else {
UserIdentity ui = SimpleUserIdentity.newInstance(
null, DEFAULT_CONFIG, true, true);
SimpleSystemEntityProperties ssep =
SimpleSystemEntityProperties.newInstance();
outValue = SimpleUserHolder.newInstance(ui, ssep);
}
if (userName != null && password != null) {
//MiscHelper.println("userName = " + userName);
//MiscHelper.println("password = " + password);
HashMap users = getCachedUsers();
if (users.containsKey(userName)) {
String correctPassword = (String)users.get(userName);
if (password.equals(correctPassword)) {
UserIdentity ui = SimpleUserIdentity.newInstance(
userName, DEFAULT_CONFIG, true, false);
SimpleSystemEntityProperties ssep =
SimpleSystemEntityProperties.newInstance();
outValue = SimpleUserHolder.newInstance(ui, ssep);
//outValue = new GenericUserHolder();
//outValue.setName(userName);
//outValue.setSecurityClass(this.getClass().getName());
}
}
if (outValue == null) {
UserIdentity ui = SimpleUserIdentity.newInstance(
userName, DEFAULT_CONFIG, false, false);
SimpleSystemEntityProperties ssep =
SimpleSystemEntityProperties.newInstance();
outValue = SimpleUserHolder.newInstance(ui, ssep);
//outValue = new GenericUserHolder();
//outValue.setValid(false);
//outValue.setName(userName);
//outValue.setSecurityClass(this.getClass().getName());
}
if (requestSss != null) {
requestSss.setUserHolder(outValue);
}
}
//MiscHelper.println("GenConfigManUaaac outValue = " + outValue);
}
//outValue = SimpleUserHolder.newInstance(ui, sep);
return outValue;
}
private synchronized final static HashMap getCachedUsers() {
HashMap outValue = null;
if (cachedUsers != null) {
long delta = System.currentTimeMillis() - cachedUsersTime;
if (delta > (1000*60*5)) {
outValue = getConfigManagerUsers();
cachedUsers = outValue;
cachedUsersTime = System.currentTimeMillis();
}
else {
outValue = cachedUsers;
}
}
else {
outValue = getConfigManagerUsers();
cachedUsers = outValue;
cachedUsersTime = System.currentTimeMillis();
}
return outValue;
}
private final static HashMap getConfigManagerUsers() {
HashMap outValue = null;
outValue = new HashMap();
ConfigService cs = ConfigServiceCallerFactory.getConfigService();
//ConfigLifecycle cm = ConfigLifecycleFactory.getConfigLifecycle();
ConfigInstanceConfig cic = cs.accessConfig(ConfigInstance.SECURITY);
int userCount = cic.getPropertyCount(
ConfigInstance.CUSTOM_CONTENT, XPATH_GENERIC, "user", 0);
//MiscHelper.println("userCount = " + userCount);
for (int i = 0; i < userCount; i++) {
LinearXPath nextBase = XPATH_GENERIC.b("user", (i + 1));
String nextUsername = cic.getPropertyAttribute(
ConfigInstance.CUSTOM_CONTENT, nextBase, "username", null);
String nextPassword = cic.getPropertyAttribute(
ConfigInstance.CUSTOM_CONTENT, nextBase, "password", null);
//MiscHelper.println("nextUsername = " + nextUsername);
//MiscHelper.println("nextPassword = " + nextPassword);
//username is case-insentitive,
//password is case-sensitive
outValue.put(nextUsername, nextPassword);
}
//cm.close();
return outValue;
}
public boolean isUserInGroup(UserHolder inUser, GroupHolder inGroup) {
boolean outValue = false;
//String className = this.getClass().getName();
//MiscHelper.println("inUser = " + inUser);
//MiscHelper.println("inGroup = " + inGroup);
//MiscHelper.println("inUser.isValid() = " + inUser.isValid());
//MiscHelper.println("inUser.getSecurityClass() = "
// + inUser.getSecurityClass());
//MiscHelper.println("inGroup.getSecurityClass() = "
// + inGroup.getSecurityClass());
//try {
// Thread.sleep(15000);
//}
//catch (Exception e) {
//}
if (inUser.getUserIdentity().isValid()
&& !inUser.getUserIdentity().isAnonymous()
&& inUser.getUserIdentity().getSecurityType().equals(DEFAULT_CONFIG)
&& inGroup.getSecurityType().equals(DEFAULT_CONFIG)) {
ConfigService cs = ConfigServiceCallerFactory.getConfigService();
//ConfigLifecycle cm = ConfigLifecycleFactory.getConfigLifecycle();
ConfigInstanceConfig cic = cs.accessConfig(ConfigInstance.SECURITY);
//Iterator iter = null;
HashMap groupsInGroups = null;
HashMap usersInGroups = null;
//synchronized(GenericConfigManagerUaaac.class) {
groupsInGroups = getCachedGroups(cic);
//MiscHelper.println("groupsInGroups = "
//+ groupsInGroups.size());
//iter = groupsInGroups.keySet().iterator();
//while (iter.hasNext()) {
// MiscHelper.println("nextGroupInGroup = " + iter.next());
//}
usersInGroups = getCachedUsers(cic);
//}
//MiscHelper.println("usersInGroups = " + usersInGroups.size());
//iter = usersInGroups.keySet().iterator();
//while (iter.hasNext()) {
// MiscHelper.println("nextUserInGroup = " + iter.next());
//}
ArrayList groupsAvailable = new ArrayList();
Iterator iter = groupsInGroups.keySet().iterator();
while (iter.hasNext()) {
groupsAvailable.add(iter.next().toString().toUpperCase());
}
outValue = isUserInGroup(inUser, inGroup,
groupsInGroups, usersInGroups, groupsAvailable);
//MiscHelper.println("outValue = " + outValue);
//cm.close();
}
return outValue;
}
private final static synchronized HashMap getCachedUsers(
ConfigInstanceConfig inCic) {
HashMap outValue = null;
if (cachedUsersInGroups != null) {
long delta = System.currentTimeMillis() - cachedUsersInGroupsTime;
if (delta > (1000*60*10)) {
outValue = getEntitiesInGroups(inCic, "user");
cachedUsersInGroups = outValue;
cachedUsersInGroupsTime = System.currentTimeMillis();
}
else {
outValue = cachedUsersInGroups;
}
}
else {
outValue = getEntitiesInGroups(inCic, "user");
cachedUsersInGroups = outValue;
cachedUsersInGroupsTime = System.currentTimeMillis();
}
return outValue;
}
private final static synchronized HashMap getCachedGroups(
ConfigInstanceConfig inCic) {
HashMap outValue = null;
if (cachedGroupsInGroups != null) {
long delta = System.currentTimeMillis() - cachedGroupsInGroupsTime;
if (delta > (1000*60*10)) {
outValue = getEntitiesInGroups(inCic, "group");
cachedGroupsInGroups = outValue;
cachedGroupsInGroupsTime = System.currentTimeMillis();
}
else {
outValue = cachedGroupsInGroups;
}
}
else {
outValue = getEntitiesInGroups(inCic, "group");
cachedGroupsInGroups = outValue;
cachedGroupsInGroupsTime = System.currentTimeMillis();
}
return outValue;
}
private boolean isUserInGroup(UserHolder inUser, GroupHolder inGroup,
HashMap inGroupsInGroups, HashMap inUsersInGroups,
Collection inGroupsAvailable) {
boolean outValue = false;
//MiscHelper.println("isUserInGroup::inUser = " + inUser);
//MiscHelper.println("isUserInGroup::inGroup = " + inGroup);
//MiscHelper.println("isUserInGroup::inGroupsInGroups = "
// + inGroupsInGroups);
//MiscHelper.println("isUserInGroup::inUsersInGroups = "
// + inUsersInGroups);
//MiscHelper.println("isUserInGroup::inGroupsAvailable = "
// + inGroupsAvailable);
if (inGroupsAvailable.contains(inGroup.getName().toUpperCase())) {
//int groupIndex = inGroupsAvailable.indexOf(inGroup);
//MiscHelper.println("GroupFound");
inGroupsAvailable.remove(inGroup);
Iterator users = ((HashSet)inUsersInGroups.get(
inGroup.getName().toUpperCase())).iterator();
while (users.hasNext()) {
String nextUser = (String)users.next();
//MiscHelper.println("nextUser = " + nextUser);
//MiscHelper.println("inUser.getName() = " + inUser.getName());
if (nextUser.equalsIgnoreCase(
inUser.getUserIdentity().getName())) {
//
outValue = true;
break;
}
}
if (!outValue) {
//MiscHelper.println("inGroup = " + inGroup);
//MiscHelper.println(inGroupsInGroups.toString());
//MiscHelper.println("inGroup.toUpperCase() = "
// + inGroup.toUpperCase());
//MiscHelper.println(
// "inGroupsInGroups.get(inGroup.toUpperCase()) = "
// + inGroupsInGroups.get(inGroup.toUpperCase()));
//Iterator iter = inGroupsInGroups.keySet().iterator();
//while (iter.hasNext()) {
// MiscHelper.println("key = '" + iter.next() + "'");
//}
Iterator groups =
((HashSet)inGroupsInGroups.get(
inGroup.getName().toUpperCase())).iterator();
while (groups.hasNext()) {
String nextGroup = (String)groups.next();
outValue = isUserInGroup(inUser,
SimpleGroupHolder.newInstance(
nextGroup, DEFAULT_CONFIG),
//new GenericGroupHolder(nextGroup),
inGroupsInGroups, inUsersInGroups, inGroupsAvailable);
if (outValue) {
break;
}
}
}
}
return outValue;
}
private final static HashMap getEntitiesInGroups(ConfigInstanceConfig inCic,
String inEntity) {
HashMap outValue = new HashMap();
int groupCount = inCic.getPropertyCount(
ConfigInstance.CUSTOM_CONTENT, XPATH_GENERIC, "group", 0);
for (int i = 0; i < groupCount; i++) {
LinearXPath nextGroupPath = XPATH_GENERIC.b("group", (i + 1));
String nextGroupName = inCic.getPropertyAttribute(
ConfigInstance.CUSTOM_CONTENT, nextGroupPath, "name", null);
// inCm.getPropertyAttribute(nextGroupPath, "name", null);
HashSet nextGroup = new HashSet();
if (nextGroupName != null) {
outValue.put(nextGroupName.toUpperCase(), nextGroup);
}
else {
continue;
}
int subCount = inCic.getPropertyCount(
ConfigInstance.CUSTOM_CONTENT, nextGroupPath, inEntity, 0);
for (int j = 0; j < subCount; j++) {
LinearXPath nextSubPath = nextGroupPath.b(inEntity, (j + 1));
String subId = inCic.getPropertyAttribute(
ConfigInstance.CUSTOM_CONTENT, nextSubPath, "name", null);
// inCm.getPropertyAttribute(nextSubPath, "name", null);
if (subId != null) {
nextGroup.add(subId.toUpperCase());
}
}
}
return outValue;
}
}
|