/*

 * 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);

    }

}