/* * 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 sun.security.smartcardio; import java.nio.*;import java.security.AccessController; import javax.smartcardio.*; import static sun.security.smartcardio.PCSC.*; import sun.security.action.GetPropertyAction; /** * CardChannel implementation. * * @since   1.6 * @author  Andreas Sterbenz */final class ChannelImpl extends CardChannel {     // the card this channel is associated with    private final CardImpl card;     // the channel number, 0 for the basic logical channel    private final int channel;     // whether this channel has been closed. only logical channels can be closed    private volatile boolean isClosed;     ChannelImpl(CardImpl card, int channel) {        this.card = card;        this.channel = channel;    }     void checkClosed() {        card.checkState();        if (isClosed) {            throw new IllegalStateException("Logical channel has been closed");        }    }     public Card getCard() {        return card;    }     public int getChannelNumber() {        checkClosed();        return channel;    }     private static void checkManageChannel(byte[] b) {        if (b.length < 4) {            throw new IllegalArgumentException                ("Command APDU must be at least 4 bytes long");        }        if ((b[0] >= 0) && (b[1] == 0x70)) {            throw new IllegalArgumentException                ("Manage channel command not allowed, use openLogicalChannel()");        }    }     public ResponseAPDU transmit(CommandAPDU command) throws CardException {        checkClosed();        card.checkExclusive();        byte[] commandBytes = command.getBytes();        byte[] responseBytes = doTransmit(commandBytes);        return new ResponseAPDU(responseBytes);    }     public int transmit(ByteBuffer command, ByteBuffer response) throws CardException {        checkClosed();        card.checkExclusive();        if ((command == null) || (response == null)) {            throw new NullPointerException();        }        if (response.isReadOnly()) {            throw new ReadOnlyBufferException();        }        if (command == response) {            throw new IllegalArgumentException                    ("command and response must not be the same object");        }        if (response.remaining() < 258) {            throw new IllegalArgumentException                    ("Insufficient space in response buffer");        }        byte[] commandBytes = new byte[command.remaining()];        command.get(commandBytes);        byte[] responseBytes = doTransmit(commandBytes);        response.put(responseBytes);        return responseBytes.length;    }     private final static boolean t0GetResponse =        getBooleanProperty("sun.security.smartcardio.t0GetResponse", true);     private final static boolean t1GetResponse =        getBooleanProperty("sun.security.smartcardio.t1GetResponse", true);     private final static boolean t1StripLe =        getBooleanProperty("sun.security.smartcardio.t1StripLe", false);     private static boolean getBooleanProperty(String name, boolean def) {        String val = AccessController.doPrivileged(new GetPropertyAction(name));        if (val == null) {            return def;        }        if (val.equalsIgnoreCase("true")) {            return true;        } else if (val.equalsIgnoreCase("false")) {            return false;        } else {            throw new IllegalArgumentException                (name + " must be either 'true' or 'false'");        }    }     private byte[] concat(byte[] b1, byte[] b2, int n2) {        int n1 = b1.length;        if ((n1 == 0) && (n2 == b2.length)) {            return b2;        }        byte[] res = new byte[n1 + n2];        System.arraycopy(b1, 0, res, 0, n1);        System.arraycopy(b2, 0, res, n1, n2);        return res;    }     private final static byte[] B0 = new byte[0];     private byte[] doTransmit(byte[] command) throws CardException {        // note that we modify the 'command' array in some cases, so it must        // be a copy of the application provided data.        try {            checkManageChannel(command);            setChannel(command);            int n = command.length;            boolean t0 = card.protocol == SCARD_PROTOCOL_T0;            boolean t1 = card.protocol == SCARD_PROTOCOL_T1;            if (t0 && (n >= 7) && (command[4] == 0)) {                throw new CardException                        ("Extended length forms not supported for T=0");            }            if ((t0 || (t1 && t1StripLe)) && (n >= 7)) {                int lc = command[4] & 0xff;                if (lc != 0) {                    if (n == lc + 6) {                        n--;                    }                } else {                    lc = ((command[5] & 0xff) << 8) | (command[6] & 0xff);                    if (n == lc + 9) {                        n -= 2;                    }                }            }            boolean getresponse = (t0 && t0GetResponse) || (t1 && t1GetResponse);            int k = 0;            byte[] result = B0;            while (true) {                if (++k >= 32) {                    throw new CardException("Could not obtain response");                }                byte[] response = SCardTransmit                    (card.cardId, card.protocol, command, 0, n);                int rn = response.length;                if (getresponse && (rn >= 2)) {                    // see ISO 7816/2005, 5.1.3                    if ((rn == 2) && (response[0] == 0x6c)) {                        // Resend command using SW2 as short Le field                        command[n - 1] = response[1];                        continue;                    }                    if (response[rn - 2] == 0x61) {                        // Issue a GET RESPONSE command with the same CLA                        // using SW2 as short Le field                        if (rn > 2) {                            result = concat(result, response, rn - 2);                        }                        command[1] = (byte)0xC0;                        command[2] = 0;                        command[3] = 0;                        command[4] = response[rn - 1];                        n = 5;                        continue;                    }                 }                result = concat(result, response, rn);                break;            }            return result;        } catch (PCSCException e) {            card.handleError(e);            throw new CardException(e);        }    }     private static int getSW(byte[] res) throws CardException {        if (res.length < 2) {            throw new CardException("Invalid response length: " + res.length);        }        int sw1 = res[res.length - 2] & 0xff;        int sw2 = res[res.length - 1] & 0xff;        return (sw1 << 8) | sw2;    }     private static boolean isOK(byte[] res) throws CardException {        return (res.length == 2) && (getSW(res) == 0x9000);    }     private void setChannel(byte[] com) {        int cla = com[0];        if (cla < 0) {            // proprietary class format, cannot set or check logical channel            // for now, just return            return;        }        // classes 001x xxxx is reserved for future use in ISO, ignore        if ((cla & 0xe0) == 0x20) {            return;        }        // see ISO 7816/2005, table 2 and 3        if (channel <= 3) {            // mask of bits 7, 1, 0 (channel number)            // 0xbc == 1011 1100            com[0] &= 0xbc;            com[0] |= channel;        } else if (channel <= 19) {            // mask of bits 7, 3, 2, 1, 0 (channel number)            // 0xbc == 1011 0000            com[0] &= 0xb0;            com[0] |= 0x40;            com[0] |= (channel - 4);        } else {            throw new RuntimeException("Unsupported channel number: " + channel);        }    }     public void close() throws CardException {        if (getChannelNumber() == 0) {            throw new IllegalStateException("Cannot close basic logical channel");        }        if (isClosed) {            return;        }        card.checkExclusive();        try {            byte[] com = new byte[] {0x00, 0x70, (byte)0x80, 0};            com[3] = (byte)getChannelNumber();            setChannel(com);            byte[] res = SCardTransmit(card.cardId, card.protocol, com, 0, com.length);            if (isOK(res) == false) {                throw new CardException("close() failed: " + PCSC.toString(res));            }        } catch (PCSCException e) {            card.handleError(e);            throw new CardException("Could not close channel", e);        } finally {            isClosed = true;        }    }     public String toString() {        return "PC/SC channel " + channel;    } }