267 lines · 9.7 KB · Java
RawDownload
/* * 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.util.*;import java.lang.ref.*; import javax.smartcardio.*;import static javax.smartcardio.CardTerminals.State.*; import static sun.security.smartcardio.PCSC.*; /** * TerminalFactorySpi implementation class. * * @since   1.6 * @author  Andreas Sterbenz */final class PCSCTerminals extends CardTerminals {     // SCARDCONTEXT, currently shared between all threads/terminals    private static long contextId;     // terminal state used by waitForCard()    private Map<String,ReaderState> stateMap;     PCSCTerminals() {        // empty    }     static synchronized void initContext() throws PCSCException {        if (contextId == 0) {            contextId = SCardEstablishContext(SCARD_SCOPE_USER);        }    }     private static final Map<String,Reference<TerminalImpl>> terminals        = new HashMap<String,Reference<TerminalImpl>>();     private static synchronized TerminalImpl implGetTerminal(String name) {        Reference<TerminalImpl> ref = terminals.get(name);        TerminalImpl terminal = (ref != null) ? ref.get() : null;        if (terminal != null) {            return terminal;        }        terminal = new TerminalImpl(contextId, name);        terminals.put(name, new WeakReference<TerminalImpl>(terminal));        return terminal;     }     public synchronized List<CardTerminal> list(State state) throws CardException {        if (state == null) {            throw new NullPointerException();        }        try {            String[] readerNames = SCardListReaders(contextId);            List<CardTerminal> list = new ArrayList<CardTerminal>(readerNames.length);            if (stateMap == null) {                // If waitForChange() has never been called, treat event                // queries as status queries.                if (state == CARD_INSERTION) {                    state = CARD_PRESENT;                } else if (state == CARD_REMOVAL) {                    state = CARD_ABSENT;                }            }            for (String readerName : readerNames) {                CardTerminal terminal = implGetTerminal(readerName);                ReaderState readerState;                switch (state) {                case ALL:                    list.add(terminal);                    break;                case CARD_PRESENT:                    if (terminal.isCardPresent()) {                        list.add(terminal);                    }                    break;                case CARD_ABSENT:                    if (terminal.isCardPresent() == false) {                        list.add(terminal);                    }                    break;                case CARD_INSERTION:                    readerState = stateMap.get(readerName);                    if ((readerState != null) && readerState.isInsertion()) {                        list.add(terminal);                    }                    break;                case CARD_REMOVAL:                    readerState = stateMap.get(readerName);                    if ((readerState != null) && readerState.isRemoval()) {                        list.add(terminal);                    }                    break;                default:                    throw new CardException("Unknown state: " + state);                }            }            return Collections.unmodifiableList(list);        } catch (PCSCException e) {            throw new CardException("list() failed", e);        }    }     private static class ReaderState {        private int current, previous;        ReaderState() {            current = SCARD_STATE_UNAWARE;            previous = SCARD_STATE_UNAWARE;        }        int get() {            return current;        }        void update(int newState) {            previous = current;            current = newState;        }        boolean isInsertion() {            return !present(previous) && present(current);        }        boolean isRemoval() {            return present(previous) && !present(current);        }        static boolean present(int state) {            return (state & SCARD_STATE_PRESENT) != 0;        }    }     public synchronized boolean waitForChange(long timeout) throws CardException {        if (timeout < 0) {            throw new IllegalArgumentException                ("Timeout must not be negative: " + timeout);        }        if (stateMap == null) {            // We need to initialize the state database.            // Do that with a recursive call, which will return immediately            // because we pass SCARD_STATE_UNAWARE.            // After that, proceed with the real call.            stateMap = new HashMap<String,ReaderState>();            waitForChange(0);        }        if (timeout == 0) {            timeout = TIMEOUT_INFINITE;        }        try {            String[] readerNames = SCardListReaders(contextId);            int n = readerNames.length;            if (n == 0) {                throw new IllegalStateException("No terminals available");            }            int[] status = new int[n];            ReaderState[] readerStates = new ReaderState[n];            for (int i = 0; i < readerNames.length; i++) {                String name = readerNames[i];                ReaderState state = stateMap.get(name);                if (state == null) {                    state = new ReaderState();                }                readerStates[i] = state;                status[i] = state.get();            }            status = SCardGetStatusChange(contextId, timeout, status, readerNames);            stateMap.clear(); // remove any readers that are no longer available            for (int i = 0; i < n; i++) {                ReaderState state = readerStates[i];                state.update(status[i]);                stateMap.put(readerNames[i], state);            }            return true;        } catch (PCSCException e) {            if (e.code == SCARD_E_TIMEOUT) {                return false;            } else {                throw new CardException("waitForChange() failed", e);            }        }    }     static List<CardTerminal> waitForCards(List<? extends CardTerminal> terminals,            long timeout, boolean wantPresent) throws CardException {        // the argument sanity checks are performed in        // javax.smartcardio.TerminalFactory or TerminalImpl         long thisTimeout;        if (timeout == 0) {            timeout = TIMEOUT_INFINITE;            thisTimeout = TIMEOUT_INFINITE;        } else {            // if timeout is not infinite, do the initial call that retrieves            // the status with a 0 timeout. Otherwise, we might get incorrect            // timeout exceptions (seen on Solaris with PC/SC shim)            thisTimeout = 0;        }         String[] names = new String[terminals.size()];        int i = 0;        for (CardTerminal terminal : terminals) {            if (terminal instanceof TerminalImpl == false) {                throw new IllegalArgumentException                    ("Invalid terminal type: " + terminal.getClass().getName());            }            TerminalImpl impl = (TerminalImpl)terminal;            names[i++] = impl.name;        }         int[] status = new int[names.length];        Arrays.fill(status, SCARD_STATE_UNAWARE);         try {            while (true) {                // note that we pass "timeout" on each native PC/SC call                // that means that if we end up making multiple (more than 2)                // calls, we might wait too long.                // for now assume that is unlikely and not a problem.                status = SCardGetStatusChange(contextId, thisTimeout, status, names);                thisTimeout = timeout;                 List<CardTerminal> results = null;                for (i = 0; i < names.length; i++) {                    boolean nowPresent = (status[i] & SCARD_STATE_PRESENT) != 0;                    if (nowPresent == wantPresent) {                        if (results == null) {                            results = new ArrayList<CardTerminal>();                        }                        results.add(implGetTerminal(names[i]));                    }                }                 if (results != null) {                    return Collections.unmodifiableList(results);                }            }        } catch (PCSCException e) {            if (e.code == SCARD_E_TIMEOUT) {                return Collections.emptyList();            } else {                throw new CardException("waitForCard() failed", e);            }        }    } }