/*

 * 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.util.Arrays;

import java.nio.ByteBuffer;

/**

 * A command APDU following the structure defined in ISO/IEC 7816-4.

 * It consists of a four byte header and a conditional body of variable length.

 * This class does not attempt to verify that the APDU encodes a semantically

 * valid command.

 *

 * <p>Note that when the expected length of the response APDU is specified

 * in the {@linkplain #CommandAPDU(int,int,int,int,int) constructors},

 * the actual length (Ne) must be specified, not its

 * encoded form (Le). Similarly, {@linkplain #getNe} returns the actual

 * value Ne. In other words, a value of 0 means "no data in the response APDU"

 * rather than "maximum length."

 *

 * <p>This class supports both the short and extended forms of length

 * encoding for Ne and Nc. However, note that not all terminals and Smart Cards

 * are capable of accepting APDUs that use the extended form.

 *

 * <p>For the header bytes CLA, INS, P1, and P2 the Java type <code>int</code>

 * is used to represent the 8 bit unsigned values. In the constructors, only

 * the 8 lowest bits of the <code>int</code> value specified by the application

 * are significant. The accessor methods always return the byte as an unsigned

 * value between 0 and 255.

 *

 * <p>Instances of this class are immutable. Where data is passed in or out

 * via byte arrays, defensive cloning is performed.

 *

 * @see ResponseAPDU

 * @see CardChannel#transmit CardChannel.transmit

 *

 * @since   1.6

 * @author  Andreas Sterbenz

 * @author  JSR 268 Expert Group

 */

public final class CommandAPDU implements java.io.Serializable {

    private static final long serialVersionUID = 398698301286670877L;

    private static final int MAX_APDU_SIZE = 65544;

    /** @serial */

    private byte[] apdu;

    // value of nc

    private transient int nc;

    // value of ne

    private transient int ne;

    // index of start of data within the apdu array

    private transient int dataOffset;

    /**

     * Constructs a CommandAPDU from a byte array containing the complete

     * APDU contents (header and body).

     *

     * <p>Note that the apdu bytes are copied to protect against

     * subsequent modification.

     *

     * @param apdu the complete command APDU

     *

     * @throws NullPointerException if apdu is null

     * @throws IllegalArgumentException if apdu does not contain a valid

     *   command APDU

     */

    public CommandAPDU(byte[] apdu) {

        this.apdu = apdu.clone();

        parse();

    }

    /**

     * Constructs a CommandAPDU from a byte array containing the complete

     * APDU contents (header and body). The APDU starts at the index

     * <code>apduOffset</code> in the byte array and is <code>apduLength</code>

     * bytes long.

     *

     * <p>Note that the apdu bytes are copied to protect against

     * subsequent modification.

     *

     * @param apdu the complete command APDU

     * @param apduOffset the offset in the byte array at which the apdu

     *   data begins

     * @param apduLength the length of the APDU

     *

     * @throws NullPointerException if apdu is null

     * @throws IllegalArgumentException if apduOffset or apduLength are

     *   negative or if apduOffset + apduLength are greater than apdu.length,

     *   or if the specified bytes are not a valid APDU

     */

    public CommandAPDU(byte[] apdu, int apduOffset, int apduLength) {

        checkArrayBounds(apdu, apduOffset, apduLength);

        this.apdu = new byte[apduLength];

        System.arraycopy(apdu, apduOffset, this.apdu, 0, apduLength);

        parse();

    }

    private void checkArrayBounds(byte[] b, int ofs, int len) {

        if ((ofs < 0) || (len < 0)) {

            throw new IllegalArgumentException

                ("Offset and length must not be negative");

        }

        if (b == null) {

            if ((ofs != 0) && (len != 0)) {

                throw new IllegalArgumentException

                    ("offset and length must be 0 if array is null");

            }

        } else {

            if (ofs > b.length - len) {

                throw new IllegalArgumentException

                    ("Offset plus length exceed array size");

            }

        }

    }

    /**

     * Creates a CommandAPDU from the ByteBuffer containing the complete APDU

     * contents (header and body).

     * The buffer's <code>position</code> must be set to the start of the APDU,

     * its <code>limit</code> to the end of the APDU. Upon return, the buffer's

     * <code>position</code> is equal to its limit; its limit remains unchanged.

     *

     * <p>Note that the data in the ByteBuffer is copied to protect against

     * subsequent modification.

     *

     * @param apdu the ByteBuffer containing the complete APDU

     *

     * @throws NullPointerException if apdu is null

     * @throws IllegalArgumentException if apdu does not contain a valid

     *   command APDU

     */

