Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2008, 2009 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.internal.permadmin;
 
 import java.util.*;
 
 public final class SecurityRow implements ConditionalPermissionInfo {
 	/* Used to find condition constructors getConditions */
 	static final Class[] conditionMethodArgs = new Class[] {Bundle.classConditionInfo.class};
 	static Condition[] ABSTAIN_LIST = new Condition[0];
 	static Condition[] SATISFIED_LIST = new Condition[0];
 	static final Decision DECISION_ABSTAIN = new Decision(.nullnullnull);
 	static final Decision DECISION_GRANTED = new Decision(.nullnullnull);
 	static final Decision DECISION_DENIED = new Decision(.nullnullnull);
 
 	private final SecurityAdmin securityAdmin;
 	private final String name;
 	private final ConditionInfo[] conditionInfos;
 	private final boolean deny;
 	/* GuardedBy(bundleConditions) */
 
 	public SecurityRow(SecurityAdmin securityAdminString nameConditionInfo[] conditionInfosPermissionInfo[] permissionInfosString decision) {
 		if (permissionInfos == null || permissionInfos.length == 0)
 			throw new IllegalArgumentException("It is invalid to have empty permissionInfos"); //$NON-NLS-1$
 		this. = securityAdmin;
 		this. = conditionInfos == null ? new ConditionInfo[0] : conditionInfos;
 		decision = decision.toLowerCase();
 		boolean d = ..equals(decision);
 		boolean a = ..equals(decision);
 		if (!(d | a))
 			throw new IllegalArgumentException("Invalid decision: " + decision); //$NON-NLS-1$
 		this. = d;
 		this. = name;
 		this. = new PermissionInfoCollection(permissionInfos);
 		if (conditionInfos == null || conditionInfos.length == 0)
 			 = null;
 		else
 	}
 
 	}
 
 	static SecurityRow createSecurityRow(SecurityAdmin securityAdminString encoded) {
 		return (SecurityRowcreateConditionalPermissionInfo(securityAdminencoded);
 	}
 
 	private static ConditionalPermissionInfo createConditionalPermissionInfo(SecurityAdmin securityAdminString encoded) {
 		encoded = encoded.trim();
 		if (encoded.length() == 0)
 			throw new IllegalArgumentException("Empty encoded string is invalid"); //$NON-NLS-1$
 		char[] chars = encoded.toCharArray();
 		int end = encoded.length() - 1;
 		char lastChar = chars[end];
 		if (lastChar != '}' && lastChar != '"')
 			throw new IllegalArgumentException(encoded);
 		String encodedName = null;
 		if (lastChar == '"') {
 			// we have a name: an empty name must have at least 2 chars for the quotes
 			if (chars.length < 2)
 				throw new IllegalArgumentException(encoded);
 			int endName = encoded.length() - 1;
 			int startName = endName - 1;
 			while (startName > 0) {
 				if (chars[startName] == '"') {
 					startName--;
 					if (startName > 0 && chars[startName] == '\\')
 						startName--;
 					else {
 						startName++;
 						break;
 					}
 				}
 				startName--;
 			}
 			if (chars[startName] != '"')
 				throw new IllegalArgumentException(encoded);
 			encodedName = unescapeString(encoded.substring(startName + 1, endName));
 			end = encoded.lastIndexOf('}'startName);
 		}
 		int start = encoded.indexOf('{');
 		if (start < 0 || end < start)
 			throw new IllegalArgumentException(encoded);
		String decision = encoded.substring(0, start);
		decision = decision.trim();
			throw new IllegalArgumentException(encoded);
		ArrayList condList = new ArrayList();
		ArrayList permList = new ArrayList();
		int pos = start + 1;
		while (pos < end) {
			while (pos < end && chars[pos] != '[' && chars[pos] != '(')
				pos++;
			if (pos == end)
				break// no perms or conds left
			int startPos = pos;
			char endChar = chars[startPos] == '[' ? ']' : ')';
			while (pos < end && chars[pos] != endChar) {
				if (chars[pos] == '"') {
					pos++;
					while (chars[pos] != '"') {
						if (chars[pos] == '\\')
							pos++;
						pos++;
					}
				}
				pos++;
			}
			int endPos = pos;
			String token = new String(charsstartPosendPos - startPos + 1);
			if (endChar == ']')
				condList.add(new ConditionInfo(token));
			else
				permList.add(new PermissionInfo(token));
			pos++;
		}
		if (permList.size() == 0)
			throw new IllegalArgumentException("No Permission infos: " + encoded); //$NON-NLS-1$
		ConditionInfo[] conds = (ConditionInfo[]) condList.toArray(new ConditionInfo[condList.size()]);
		PermissionInfo[] perms = (PermissionInfo[]) permList.toArray(new PermissionInfo[permList.size()]);
		if (securityAdmin == null)
			return new SecurityRowSnapShot(encodedNamecondspermsdecision);
		return new SecurityRow(securityAdminencodedNamecondspermsdecision);
	}
	static Object cloneArray(Object[] array) {
		if (array == null)
			return null;
		Object result = Array.newInstance(array.getClass().getComponentType(), array.length);
		System.arraycopy(array, 0, result, 0, array.length);
		return result;
	}
	private static void escapeString(String strStringBuffer output) {
		int len = str.length();
		for (int i = 0; i < leni++) {
			char c = str.charAt(i);
			switch (c) {
				case '"' :
				case '\\' :
					output.append('\\');
					output.append(c);
					break;
				case '\r' :
					output.append("\\r"); //$NON-NLS-1$
					break;
				case '\n' :
					output.append("\\n"); //$NON-NLS-1$
					break;
				default :
					output.append(c);
					break;
			}
		}
	}
	private static String unescapeString(String str) {
		StringBuffer output = new StringBuffer(str.length());
		int end = str.length();
		for (int i = 0; i < endi++) {
			char c = str.charAt(i);
			if (c == '\\') {
				i++;
				if (i < end) {
					c = str.charAt(i);
					switch (c) {
						case '"' :
						case '\\' :
							break;
						case 'r' :
							c = '\r';
							break;
						case 'n' :
							c = '\n';
							break;
						default :
							c = '\\';
							i--;
							break;
					}
				}
			}
			output.append(c);
		}
		return output.toString();
	}
	public String getName() {
		return ;
	}
		// must make a copy for the public API method to prevent modification
	}
	}
	}
		// must make a copy for the public API method to prevent modification
	}
	}

