| /* |
| * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.smartcardio; |
| |
| import java.io.*; |
| |
| import java.security.Permission; |
| |
| /** |
| * A permission for Smart Card operations. A CardPermission consists of the |
| * name of the card terminal the permission applies to and a set of actions |
| * that are valid for that terminal. |
| * |
| * <p>A CardPermission with a name of <code>*</code> applies to all |
| * card terminals. The actions string is a comma separated list of the actions |
| * listed below, or <code>*</code> to signify "all actions." |
| * |
| * <p>Individual actions are: |
| * <dl> |
| * <dt>connect |
| * <dd>connect to a card using |
| * {@linkplain CardTerminal#connect CardTerminal.connect()} |
| * |
| * <dt>reset |
| * <dd>reset the card using {@linkplain Card#disconnect Card.disconnect(true)} |
| * |
| * <dt>exclusive |
| * <dd>establish exclusive access to a card using |
| * {@linkplain Card#beginExclusive} and {@linkplain Card#endExclusive |
| * endExclusive()} |
| * |
| * <dt>transmitControl |
| * <dd>transmit a control command using |
| * {@linkplain Card#transmitControlCommand Card.transmitControlCommand()} |
| * |
| * <dt>getBasicChannel |
| * <dd>obtain the basic logical channel using |
| * {@linkplain Card#getBasicChannel} |
| * |
| * <dt>openLogicalChannel |
| * <dd>open a new logical channel using |
| * {@linkplain Card#openLogicalChannel} |
| * |
| * </dl> |
| * |
| * @since 1.6 |
| * @author Andreas Sterbenz |
| * @author JSR 268 Expert Group |
| */ |
| public class CardPermission extends Permission { |
| |
| private static final long serialVersionUID = 7146787880530705613L; |
| |
| private final static int A_CONNECT = 0x01; |
| private final static int A_EXCLUSIVE = 0x02; |
| private final static int A_GET_BASIC_CHANNEL = 0x04; |
| private final static int A_OPEN_LOGICAL_CHANNEL = 0x08; |
| private final static int A_RESET = 0x10; |
| private final static int A_TRANSMIT_CONTROL = 0x20; |
| |
| // sum of all the actions above |
| private final static int A_ALL = 0x3f; |
| |
| private final static int[] ARRAY_MASKS = { |
| A_ALL, |
| A_CONNECT, |
| A_EXCLUSIVE, |
| A_GET_BASIC_CHANNEL, |
| A_OPEN_LOGICAL_CHANNEL, |
| A_RESET, |
| A_TRANSMIT_CONTROL, |
| }; |
| |
| private final static String S_CONNECT = "connect"; |
| private final static String S_EXCLUSIVE = "exclusive"; |
| private final static String S_GET_BASIC_CHANNEL = "getBasicChannel"; |
| private final static String S_OPEN_LOGICAL_CHANNEL = "openLogicalChannel"; |
| private final static String S_RESET = "reset"; |
| private final static String S_TRANSMIT_CONTROL = "transmitControl"; |
| |
| private final static String S_ALL = "*"; |
| |
| private final static String[] ARRAY_STRINGS = { |
| S_ALL, |
| S_CONNECT, |
| S_EXCLUSIVE, |
| S_GET_BASIC_CHANNEL, |
| S_OPEN_LOGICAL_CHANNEL, |
| S_RESET, |
| S_TRANSMIT_CONTROL, |
| }; |
| |
| private transient int mask; |
| |
| /** |
| * @serial |
| */ |
| private volatile String actions; |
| |
| /** |
| * Constructs a new CardPermission with the specified actions. |
| * <code>terminalName</code> is the name of a CardTerminal or <code>*</code> |
| * if this permission applies to all terminals. <code>actions</code> |
| * contains a comma-separated list of the individual actions |
| * or <code>*</code> to signify all actions. For more information, |
| * see the documentation at the top of this {@linkplain CardPermission |
| * class}. |
| * |
| * @param terminalName the name of the card terminal, or <code>*</code> |
| * @param actions the action string (or null if the set of permitted |
| * actions is empty) |
| * |
| * @throws NullPointerException if terminalName is null |
| * @throws IllegalArgumentException if actions is an invalid actions |
| * specification |
| */ |
| public CardPermission(String terminalName, String actions) { |
| super(terminalName); |
| if (terminalName == null) { |
| throw new NullPointerException(); |
| } |
| mask = getMask(actions); |
| } |
| |
| private static int getMask(String actions) { |
| if ((actions == null) || (actions.length() == 0)) { |
| throw new IllegalArgumentException("actions must not be empty"); |
| } |
| |
| // try exact matches for simple actions first |
| for (int i = 0; i < ARRAY_STRINGS.length; i++) { |
| if (actions == ARRAY_STRINGS[i]) { |
| return ARRAY_MASKS[i]; |
| } |
| } |
| |
| if (actions.endsWith(",")) { |
| throw new IllegalArgumentException("Invalid actions: '" + actions + "'"); |
| } |
| int mask = 0; |
| String[] split = actions.split(","); |
| outer: |
| for (String s : split) { |
| for (int i = 0; i < ARRAY_STRINGS.length; i++) { |
| if (ARRAY_STRINGS[i].equalsIgnoreCase(s)) { |
| mask |= ARRAY_MASKS[i]; |
| continue outer; |
| } |
| } |
| throw new IllegalArgumentException("Invalid action: '" + s + "'"); |
| } |
| |
| return mask; |
| } |
| |
| private static String getActions(int mask) { |
| if (mask == A_ALL) { |
| return S_ALL; |
| } |
| boolean first = true; |
| StringBuilder sb = new StringBuilder(); |
| for (int i = 0; i < ARRAY_MASKS.length; i++) { |
| int action = ARRAY_MASKS[i]; |
| if ((mask & action) == action) { |
| if (first == false) { |
| sb.append(","); |
| } else { |
| first = false; |
| } |
| sb.append(ARRAY_STRINGS[i]); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| |
| /** |
| * Returns the canonical string representation of the actions. |
| * It is <code>*</code> to signify all actions defined by this class or |
| * the string concatenation of the comma-separated, |
| * lexicographically sorted list of individual actions. |
| * |
| * @return the canonical string representation of the actions. |
| */ |
| public String getActions() { |
| if (actions == null) { |
| actions = getActions(mask); |
| } |
| return actions; |
| } |
| |
| /** |
| * Checks if this CardPermission object implies the specified permission. |
| * That is the case, if and only if |
| * <ul> |
| * <li><p><code>permission</code> is an instance of CardPermission,</p> |
| * <li><p><code>permission</code>'s actions are a proper subset of this |
| * object's actions, and</p> |
| * <li><p>this object's <code>getName()</code> method is either |
| * <code>*</code> or equal to <code>permission</code>'s <code>name</code>. |
| * </p> |
| * </ul> |
| * |
| * @param permission the permission to check against |
| * @return true if and only if this CardPermission object implies the |
| * specified permission. |
| */ |
| public boolean implies(Permission permission) { |
| if (permission instanceof CardPermission == false) { |
| return false; |
| } |
| CardPermission other = (CardPermission)permission; |
| if ((this.mask & other.mask) != other.mask) { |
| return false; |
| } |
| String thisName = getName(); |
| if (thisName.equals("*")) { |
| return true; |
| } |
| if (thisName.equals(other.getName())) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Compares the specified object with this CardPermission for equality. |
| * This CardPermission is equal to another Object <code>object</code>, if |
| * and only if |
| * <ul> |
| * <li><p><code>object</code> is an instance of CardPermission,</p> |
| * <li><p><code>this.getName()</code> is equal to |
| * <code>((CardPermission)object).getName()</code>, and</p> |
| * <li><p><code>this.getActions()</code> is equal to |
| * <code>((CardPermission)object).getActions()</code>.</p> |
| * </ul> |
| * |
| * @param obj the object to be compared for equality with this CardPermission |
| * @return true if and only if the specified object is equal to this |
| * CardPermission |
| */ |
| public boolean equals(Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| if (obj instanceof CardPermission == false) { |
| return false; |
| } |
| CardPermission other = (CardPermission)obj; |
| return this.getName().equals(other.getName()) && (this.mask == other.mask); |
| } |
| |
| /** |
| * Returns the hash code value for this CardPermission object. |
| * |
| * @return the hash code value for this CardPermission object. |
| */ |
| public int hashCode() { |
| return getName().hashCode() + 31 * mask; |
| } |
| |
| private void writeObject(ObjectOutputStream s) throws IOException { |
| // Write out the actions. The superclass takes care of the name. |
| // Call getActions to make sure actions field is initialized |
| if (actions == null) { |
| getActions(); |
| } |
| s.defaultWriteObject(); |
| } |
| |
| private void readObject(ObjectInputStream s) |
| throws IOException, ClassNotFoundException { |
| // Read in the actions, then restore the mask. |
| s.defaultReadObject(); |
| mask = getMask(actions); |
| } |
| |
| } |