    public CommandAPDU(ByteBuffer apdu) {

        this.apdu = new byte[apdu.remaining()];

        apdu.get(this.apdu);

        parse();

    }

    /**

     * Constructs a CommandAPDU from the four header bytes. This is case 1

     * in ISO 7816, no command body.

     *

     * @param cla the class byte CLA

     * @param ins the instruction byte INS

     * @param p1 the parameter byte P1

     * @param p2 the parameter byte P2

     */

    public CommandAPDU(int cla, int ins, int p1, int p2) {

        this(cla, ins, p1, p2, null, 0, 0, 0);

    }

    /**

     * Constructs a CommandAPDU from the four header bytes and the expected

     * response data length. This is case 2 in ISO 7816, empty command data

     * field with Ne specified. If Ne is 0, the APDU is encoded as ISO 7816

     * case 1.

     *

     * @param cla the class byte CLA

     * @param ins the instruction byte INS

     * @param p1 the parameter byte P1

     * @param p2 the parameter byte P2

     * @param ne the maximum number of expected data bytes in a response APDU

     *

     * @throws IllegalArgumentException if ne is negative or greater than

     *   65536

     */

    public CommandAPDU(int cla, int ins, int p1, int p2, int ne) {

        this(cla, ins, p1, p2, null, 0, 0, ne);

    }

    /**

     * Constructs a CommandAPDU from the four header bytes and command data.

     * This is case 3 in ISO 7816, command data present and Ne absent. The

     * value Nc is taken as data.length. If <code>data</code> is null or

     * its length is 0, the APDU is encoded as ISO 7816 case 1.

     *

     * <p>Note that the data bytes are copied to protect against

     * subsequent modification.

     *

     * @param cla the class byte CLA

     * @param ins the instruction byte INS

     * @param p1 the parameter byte P1

     * @param p2 the parameter byte P2

     * @param data the byte array containing the data bytes of the command body

     *

     * @throws IllegalArgumentException if data.length is greater than 65535

     */