Deprecated:
	public void delete() {
		.delete(thistrue);
	}
		Condition[] conditions = new Condition[.];
		for (int i = 0; i < .i++) {
			/*
			 * TODO: Can we pre-get the Constructors in our own constructor
			 */
			Class clazz;
			try {
				clazz = Class.forName([i].getType());
catch (ClassNotFoundException e) {
				/* If the class isn't there, we fail */
				return null;
			}
			Constructor constructor = null;
			Method method = null;
			try {
				method = clazz.getMethod("getCondition"); //$NON-NLS-1$
				if ((method.getModifiers() & .) == 0)
					method = null;
catch (NoSuchMethodException e) {
				// This is a normal case
			}
			if (method == null)
				try {
					constructor = clazz.getConstructor();
catch (NoSuchMethodException e) {
					// TODO should post a FrameworkEvent of type error here
					conditions[i] = .;
					continue;
				}
			Object args[] = {bundle[i]};
			try {
				if (method != null)
					conditions[i] = (Conditionmethod.invoke(nullargs);
				else
					conditions[i] = (Conditionconstructor.newInstance(args);
catch (Throwable t) {
				// TODO should post a FrameworkEvent of type error here
				conditions[i] = .;
			}
		}
		return conditions;
	}
	Decision evaluate(BundlePermissions bundlePermissionsPermission permission) {
		if ( == null || bundlePermissions == null)
			return evaluatePermission(permission);
		Condition[] conditions;
		synchronized () {
			conditions = (Condition[]) .get(bundlePermissions);
			if (conditions == null) {
				conditions = getConditions(bundlePermissions.getBundle());
				.put(bundlePermissionsconditions);
			}
		}
		if (conditions == )
		if (conditions == )
			return evaluatePermission(permission);
		boolean empty = true;
		List postponedConditions = null;
		Decision postponedPermCheck = null;
		for (int i = 0; i < conditions.lengthi++) {
			Condition condition = conditions[i];
			if (condition == null)
				continue// this condition must have been satisfied && !mutable in a previous check
			if (!isPostponed(condition)) {
				// must call isMutable before calling isSatisfied according to the specification.
				boolean mutable = condition.isMutable();
				if (condition.isSatisfied()) {
					if (!mutable)
						conditions[i] = null// ignore this condition for future checks
else {
					if (!mutable)
						// this will cause the row to always abstain; mark this to be ignored in future checks
						synchronized () {
							.put(bundlePermissions);
						}
				}
else { // postponed case
				if (postponedPermCheck == null)
					// perform a permission check now
					postponedPermCheck = evaluatePermission(permission);
				if (postponedPermCheck == )
					return postponedPermCheck// no need to postpone the condition if the row abstains
				// this row will deny or allow the permission; must queue the postponed condition
				if (postponedConditions == null)
					postponedConditions = new ArrayList(1);
				postponedConditions.add(condition);
			}
			empty &= conditions[i] == null;
		}
		if (empty) {
			synchronized () {
				.put(bundlePermissions);
			}
		}
		if (postponedPermCheck != null)
			return new Decision(postponedPermCheck.decision | ., (Condition[]) postponedConditions.toArray(new Condition[postponedConditions.size()]), thisbundlePermissions);
		return evaluatePermission(permission);
	}
	private boolean isPostponed(Condition condition) {
		// postponed checks can only happen if we are using a supported security manager
		return condition.isPostponed() && .getSupportedSecurityManager() != null;
	}
	private Decision evaluatePermission(Permission permission) {
	}
	public String toString() {
		return getEncoded();
	}
	public String getEncoded() {
	}
	public boolean equals(Object obj) {
		// doing the simple (slow) thing for now
		if (obj == this)
			return true;
		if (!(obj instanceof ConditionalPermissionInfo))
			return false;
		// we assume the encoded string provides a canonical (comparable) form
	}
	public int hashCode() {
	}
	static int getHashCode(String nameConditionInfo[] condsPermissionInfo[] permsString decision) {
		int h = 31 * 17 + decision.hashCode();
		for (int i = 0; i < conds.lengthi++)
			h = 31 * h + conds[i].hashCode();
		for (int i = 0; i < perms.lengthi++)
			h = 31 * h + perms[i].hashCode();
		if (name != null)
			h = 31 * h + name.hashCode();
		return h;
	}
	static String getEncoded(String nameConditionInfo[] conditionInfosPermissionInfo[] permissionInfosboolean deny) {
		StringBuffer result = new StringBuffer();
		if (deny)
		else
		result.append(" { "); //$NON-NLS-1$
		if (conditionInfos != null)
			for (int i = 0; i < conditionInfos.lengthi++)
				result.append(conditionInfos[i].getEncoded()).append(' ');
		if (permissionInfos != null)
			for (int i = 0; i < permissionInfos.lengthi++)
				result.append(permissionInfos[i].getEncoded()).append(' ');
		result.append('}');
		if (name != null) {
			result.append(" \""); //$NON-NLS-1$
			escapeString(nameresult);
			result.append('"');
		}
		return result.toString();
	}
	}
	void clearCaches() {
		if ( != null)
			synchronized () {
			}
	}
	static class Decision {
		final int decision;
		private final SecurityRow row;
		Decision(int decisionCondition[] postponedSecurityRow rowBundlePermissions bundlePermissions) {
			this. = decision;
			this. = postponed;
			this. = row;
			this. = bundlePermissions;
		}
		void handleImmutable(Condition conditionboolean isSatisfiedboolean mutable) {
			if (mutable || !condition.isPostponed())
				return// do nothing
			if (isSatisfied) {
				synchronized (.) {
					boolean isEmpty = true;
					for (int i = 0; i < rowConditions.lengthi++) {
						if (rowConditions[i] == condition)
							if (isSatisfied)
								rowConditions[i] = null;
						isEmpty &= rowConditions[i] == null;
					}
					if (isEmpty)
				}
else {
				synchronized (.) {
				}
			}
		}
	}
New to GrepCode? Check out our FAQ X