/*******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.osgi.framework.internal.core;

import java.security.*;
import java.util.*;
import org.osgi.service.condpermadmin.Condition;

/**
 * 
 * This security manager implements the ConditionalPermission processing for
 * OSGi. It is to be used with ConditionalPermissionAdmin.
 * 
 */
public class FrameworkSecurityManager extends SecurityManager {
	/* 
	 * This is super goofy, but we need to make sure that the CheckContext and
	 * CheckPermissionAction classes load early. Otherwise, we run into problems later.
	 */
	static {
		Class c;
		c = CheckPermissionAction.class;
		c = CheckContext.class;
		c.getName(); // to prevent compiler warnings
	}

	static class CheckContext {
		// A non zero depth indicates that we are doing a recursive permission check.
		ArrayList depthCondSets = new ArrayList(2);
        ArrayList accs = new ArrayList(2);
		ArrayList CondClassSet;

		public int getDepth() {
			return depthCondSets.size() - 1;
		}
	}

	/**
	 * Adds an array of Condition[] for a ProtectionDomain.
	 * 
	 * @param condSet the array of Condition[] for the ProtectionDomain.
	 * @return true if the condSet was added. false if this is a recursive check
	 *         and ConditionalPermissions cannot be used.
	 */
	boolean addConditionsForDomain(Condition condSet[][]) {
		CheckContext cc = (CheckContext) localCheckContext.get();
		if (cc == null) {
			// We are being invoked in a weird way. Perhaps the ProtectionDomain is
			// getting invoked directly.
			return false;
		}
		Vector condSets = (Vector) cc.depthCondSets.get(cc.getDepth());
		if (condSets == null) {
			condSets = new Vector(2);
			cc.depthCondSets.set(cc.getDepth(), condSets);
		}
		condSets.add(condSet);
		return true;
	}

	ThreadLocal localCheckContext = new ThreadLocal();

	static class CheckPermissionAction implements PrivilegedAction {
		Permission perm;
		Object context;
		FrameworkSecurityManager fsm;

		CheckPermissionAction(FrameworkSecurityManager fsm, Permission perm, Object context) {
			this.fsm = fsm;
			this.perm = perm;
			this.context = context;
		}

		public Object run() {
			fsm.internalCheckPermission(perm, context);
			return null;
		}
	}

	public void checkPermission(Permission perm, Object context) {
		AccessController.doPrivileged(new CheckPermissionAction(this, perm, context));
	}

	/**
     * Gets the AccessControlContext currently being evaluated by
     * the SecurityManager.
     * 
	 * @return the AccessControlContext currently being evaluated by the SecurityManager, or
     * null if no AccessControlContext is being evaluted. Note: this method will
     * return null if the permission check is being done directly on the AccessControlContext
     * rather than the SecurityManager.
	 */
	public AccessControlContext getContextToBeChecked() {
        CheckContext cc = (CheckContext) localCheckContext.get();
        if (cc != null && cc.accs != null && !cc.accs.isEmpty())
            return (AccessControlContext) cc.accs.get(cc.accs.size()-1);
        return null;
    }
    
	public void internalCheckPermission(Permission perm, Object context) {
		AccessControlContext acc = (AccessControlContext) context;
		CheckContext cc = (CheckContext) localCheckContext.get();
		if (cc == null) {
			cc = new CheckContext();
			localCheckContext.set(cc);
		}
		cc.depthCondSets.add(null); // initialize postponed condition set to null
        cc.accs.add(acc);
		try {
			acc.checkPermission(perm);
			// We want to pop the first set of postponed conditions and process them
			Vector remainingSets = (Vector) cc.depthCondSets.get(cc.getDepth());
			if (remainingSets != null) {
				/*
				 * In this bit of code we have to try every possible combination
				 * of conditional permissions that still need to be evaluated. We
				 * do this using recursion to keep track of the different
				 * combinations we have tried. The top call will setup the different
				 * combinations for the first protection domain with unevaluated 
				 * conditions. The final call will actually evaluate the condition.
				 * If a good combination is found, it will immediately bubble
				 * up.
				 */
				Hashtable condContextDict = new Hashtable(2);
				// The remainder we will process recursively.
				Condition conds[][] = (Condition[][]) remainingSets.remove(0);
				for (int i = 0; i < conds.length; i++)
					if (recursiveCheck(remainingSets, conds[i], null, condContextDict, cc))
						return; // found a pass return without SecurityException
				throw new SecurityException("Conditions not satisfied"); //$NON-NLS-1$
			}
		} finally {
			cc.depthCondSets.remove(cc.getDepth());
            cc.accs.remove(cc.accs.size()-1);
		}
	}

	/**
	 * Checks that at least one combination of the Condition[] in the Vector can
	 * be satisfied along with the passed array of Conditions.
	 * 
	 * @param remainingSets the Vector of Condition[][] to check.
	 * @param conditions the conditions that must be satisfied.
	 * @param condDict a dictionary that will be filled with the Conditions to
	 *        check.
	 * @param condContextDict a Dictionary of Dictionaries that will be passed
	 *        to Condition.isSatisfied when performing repeated check.
	 * @param cc the CheckContext
	 * @return true if a successful combination was found.
	 */
	private boolean recursiveCheck(Vector remainingSets, Condition[] conditions, Hashtable condDict, Hashtable condContextDict, CheckContext cc) {
		// clone condDict and clone each Vector in the condDict
		if (condDict == null) {
			condDict = new Hashtable(2);
		} else {
			Hashtable copyCondDict = new Hashtable(2);
			for (Enumeration keys = condDict.keys(); keys.hasMoreElements();) {
				Object key = keys.nextElement();
				copyCondDict.put(key, ((Vector) condDict.get(key)).clone());
			}
			condDict = copyCondDict;
		}
		for (int i = 0; i < conditions.length; i++) {
			if (conditions[i] == null)
				continue;
			Vector condList = (Vector) condDict.get(conditions[i].getClass());
			if (condList == null) {
				condList = new Vector();
				condDict.put(conditions[i].getClass(), condList);
			}
			condList.add(conditions[i]);
		}
		if (remainingSets.size() > 0) {
			Condition conds[][] = (Condition[][]) remainingSets.get(0);
			Vector newSets = (Vector) remainingSets.clone();
			newSets.remove(0);
			for (int i = 0; i < conds.length; i++)
				if (recursiveCheck(newSets, conds[i], condDict, condContextDict, cc))
					return true;
			return false;
		}
		Enumeration keys = condDict.keys();
		while (keys.hasMoreElements()) {
			Class key = (Class) keys.nextElement();
			Vector conds = (Vector) condDict.get(key);
			if (conds.size() == 0)
				continue; // This should never happen since we only add to the condDict if there is a condition
			Condition condArray[] = (Condition[]) conds.toArray(new Condition[conds.size()]);
			Dictionary context = (Dictionary) condContextDict.get(key);
			if (context == null) {
				context = new Hashtable(2);
				condContextDict.put(key, context);
			}
			if (cc.CondClassSet == null)
				cc.CondClassSet = new ArrayList(2);
			if (cc.CondClassSet.contains(condArray[0].getClass()))
				return false; // doing recursion into same condition class
			cc.CondClassSet.add(condArray[0].getClass());
			try {
				if (!condArray[0].isSatisfied(condArray, context))
					return false;
			} finally {
				cc.CondClassSet.remove(condArray[0].getClass());
			}
		}
		return true;
	}

	public void checkPermission(Permission perm) {
		checkPermission(perm, getSecurityContext());
	}

	public Object getSecurityContext() {
		return AccessController.getContext();
	}
}