    public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data) {

        this(cla, ins, p1, p2, data, 0, arrayLength(data), 0);

    }

    /**

     * Constructs a CommandAPDU from the four header bytes and command data.

     * This is case 3 in ISO 7816, command data present and Ne absent. The

     * value Nc is taken as dataLength. If <code>dataLength</code>

     * is 0, the APDU is encoded as ISO 7816 case 1.

     *

     * <p>Note that the data bytes are copied to protect against

     * subsequent modification.

     *

     * @param cla the class byte CLA

     * @param ins the instruction byte INS

     * @param p1 the parameter byte P1

     * @param p2 the parameter byte P2

     * @param data the byte array containing the data bytes of the command body

     * @param dataOffset the offset in the byte array at which the data

     *   bytes of the command body begin

     * @param dataLength the number of the data bytes in the command body

     *

     * @throws NullPointerException if data is null and dataLength is not 0

     * @throws IllegalArgumentException if dataOffset or dataLength are

     *   negative or if dataOffset + dataLength are greater than data.length

     *   or if dataLength is greater than 65535

     */

    public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data,

            int dataOffset, int dataLength) {

        this(cla, ins, p1, p2, data, dataOffset, dataLength, 0);

    }

    /**

     * Constructs a CommandAPDU from the four header bytes, command data,

     * and expected response data length. This is case 4 in ISO 7816,

     * command data and Ne present. The value Nc is taken as data.length

     * if <code>data</code> is non-null and as 0 otherwise. If Ne or Nc

     * are zero, the APDU is encoded as case 1, 2, or 3 per ISO 7816.

     *

     * <p>Note that the data bytes are copied to protect against

     * subsequent modification.

     *

     * @param cla the class byte CLA

     * @param ins the instruction byte INS

     * @param p1 the parameter byte P1

     * @param p2 the parameter byte P2

     * @param data the byte array containing the data bytes of the command body

     * @param ne the maximum number of expected data bytes in a response APDU

     *

     * @throws IllegalArgumentException if data.length is greater than 65535

     *   or if ne is negative or greater than 65536

     */

    public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data, int ne) {

        this(cla, ins, p1, p2, data, 0, arrayLength(data), ne);

    }

    private static int arrayLength(byte[] b) {

        return (b != null) ? b.length : 0;

    }

    /**

     * Command APDU encoding options:

     *

     * case 1:  |CLA|INS|P1 |P2 |                                 len = 4

     * case 2s: |CLA|INS|P1 |P2 |LE |                             len = 5

     * case 3s: |CLA|INS|P1 |P2 |LC |...BODY...|                  len = 6..260

     * case 4s: |CLA|INS|P1 |P2 |LC |...BODY...|LE |              len = 7..261

     * case 2e: |CLA|INS|P1 |P2 |00 |LE1|LE2|                     len = 7

     * case 3e: |CLA|INS|P1 |P2 |00 |LC1|LC2|...BODY...|          len = 8..65542

     * case 4e: |CLA|INS|P1 |P2 |00 |LC1|LC2|...BODY...|LE1|LE2|  len =10..65544

     *

     * LE, LE1, LE2 may be 0x00.

     * LC must not be 0x00 and LC1|LC2 must not be 0x00|0x00

     */

    private void parse() {

        if (apdu.length < 4) {

            throw new IllegalArgumentException("apdu must be at least 4 bytes long");

        }

        if (apdu.length == 4) {

            // case 1

            return;

        }

        int l1 = apdu[4] & 0xff;

        if (apdu.length == 5) {

            // case 2s

            this.ne = (l1 == 0) ? 256 : l1;

            return;

        }

        if (l1 != 0) {

            if (apdu.length == 4 + 1 + l1) {

                // case 3s

                this.nc = l1;

                this.dataOffset = 5;

                return;

            } else if (apdu.length == 4 + 2 + l1) {

                // case 4s

                this.nc = l1;

                this.dataOffset = 5;

                int l2 = apdu[apdu.length - 1] & 0xff;

                this.ne = (l2 == 0) ? 256 : l2;

                return;

            } else {

                throw new IllegalArgumentException

                    ("Invalid APDU: length=" + apdu.length + ", b1=" + l1);

            }

        }

        if (apdu.length < 7) {

            throw new IllegalArgumentException

                ("Invalid APDU: length=" + apdu.length + ", b1=" + l1);

        }

        int l2 = ((apdu[5] & 0xff) << 8) | (apdu[6] & 0xff);

        if (apdu.length == 7) {

            // case 2e

            this.ne = (l2 == 0) ? 65536 : l2;

            return;

        }

        if (l2 == 0) {

            throw new IllegalArgumentException("Invalid APDU: length="

                    + apdu.length + ", b1=" + l1 + ", b2||b3=" + l2);

        }

        if (apdu.length == 4 + 3 + l2) {

            // case 3e

            this.nc = l2;

            this.dataOffset = 7;

            return;

        } else if (apdu.length == 4 + 5 + l2) {

            // case 4e

            this.nc = l2;

            this.dataOffset = 7;

            int leOfs = apdu.length - 2;

            int l3 = ((apdu[leOfs] & 0xff) << 8) | (apdu[leOfs + 1] & 0xff);

            this.ne = (l3 == 0) ? 65536 : l3;

        } else {

            throw new IllegalArgumentException("Invalid APDU: length="

                    + apdu.length + ", b1=" + l1 + ", b2||b3=" + l2);

        }

    }

    /**

     * Constructs a CommandAPDU from the four header bytes, command data,

     * and expected response data length. This is case 4 in ISO 7816,

     * command data and Le present. The value Nc is taken as

     * <code>dataLength</code>.

     * If Ne or Nc

     * are zero, the APDU is encoded as case 1, 2, or 3 per ISO 7816.

     *

     * <p>Note that the data bytes are copied to protect against

     * subsequent modification.

     *

     * @param cla the class byte CLA

     * @param ins the instruction byte INS

     * @param p1 the parameter byte P1

     * @param p2 the parameter byte P2

     * @param data the byte array containing the data bytes of the command body

     * @param dataOffset the offset in the byte array at which the data

     *   bytes of the command body begin

     * @param dataLength the number of the data bytes in the command body

     * @param ne the maximum number of expected data bytes in a response APDU

     *

     * @throws NullPointerException if data is null and dataLength is not 0

     * @throws IllegalArgumentException if dataOffset or dataLength are

     *   negative or if dataOffset + dataLength are greater than data.length,

     *   or if ne is negative or greater than 65536,

     *   or if dataLength is greater than 65535

     */

    public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data,

            int dataOffset, int dataLength, int ne) {

        checkArrayBounds(data, dataOffset, dataLength);

        if (dataLength > 65535) {

            throw new IllegalArgumentException("dataLength is too large");

        }

        if (ne < 0) {

            throw new IllegalArgumentException("ne must not be negative");

        }

        if (ne > 65536) {

            throw new IllegalArgumentException("ne is too large");

        }

        this.ne = ne;

        this.nc = dataLength;

        if (dataLength == 0) {

            if (ne == 0) {

                // case 1

                this.apdu = new byte[4];

                setHeader(cla, ins, p1, p2);

            } else {

                // case 2s or 2e

                if (ne <= 256) {

                    // case 2s

                    // 256 is encoded as 0x00

                    byte len = (ne != 256) ? (byte)ne : 0;

                    this.apdu = new byte[5];

                    setHeader(cla, ins, p1, p2);

                    this.apdu[4] = len;

                } else {

                    // case 2e

                    byte l1, l2;

                    // 65536 is encoded as 0x00 0x00

                    if (ne == 65536) {

                        l1 = 0;

                        l2 = 0;

                    } else {

                        l1 = (byte)(ne >> 8);

                        l2 = (byte)ne;

                    }

                    this.apdu = new byte[7];

                    setHeader(cla, ins, p1, p2);

                    this.apdu[5] = l1;

                    this.apdu[6] = l2;

                }

            }

        } else {

            if (ne == 0) {

                // case 3s or 3e

                if (dataLength <= 255) {

                    // case 3s

                    apdu = new byte[4 + 1 + dataLength];

                    setHeader(cla, ins, p1, p2);

                    apdu[4] = (byte)dataLength;

                    this.dataOffset = 5;

                    System.arraycopy(data, dataOffset, apdu, 5, dataLength);

                } else {

                    // case 3e

                    apdu = new byte[4 + 3 + dataLength];

                    setHeader(cla, ins, p1, p2);

                    apdu[4] = 0;

                    apdu[5] = (byte)(dataLength >> 8);

                    apdu[6] = (byte)dataLength;

                    this.dataOffset = 7;

                    System.arraycopy(data, dataOffset, apdu, 7, dataLength);

                }

            } else {

                // case 4s or 4e

                if ((dataLength <= 255) && (ne <= 256)) {

                    // case 4s

                    apdu = new byte[4 + 2 + dataLength];

                    setHeader(cla, ins, p1, p2);

                    apdu[4] = (byte)dataLength;

                    this.dataOffset = 5;

                    System.arraycopy(data, dataOffset, apdu, 5, dataLength);

                    apdu[apdu.length - 1] = (ne != 256) ? (byte)ne : 0;

                } else {

                    // case 4e

                    apdu = new byte[4 + 5 + dataLength];

                    setHeader(cla, ins, p1, p2);

                    apdu[4] = 0;

                    apdu[5] = (byte)(dataLength >> 8);

                    apdu[6] = (byte)dataLength;

                    this.dataOffset = 7;

                    System.arraycopy(data, dataOffset, apdu, 7, dataLength);

                    if (ne != 65536) {

                        int leOfs = apdu.length - 2;

                        apdu[leOfs] = (byte)(ne >> 8);

                        apdu[leOfs + 1] = (byte)ne;

                    } // else le == 65536: no need to fill in, encoded as 0

                }

            }

        }

    }

    private void setHeader(int cla, int ins, int p1, int p2) {

        apdu[0] = (byte)cla;

        apdu[1] = (byte)ins;

        apdu[2] = (byte)p1;

        apdu[3] = (byte)p2;

    }

    /**

     * Returns the value of the class byte CLA.

     *

     * @return the value of the class byte CLA.

     */

    public int getCLA() {

        return apdu[0] & 0xff;

    }

    /**

     * Returns the value of the instruction byte INS.

     *

     * @return the value of the instruction byte INS.

     */

    public int getINS() {

        return apdu[1] & 0xff;

    }

    /**

     * Returns the value of the parameter byte P1.

     *

     * @return the value of the parameter byte P1.

     */

    public int getP1() {

        return apdu[2] & 0xff;

    }

    /**

     * Returns the value of the parameter byte P2.

     *

     * @return the value of the parameter byte P2.

     */

    public int getP2() {

        return apdu[3] & 0xff;

    }

    /**

     * Returns the number of data bytes in the command body (Nc) or 0 if this

     * APDU has no body. This call is equivalent to

     * <code>getData().length</code>.

     *

     * @return the number of data bytes in the command body or 0 if this APDU

     * has no body.

     */

    public int getNc() {

        return nc;

    }