winscard.c

Go to the documentation of this file.

/*
 * MUSCLE SmartCard Development ( https://pcsclite.apdu.fr/ )
 *
 * Copyright (C) 1999-2004
 *  David Corcoran <corcoran@musclecard.com>
 * Copyright (C) 2002-2023
 *  Ludovic Rousseau <ludovic.rousseau@free.fr>
 *
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
 
1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
   derived from this software without specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


 
#include "config.h"
#include <stdlib.h>
#include <sys/time.h>
#include <string.h>
#include <pthread.h>
 
#include "pcscd.h"
#include "winscard.h"
#include "ifdhandler.h"
#include "debuglog.h"
#include "readerfactory.h"
#include "prothandler.h"
#include "ifdwrapper.h"
#include "atrhandler.h"
#include "sys_generic.h"
#include "eventhandler.h"
#include "utils.h"
#include "reader.h"
 
#undef DO_PROFILE
#ifdef DO_PROFILE
 
#define PROFILE_FILE "/tmp/pcscd_profile"
#include <stdio.h>
#include <sys/time.h>
#include <errno.h>
#include <unistd.h>
 
struct timeval profile_time_start;
FILE *fd;
bool profile_tty;
 
#define PROFILE_START profile_start(__FUNCTION__);
#define PROFILE_END profile_end(__FUNCTION__, __LINE__);
 
static void profile_start(const char *f)
{
    static bool initialized = false;
 
    if (!initialized)
    {
        initialized = true;
        fd = fopen(PROFILE_FILE, "a+");
        if (NULL == fd)
        {
            fprintf(stderr, "\33[01;31mCan't open %s: %s\33[0m\n",
                PROFILE_FILE, strerror(errno));
            exit(-1);
        }
        fprintf(fd, "\nStart a new profile\n");
        fflush(fd);
 
        if (isatty(fileno(stderr)))
            profile_tty = true;
        else
            profile_tty = false;
    }
 
    gettimeofday(&profile_time_start, NULL);
} /* profile_start */
 
 
static void profile_end(const char *f, int line)
{
    struct timeval profile_time_end;
    long d;
 
    gettimeofday(&profile_time_end, NULL);
    d = time_sub(&profile_time_end, &profile_time_start);
 
    if (profile_tty)
        fprintf(stderr, "\33[01;31mRESULT %s \33[35m%ld\33[0m (%d)\n", f, d,
            line);
    fprintf(fd, "%s %ld\n", f, d);
    fflush(fd);
} /* profile_end */
 
#else
#define PROFILE_START
#define PROFILE_END
#endif

#define SCARD_PROTOCOL_ANY_OLD   0x1000
 
static pthread_mutex_t LockMutex = PTHREAD_MUTEX_INITIALIZER;
 
LONG SCardEstablishContext(DWORD dwScope, /*@unused@*/ LPCVOID pvReserved1,
    /*@unused@*/ LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
{
    (void)pvReserved1;
    (void)pvReserved2;
 
    if (dwScope != SCARD_SCOPE_USER && dwScope != SCARD_SCOPE_TERMINAL &&
        dwScope != SCARD_SCOPE_SYSTEM && dwScope != SCARD_SCOPE_GLOBAL)
    {
        *phContext = 0;
        return SCARD_E_INVALID_VALUE;
    }
 
    /*
     * Unique identifier for this server so that it can uniquely be
     * identified by clients and distinguished from others
     */
 
    *phContext = SYS_RandomInt();
 
    Log2(PCSC_LOG_DEBUG, "Establishing Context: 0x%lX", *phContext);
 
    return SCARD_S_SUCCESS;
}
 
LONG SCardReleaseContext(SCARDCONTEXT hContext)
{
    /*
     * Nothing to do here RPC layer will handle this
     */
#ifdef NO_LOG
    (void)hContext;
#endif
 
    Log2(PCSC_LOG_DEBUG, "Releasing Context: 0x%lX", hContext);
 
    return SCARD_S_SUCCESS;
}
 
LONG SCardConnect(/*@unused@*/ SCARDCONTEXT hContext, LPCSTR szReader,
    DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
    LPDWORD pdwActiveProtocol)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
 
    (void)hContext;
    PROFILE_START
 
    *phCard = 0;
 
    if ((dwShareMode != SCARD_SHARE_DIRECT) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_T0) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_T1) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_RAW) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD))
        return SCARD_E_PROTO_MISMATCH;
 
    if (dwShareMode != SCARD_SHARE_EXCLUSIVE &&
            dwShareMode != SCARD_SHARE_SHARED &&
            dwShareMode != SCARD_SHARE_DIRECT)
        return SCARD_E_INVALID_VALUE;
 
    Log3(PCSC_LOG_DEBUG, "Attempting Connect to %s using protocol: %ld",
        szReader, dwPreferredProtocols);
 
    rv = RFReaderInfo((LPSTR) szReader, &rContext);
    if (rv != SCARD_S_SUCCESS)
    {
        Log2(PCSC_LOG_ERROR, "Reader %s Not Found", szReader);
        return rv;
    }
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*******************************************
     *
     * This section checks for simple errors
     *
     *******************************************/
 
    /*
     * Connect if not exclusive mode
     */
    if (rContext->contexts == PCSCLITE_SHARING_EXCLUSIVE_CONTEXT)
    {
        Log1(PCSC_LOG_ERROR, "Error Reader Exclusive");
        rv = SCARD_E_SHARING_VIOLATION;
        goto exit;
    }
 
    /*
     * wait until a possible transaction is finished
     */
    if (rContext->hLockId != 0)
    {
        Log1(PCSC_LOG_INFO, "Waiting for release of lock");
        while (rContext->hLockId != 0)
            (void)SYS_USleep(PCSCLITE_LOCK_POLL_RATE);
        Log1(PCSC_LOG_INFO, "Lock released");
    }
 
    /*******************************************
     *
     * This section tries to determine the
     * presence of a card or not
     *
     *******************************************/
    if (dwShareMode != SCARD_SHARE_DIRECT)
    {
        if (!(rContext->readerState.readerState & SCARD_PRESENT))
        {
            Log1(PCSC_LOG_DEBUG, "Card Not Inserted");
            rv = SCARD_E_NO_SMARTCARD;
            goto exit;
        }
 
        /* Power on (again) the card if needed */
        (void)pthread_mutex_lock(&rContext->powerState_lock);
        if (POWER_STATE_UNPOWERED == rContext->powerState)
        {
            DWORD dwAtrLen;
 
            dwAtrLen = sizeof(rContext->readerState.cardAtr);
            rv = IFDPowerICC(rContext, IFD_POWER_UP,
                rContext->readerState.cardAtr, &dwAtrLen);
            rContext->readerState.cardAtrLength = dwAtrLen;
 
            if (rv == IFD_SUCCESS)
            {
                rContext->readerState.readerState = SCARD_PRESENT | SCARD_POWERED | SCARD_NEGOTIABLE;
 
                Log1(PCSC_LOG_DEBUG, "power up complete.");
                LogXxd(PCSC_LOG_DEBUG, "Card ATR: ",
                    rContext->readerState.cardAtr,
                    rContext->readerState.cardAtrLength);
            }
            else
                Log2(PCSC_LOG_ERROR, "Error powering up card: %s",
                    rv2text(rv));
        }
 
        if (! (rContext->readerState.readerState & SCARD_POWERED))
        {
            Log1(PCSC_LOG_ERROR, "Card Not Powered");
            (void)pthread_mutex_unlock(&rContext->powerState_lock);
            rv = SCARD_W_UNPOWERED_CARD;
            goto exit;
        }
 
        /* the card is now in use */
        rContext->powerState = POWER_STATE_IN_USE;
        Log1(PCSC_LOG_DEBUG, "powerState: POWER_STATE_IN_USE");
        (void)pthread_mutex_unlock(&rContext->powerState_lock);
    }
 
    /*******************************************
     *
     * This section tries to decode the ATR
     * and set up which protocol to use
     *
     *******************************************/
    if (dwPreferredProtocols & SCARD_PROTOCOL_RAW)
        rContext->readerState.cardProtocol = SCARD_PROTOCOL_RAW;
    else
    {
        if (dwShareMode != SCARD_SHARE_DIRECT)
        {
            /* lock here instead in IFDSetPTS() to lock up to
             * setting rContext->readerState.cardProtocol */
            (void)pthread_mutex_lock(rContext->mMutex);
 
            /* the protocol is not yet set (no PPS yet) */
            if (SCARD_PROTOCOL_UNDEFINED == rContext->readerState.cardProtocol)
            {
                int availableProtocols, defaultProtocol;
                int ret;
 
                ATRDecodeAtr(&availableProtocols, &defaultProtocol,
                    rContext->readerState.cardAtr,
                    rContext->readerState.cardAtrLength);
 
                /* If it is set to ANY let it do any of the protocols */
                if (dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD)
                    dwPreferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
 
                /* restrict to the protocols requested by the user */
                availableProtocols &= dwPreferredProtocols;
 
                ret = PHSetProtocol(rContext, dwPreferredProtocols,
                    availableProtocols, defaultProtocol);
 
                /* keep cardProtocol = SCARD_PROTOCOL_UNDEFINED in case of error  */
                if (SET_PROTOCOL_PPS_FAILED == ret)
                {
                    (void)pthread_mutex_unlock(rContext->mMutex);
                    rv = SCARD_W_UNRESPONSIVE_CARD;
                    goto exit;
                }
 
                if (SET_PROTOCOL_WRONG_ARGUMENT == ret)
                {
                    (void)pthread_mutex_unlock(rContext->mMutex);
                    rv = SCARD_E_PROTO_MISMATCH;
                    goto exit;
                }
 
                /* use negotiated protocol */
                rContext->readerState.cardProtocol = ret;
 
                (void)pthread_mutex_unlock(rContext->mMutex);
            }
            else
            {
                (void)pthread_mutex_unlock(rContext->mMutex);
 
                if (! (dwPreferredProtocols & rContext->readerState.cardProtocol))
                {
                    rv = SCARD_E_PROTO_MISMATCH;
                    goto exit;
                }
            }
        }
    }
 
    *pdwActiveProtocol = rContext->readerState.cardProtocol;
 
    if (dwShareMode != SCARD_SHARE_DIRECT)
    {
        switch (*pdwActiveProtocol)
        {
            case SCARD_PROTOCOL_T0:
            case SCARD_PROTOCOL_T1:
                Log2(PCSC_LOG_DEBUG, "Active Protocol: T=%d",
                    (*pdwActiveProtocol == SCARD_PROTOCOL_T0) ? 0 : 1);
                break;
 
            case SCARD_PROTOCOL_RAW:
                Log1(PCSC_LOG_DEBUG, "Active Protocol: RAW");
                break;
 
            default:
                Log2(PCSC_LOG_ERROR, "Active Protocol: unknown %ld",
                    *pdwActiveProtocol);
        }
    }
    else
        Log1(PCSC_LOG_DEBUG, "Direct access: no protocol selected");
 
    /*
     * Prepare the SCARDHANDLE identity
     */
 
    /* we need a lock to avoid concurrent generation of handles leading
     * to a possible hCard handle duplication */
    (void)pthread_mutex_lock(&LockMutex);
 
    *phCard = RFCreateReaderHandle(rContext);
 
    Log2(PCSC_LOG_DEBUG, "hCard Identity: %lx", *phCard);
 
    /*******************************************
     *
     * This section tries to set up the
     * exclusivity modes. -1 is exclusive
     *
     *******************************************/
 
    if (dwShareMode == SCARD_SHARE_EXCLUSIVE)
    {
        if (rContext->contexts == PCSCLITE_SHARING_NO_CONTEXT)
        {
            rContext->contexts = PCSCLITE_SHARING_EXCLUSIVE_CONTEXT;
            (void)RFLockSharing(*phCard, rContext);
        }
        else
        {
            *phCard = 0;
            rv = SCARD_E_SHARING_VIOLATION;
            (void)pthread_mutex_unlock(&LockMutex);
            goto exit;
        }
    }
    else
    {
        /*
         * Add a connection to the context stack
         */
        rContext->contexts += 1;
    }
 
    /*
     * Add this handle to the handle list
     */
    rv = RFAddReaderHandle(rContext, *phCard);
 
    (void)pthread_mutex_unlock(&LockMutex);
 
    if (rv != SCARD_S_SUCCESS)
    {
        /*
         * Clean up - there is no more room
         */
        if (rContext->contexts == PCSCLITE_SHARING_EXCLUSIVE_CONTEXT)
            rContext->contexts = PCSCLITE_SHARING_NO_CONTEXT;
        else
            if (rContext->contexts > PCSCLITE_SHARING_NO_CONTEXT)
                rContext->contexts -= 1;
 
        *phCard = 0;
 
        rv = SCARD_F_INTERNAL_ERROR;
        goto exit;
    }
 
    /*
     * Propagate new state to reader state
     */
    rContext->readerState.readerSharing = rContext->contexts;
 
exit:
    UNREF_READER(rContext)
 
    PROFILE_END
 
    return rv;
}
 
LONG SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,
    DWORD dwPreferredProtocols, DWORD dwInitialization,
    LPDWORD pdwActiveProtocol)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
 
    Log1(PCSC_LOG_DEBUG, "Attempting reconnect to token.");
 
    if (hCard == 0)
        return SCARD_E_INVALID_HANDLE;
 
    /*
     * Handle the dwInitialization
     */
    if (dwInitialization != SCARD_LEAVE_CARD &&
            dwInitialization != SCARD_RESET_CARD &&
            dwInitialization != SCARD_UNPOWER_CARD)
        return SCARD_E_INVALID_VALUE;
 
    if (dwShareMode != SCARD_SHARE_SHARED &&
            dwShareMode != SCARD_SHARE_EXCLUSIVE &&
            dwShareMode != SCARD_SHARE_DIRECT)
        return SCARD_E_INVALID_VALUE;
 
    if ((dwShareMode != SCARD_SHARE_DIRECT) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_T0) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_T1) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_RAW) &&
            !(dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD))
        return SCARD_E_PROTO_MISMATCH;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure no one has a lock on this reader
     */
    rv = RFCheckSharing(hCard, rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    if (dwInitialization == SCARD_RESET_CARD ||
        dwInitialization == SCARD_UNPOWER_CARD)
    {
        DWORD dwAtrLen;
 
        /*
         * Notify the card has been reset
         */
        RFSetReaderEventState(rContext, SCARD_RESET);
 
        dwAtrLen = sizeof(rContext->readerState.cardAtr);
        if (SCARD_RESET_CARD == dwInitialization)
            rv = IFDPowerICC(rContext, IFD_RESET,
                rContext->readerState.cardAtr, &dwAtrLen);
        else
        {
            IFDPowerICC(rContext, IFD_POWER_DOWN, NULL, NULL);
            rv = IFDPowerICC(rContext, IFD_POWER_UP,
                rContext->readerState.cardAtr, &dwAtrLen);
        }
 
        /* the protocol is unset after a power on */
        rContext->readerState.cardProtocol = SCARD_PROTOCOL_UNDEFINED;
 
        /*
         * Set up the status bit masks on readerState
         */
        if (rv == IFD_SUCCESS)
        {
            rContext->readerState.cardAtrLength = dwAtrLen;
            rContext->readerState.readerState =
                SCARD_PRESENT | SCARD_POWERED | SCARD_NEGOTIABLE;
 
            Log1(PCSC_LOG_DEBUG, "Reset complete.");
            LogXxd(PCSC_LOG_DEBUG, "Card ATR: ",
                rContext->readerState.cardAtr,
                rContext->readerState.cardAtrLength);
        }
        else
        {
            rContext->readerState.cardAtrLength = 0;
            Log1(PCSC_LOG_ERROR, "Error resetting card.");
 
            if (rv == SCARD_W_REMOVED_CARD)
            {
                rContext->readerState.readerState = SCARD_ABSENT;
                rv = SCARD_E_NO_SMARTCARD;
                goto exit;
            }
            else
            {
                rContext->readerState.readerState =
                    SCARD_PRESENT | SCARD_SWALLOWED;
                rv = SCARD_W_UNRESPONSIVE_CARD;
                goto exit;
            }
        }
    }
    else
        if (dwInitialization == SCARD_LEAVE_CARD)
        {
            uint32_t readerState = rContext->readerState.readerState;
 
            if (readerState & SCARD_ABSENT)
            {
                rv = SCARD_E_NO_SMARTCARD;
                goto exit;
            }
 
            if ((readerState & SCARD_PRESENT)
                && (readerState & SCARD_SWALLOWED))
            {
                rv = SCARD_W_UNRESPONSIVE_CARD;
                goto exit;
            }
        }
 
    /*******************************************
     *
     * This section tries to decode the ATR
     * and set up which protocol to use
     *
     *******************************************/
    if (dwPreferredProtocols & SCARD_PROTOCOL_RAW)
        rContext->readerState.cardProtocol = SCARD_PROTOCOL_RAW;
    else
    {
        if (dwShareMode != SCARD_SHARE_DIRECT)
        {
            /* lock here instead in IFDSetPTS() to lock up to
             * setting rContext->readerState.cardProtocol */
            (void)pthread_mutex_lock(rContext->mMutex);
 
            /* the protocol is not yet set (no PPS yet) */
            if (SCARD_PROTOCOL_UNDEFINED == rContext->readerState.cardProtocol)
            {
                int availableProtocols, defaultProtocol;
                int ret;
 
                ATRDecodeAtr(&availableProtocols, &defaultProtocol,
                    rContext->readerState.cardAtr,
                    rContext->readerState.cardAtrLength);
 
                /* If it is set to ANY let it do any of the protocols */
                if (dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD)
                    dwPreferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
 
                /* restrict to the protocols requested by the user */
                availableProtocols &= dwPreferredProtocols;
 
                ret = PHSetProtocol(rContext, dwPreferredProtocols,
                    availableProtocols, defaultProtocol);
 
                /* keep cardProtocol = SCARD_PROTOCOL_UNDEFINED in case of error  */
                if (SET_PROTOCOL_PPS_FAILED == ret)
                {
                    (void)pthread_mutex_unlock(rContext->mMutex);
                    rv = SCARD_W_UNRESPONSIVE_CARD;
                    goto exit;
                }
 
                if (SET_PROTOCOL_WRONG_ARGUMENT == ret)
                {
                    (void)pthread_mutex_unlock(rContext->mMutex);
                    rv = SCARD_E_PROTO_MISMATCH;
                    goto exit;
                }
 
                /* use negotiated protocol */
                rContext->readerState.cardProtocol = ret;
 
                (void)pthread_mutex_unlock(rContext->mMutex);
            }
            else
            {
                (void)pthread_mutex_unlock(rContext->mMutex);
 
                if (! (dwPreferredProtocols & rContext->readerState.cardProtocol))
                {
                    rv = SCARD_E_PROTO_MISMATCH;
                    goto exit;
                }
            }
 
            /* the card is now in use */
            RFSetPowerState(rContext, POWER_STATE_IN_USE);
            Log1(PCSC_LOG_DEBUG, "powerState: POWER_STATE_IN_USE");
        }
    }
 
    *pdwActiveProtocol = rContext->readerState.cardProtocol;
 
    if (dwShareMode != SCARD_SHARE_DIRECT)
    {
        switch (*pdwActiveProtocol)
        {
            case SCARD_PROTOCOL_T0:
            case SCARD_PROTOCOL_T1:
                Log2(PCSC_LOG_DEBUG, "Active Protocol: T=%d",
                    (*pdwActiveProtocol == SCARD_PROTOCOL_T0) ? 0 : 1);
                break;
 
            case SCARD_PROTOCOL_RAW:
                Log1(PCSC_LOG_DEBUG, "Active Protocol: RAW");
                break;
 
            default:
                Log2(PCSC_LOG_ERROR, "Active Protocol: unknown %ld",
                    *pdwActiveProtocol);
        }
    }
    else
        Log1(PCSC_LOG_DEBUG, "Direct access: no protocol selected");
 
    if (dwShareMode == SCARD_SHARE_EXCLUSIVE)
    {
        if (rContext->contexts == PCSCLITE_SHARING_EXCLUSIVE_CONTEXT)
        {
            /*
             * Do nothing - we are already exclusive
             */
        }
        else
        {
            if (rContext->contexts == PCSCLITE_SHARING_LAST_CONTEXT)
            {
                rContext->contexts = PCSCLITE_SHARING_EXCLUSIVE_CONTEXT;
                (void)RFLockSharing(hCard, rContext);
            }
            else
            {
                rv = SCARD_E_SHARING_VIOLATION;
                goto exit;
            }
        }
    }
    else if (dwShareMode == SCARD_SHARE_SHARED)
    {
        if (rContext->contexts != PCSCLITE_SHARING_EXCLUSIVE_CONTEXT)
        {
            /*
             * Do nothing - in sharing mode already
             */
        }
        else
        {
            /*
             * We are in exclusive mode but want to share now
             */
            (void)RFUnlockSharing(hCard, rContext);
            rContext->contexts = PCSCLITE_SHARING_LAST_CONTEXT;
        }
    }
    else if (dwShareMode == SCARD_SHARE_DIRECT)
    {
        if (rContext->contexts != PCSCLITE_SHARING_EXCLUSIVE_CONTEXT)
        {
            /*
             * Do nothing - in sharing mode already
             */
        }
        else
        {
            /*
             * We are in exclusive mode but want to share now
             */
            (void)RFUnlockSharing(hCard, rContext);
            rContext->contexts = PCSCLITE_SHARING_LAST_CONTEXT;
        }
    }
    else
    {
        rv = SCARD_E_INVALID_VALUE;
        goto exit;
    }
 
    /*
     * Clear a previous event to the application
     */
    (void)RFClearReaderEventState(rContext, hCard);
 
    /*
     * Propagate new state to reader state
     */
    rContext->readerState.readerSharing = rContext->contexts;
 
    rv = SCARD_S_SUCCESS;
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
 
    if (hCard == 0)
        return SCARD_E_INVALID_HANDLE;
 
    if ((dwDisposition != SCARD_LEAVE_CARD)
        && (dwDisposition != SCARD_UNPOWER_CARD)
        && (dwDisposition != SCARD_RESET_CARD)
        && (dwDisposition != SCARD_EJECT_CARD))
        return SCARD_E_INVALID_VALUE;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    /* ignore reader removal */
    if (SCARD_E_INVALID_VALUE == rv || SCARD_E_READER_UNAVAILABLE == rv)
        return SCARD_S_SUCCESS;
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * wait until a possible transaction is finished
     */
    if ((dwDisposition != SCARD_LEAVE_CARD) && (rContext->hLockId != 0)
        && (rContext->hLockId != hCard))
    {
        Log1(PCSC_LOG_INFO, "Waiting for release of lock");
        while (rContext->hLockId != 0)
            (void)SYS_USleep(PCSCLITE_LOCK_POLL_RATE);
        Log1(PCSC_LOG_INFO, "Lock released");
    }
 
    /*
     * Try to unlock any blocks on this context
     *
     * This may fail with SCARD_E_SHARING_VIOLATION if a transaction is
     * on going on another card context and dwDisposition == SCARD_LEAVE_CARD.
     * We should not stop.
     */
    rv = RFUnlockAllSharing(hCard, rContext);
    if (rv != SCARD_S_SUCCESS)
    {
        if (rv != SCARD_E_SHARING_VIOLATION)
        {
            goto exit;
        }
        else
        {
            if (SCARD_LEAVE_CARD != dwDisposition)
                goto exit;
        }
    }
 
    Log2(PCSC_LOG_DEBUG, "Active Contexts: %d", rContext->contexts);
    Log2(PCSC_LOG_DEBUG, "dwDisposition: %ld", dwDisposition);
 
    if (dwDisposition == SCARD_RESET_CARD ||
        dwDisposition == SCARD_UNPOWER_CARD)
    {
        DWORD dwAtrLen;
 
        /*
         * Notify the card has been reset
         */
        RFSetReaderEventState(rContext, SCARD_RESET);
 
        dwAtrLen = sizeof(rContext->readerState.cardAtr);
        if (SCARD_RESET_CARD == dwDisposition)
            rv = IFDPowerICC(rContext, IFD_RESET,
                rContext->readerState.cardAtr, &dwAtrLen);
        else
        {
            /* SCARD_UNPOWER_CARD */
            rv = IFDPowerICC(rContext, IFD_POWER_DOWN, NULL, NULL);
 
            RFSetPowerState(rContext, POWER_STATE_UNPOWERED);
            Log1(PCSC_LOG_DEBUG, "powerState: POWER_STATE_UNPOWERED");
        }
 
        /* the protocol is unset after a power on */
        rContext->readerState.cardProtocol = SCARD_PROTOCOL_UNDEFINED;
 
        if (rv == IFD_SUCCESS)
        {
            if (SCARD_UNPOWER_CARD == dwDisposition)
                rContext->readerState.readerState = SCARD_PRESENT;
            else
            {
                rContext->readerState.cardAtrLength = dwAtrLen;
                rContext->readerState.readerState =
                    SCARD_PRESENT | SCARD_POWERED | SCARD_NEGOTIABLE;
 
                Log1(PCSC_LOG_DEBUG, "Reset complete.");
                LogXxd(PCSC_LOG_DEBUG, "Card ATR: ",
                    rContext->readerState.cardAtr,
                    rContext->readerState.cardAtrLength);
            }
        }
        else
        {
            if (SCARD_UNPOWER_CARD == dwDisposition)
                Log2(PCSC_LOG_ERROR, "Error powering down card: %s",
                    rv2text(rv));
            else
            {
                rContext->readerState.cardAtrLength = 0;
                Log1(PCSC_LOG_ERROR, "Error resetting card.");
            }
 
            if (rv == SCARD_W_REMOVED_CARD)
                rContext->readerState.readerState = SCARD_ABSENT;
            else
                rContext->readerState.readerState =
                    SCARD_PRESENT | SCARD_SWALLOWED;
        }
    }
    else if (dwDisposition == SCARD_EJECT_CARD)
    {
        UCHAR controlBuffer[5];
        UCHAR receiveBuffer[MAX_BUFFER_SIZE] = { 0 };
        DWORD receiveLength;
 
        /*
         * Set up the CTBCS command for Eject ICC
         */
        controlBuffer[0] = 0x20;
        controlBuffer[1] = 0x15;
        controlBuffer[2] = (rContext->slot & 0x0000FFFF) + 1;
        controlBuffer[3] = 0x00;
        controlBuffer[4] = 0x00;
        receiveLength = 2;
        rv = IFDControl_v2(rContext, controlBuffer, 5, receiveBuffer,
            &receiveLength);
 
        if (rv == SCARD_S_SUCCESS)
        {
            if (receiveLength == 2 && receiveBuffer[0] == 0x90)
            {
                Log1(PCSC_LOG_DEBUG, "Card ejected successfully.");
                /*
                 * Successful
                 */
            }
            else
                Log1(PCSC_LOG_ERROR, "Error ejecting card.");
        }
        else
            Log1(PCSC_LOG_ERROR, "Error ejecting card.");
 
    }
    else if (dwDisposition == SCARD_LEAVE_CARD)
    {
        /*
         * Do nothing
         */
    }
 
    /*
     * Remove and destroy this handle
     */
    (void)RFRemoveReaderHandle(rContext, hCard);
 
    /*
     * For exclusive connection reset it to no connections
     */
    if (rContext->contexts == PCSCLITE_SHARING_EXCLUSIVE_CONTEXT)
        rContext->contexts = PCSCLITE_SHARING_NO_CONTEXT;
    else
    {
        /*
         * Remove a connection from the context stack
         */
        rContext->contexts -= 1;
 
        if (rContext->contexts < 0)
            rContext->contexts = 0;
    }
 
    if (PCSCLITE_SHARING_NO_CONTEXT == rContext->contexts)
    {
        RESPONSECODE (*fct)(DWORD) = NULL;
        DWORD dwGetSize;
 
        (void)pthread_mutex_lock(&rContext->powerState_lock);
        /* Switch to POWER_STATE_GRACE_PERIOD unless the card was not
         * powered */
        if (POWER_STATE_POWERED <= rContext->powerState)
        {
            rContext->powerState = POWER_STATE_GRACE_PERIOD;
            Log1(PCSC_LOG_DEBUG, "powerState: POWER_STATE_GRACE_PERIOD");
        }
 
        (void)pthread_mutex_unlock(&rContext->powerState_lock);
 
        /* ask to stop the "polling" thread so it can be restarted using
         * the correct timeout */
        dwGetSize = sizeof(fct);
        rv = IFDGetCapabilities(rContext, TAG_IFD_STOP_POLLING_THREAD,
            &dwGetSize, (PUCHAR)&fct);
 
        if ((IFD_SUCCESS == rv) && (dwGetSize == sizeof(fct)))
        {
            Log1(PCSC_LOG_INFO, "Stopping polling thread");
            fct(rContext->slot);
        }
    }
 
    /*
     * Propagate new state to reader state
     */
    rContext->readerState.readerSharing = rContext->contexts;
 
    rv = SCARD_S_SUCCESS;
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardBeginTransaction(SCARDHANDLE hCard)
{
    LONG rv;
    READER_CONTEXT * rContext;
 
    if (hCard == 0)
        return SCARD_E_INVALID_HANDLE;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure some event has not occurred
     */
    rv = RFCheckReaderEventState(rContext, hCard);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    rv = RFLockSharing(hCard, rContext);
 
    /* if the transaction is not yet ready we sleep a bit so the client
     * do not retry immediately */
    if (SCARD_E_SHARING_VIOLATION == rv)
        (void)SYS_USleep(PCSCLITE_LOCK_POLL_RATE);
 
    Log2(PCSC_LOG_DEBUG, "Status: %s", rv2text(rv));
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition)
{
    LONG rv;
    LONG rv2;
    READER_CONTEXT * rContext = NULL;
 
    /*
     * Ignoring dwDisposition for now
     */
    if (hCard == 0)
        return SCARD_E_INVALID_HANDLE;
 
    if ((dwDisposition != SCARD_LEAVE_CARD)
        && (dwDisposition != SCARD_UNPOWER_CARD)
        && (dwDisposition != SCARD_RESET_CARD)
        && (dwDisposition != SCARD_EJECT_CARD))
    return SCARD_E_INVALID_VALUE;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure some event has not occurred
     */
    rv = RFCheckReaderEventState(rContext, hCard);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Error if another transaction is ongoing and a card action is
     * requested
     */
    if ((dwDisposition != SCARD_LEAVE_CARD) && (rContext->hLockId != 0)
        && (rContext->hLockId != hCard))
    {
        Log1(PCSC_LOG_INFO, "No card reset within a transaction");
        rv = SCARD_E_SHARING_VIOLATION;
        goto exit;
    }
 
    if (dwDisposition == SCARD_RESET_CARD ||
        dwDisposition == SCARD_UNPOWER_CARD)
    {
        DWORD dwAtrLen;
 
        dwAtrLen = sizeof(rContext->readerState.cardAtr);
        if (SCARD_RESET_CARD == dwDisposition)
            rv = IFDPowerICC(rContext, IFD_RESET,
                rContext->readerState.cardAtr, &dwAtrLen);
        else
        {
            IFDPowerICC(rContext, IFD_POWER_DOWN, NULL, NULL);
            rv = IFDPowerICC(rContext, IFD_POWER_UP,
                rContext->readerState.cardAtr, &dwAtrLen);
        }
 
        /* the protocol is unset after a power on */
        rContext->readerState.cardProtocol = SCARD_PROTOCOL_UNDEFINED;
 
        /*
         * Notify the card has been reset
         */
        RFSetReaderEventState(rContext, SCARD_RESET);
 
        /*
         * Set up the status bit masks on readerState
         */
        if (rv == IFD_SUCCESS)
        {
            rContext->readerState.cardAtrLength = dwAtrLen;
            rContext->readerState.readerState =
                SCARD_PRESENT | SCARD_POWERED | SCARD_NEGOTIABLE;
 
            Log1(PCSC_LOG_DEBUG, "Reset complete.");
            LogXxd(PCSC_LOG_DEBUG, "Card ATR: ",
                rContext->readerState.cardAtr,
                rContext->readerState.cardAtrLength);
        }
        else
        {
            rContext->readerState.cardAtrLength = 0;
            Log1(PCSC_LOG_ERROR, "Error resetting card.");
 
            if (rv == SCARD_W_REMOVED_CARD)
                rContext->readerState.readerState = SCARD_ABSENT;
            else
                rContext->readerState.readerState =
                    SCARD_PRESENT | SCARD_SWALLOWED;
        }
    }
    else if (dwDisposition == SCARD_EJECT_CARD)
    {
        UCHAR controlBuffer[5];
        UCHAR receiveBuffer[MAX_BUFFER_SIZE];
        DWORD receiveLength;
 
        /*
         * Set up the CTBCS command for Eject ICC
         */
        controlBuffer[0] = 0x20;
        controlBuffer[1] = 0x15;
        controlBuffer[2] = (rContext->slot & 0x0000FFFF) + 1;
        controlBuffer[3] = 0x00;
        controlBuffer[4] = 0x00;
        receiveLength = 2;
        rv = IFDControl_v2(rContext, controlBuffer, 5, receiveBuffer,
            &receiveLength);
 
        if (rv == SCARD_S_SUCCESS)
        {
            if (receiveLength == 2 && receiveBuffer[0] == 0x90)
            {
                Log1(PCSC_LOG_DEBUG, "Card ejected successfully.");
                /*
                 * Successful
                 */
            }
            else
                Log1(PCSC_LOG_ERROR, "Error ejecting card.");
        }
        else
            Log1(PCSC_LOG_ERROR, "Error ejecting card.");
 
    }
    else if (dwDisposition == SCARD_LEAVE_CARD)
    {
        /*
         * Do nothing
         */
    }
 
    /*
     * Unlock any blocks on this context
     */
    /* we do not want to lose the previous rv value
     * So we use another variable */
    rv2 = RFUnlockSharing(hCard, rContext);
    if (rv2 != SCARD_S_SUCCESS)
        /* if rv is already in error then do not change its value */
        if (rv == SCARD_S_SUCCESS)
            rv = rv2;
 
    Log2(PCSC_LOG_DEBUG, "Status: %s", rv2text(rv));
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardStatus(SCARDHANDLE hCard, LPSTR szReaderNames,
    LPDWORD pcchReaderLen, LPDWORD pdwState,
    LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
 
    /* These parameters are not used by the client
     * Client side code uses readerStates[] instead */
    (void)szReaderNames;
    (void)pcchReaderLen;
    (void)pdwState;
    (void)pdwProtocol;
    (void)pbAtr;
    (void)pcbAtrLen;
 
    if (hCard == 0)
        return SCARD_E_INVALID_HANDLE;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure no one has a lock on this reader
     */
    rv = RFCheckSharing(hCard, rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    if (rContext->readerState.cardAtrLength > MAX_ATR_SIZE)
    {
        rv = SCARD_F_INTERNAL_ERROR;
        goto exit;
    }
 
    /*
     * This is a client side function however the server maintains the
     * list of events between applications so it must be passed through to
     * obtain this event if it has occurred
     */
 
    /*
     * Make sure some event has not occurred
     */
    rv = RFCheckReaderEventState(rContext, hCard);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardControl(SCARDHANDLE hCard, DWORD dwControlCode,
    LPCVOID pbSendBuffer, DWORD cbSendLength,
    LPVOID pbRecvBuffer, DWORD cbRecvLength, LPDWORD lpBytesReturned)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
 
    /* 0 bytes returned by default */
    *lpBytesReturned = 0;
 
    if (0 == hCard)
        return SCARD_E_INVALID_HANDLE;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure no one has a lock on this reader
     */
    rv = RFCheckSharing(hCard, rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    if (IFD_HVERSION_2_0 == rContext->version)
        if (NULL == pbSendBuffer || 0 == cbSendLength)
        {
            rv = SCARD_E_INVALID_PARAMETER;
            goto exit;
        }
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    if (IFD_HVERSION_2_0 == rContext->version)
    {
        /* we must wrap a API 3.0 client in an API 2.0 driver */
        *lpBytesReturned = cbRecvLength;
        rv = IFDControl_v2(rContext, (PUCHAR)pbSendBuffer,
            cbSendLength, pbRecvBuffer, lpBytesReturned);
    }
    else
        if (IFD_HVERSION_3_0 == rContext->version)
            rv = IFDControl(rContext, dwControlCode, pbSendBuffer,
                cbSendLength, pbRecvBuffer, cbRecvLength, lpBytesReturned);
        else
            rv = SCARD_E_UNSUPPORTED_FEATURE;
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId,
    LPBYTE pbAttr, LPDWORD pcbAttrLen)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
 
    if (0 == hCard)
        return SCARD_E_INVALID_HANDLE;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure no one has a lock on this reader
     */
    rv = RFCheckSharing(hCard, rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure some event has not occurred
     */
    rv = RFCheckReaderEventState(rContext, hCard);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    rv = IFDGetCapabilities(rContext, dwAttrId, pcbAttrLen, pbAttr);
    switch(rv)
    {
        case IFD_SUCCESS:
            rv = SCARD_S_SUCCESS;
            break;
        case IFD_ERROR_TAG:
            /* Special case SCARD_ATTR_DEVICE_FRIENDLY_NAME as it is better
             * implemented in pcscd (it knows the friendly name)
             */
            if ((SCARD_ATTR_DEVICE_FRIENDLY_NAME == dwAttrId)
                || (SCARD_ATTR_DEVICE_SYSTEM_NAME == dwAttrId))
            {
                unsigned int len = strlen(rContext->readerState.readerName)+1;
 
                if (len > *pcbAttrLen)
                    rv = SCARD_E_INSUFFICIENT_BUFFER;
                else
                {
                    strcpy((char *)pbAttr, rContext->readerState.readerName);
                    rv = SCARD_S_SUCCESS;
                }
                *pcbAttrLen = len;
            }
            else
                rv = SCARD_E_UNSUPPORTED_FEATURE;
            break;
        case IFD_ERROR_INSUFFICIENT_BUFFER:
            rv = SCARD_E_INSUFFICIENT_BUFFER;
            break;
        default:
            rv = SCARD_E_NOT_TRANSACTED;
    }
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId,
    LPCBYTE pbAttr, DWORD cbAttrLen)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
 
    if (0 == hCard)
        return SCARD_E_INVALID_HANDLE;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure no one has a lock on this reader
     */
    rv = RFCheckSharing(hCard, rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure some event has not occurred
     */
    rv = RFCheckReaderEventState(rContext, hCard);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    rv = IFDSetCapabilities(rContext, dwAttrId, cbAttrLen, (PUCHAR)pbAttr);
    if (rv == IFD_SUCCESS)
        rv = SCARD_S_SUCCESS;
    else
        if (rv == IFD_ERROR_TAG)
            rv = SCARD_E_UNSUPPORTED_FEATURE;
        else
            rv = SCARD_E_NOT_TRANSACTED;
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}
 
LONG SCardTransmit(SCARDHANDLE hCard, const SCARD_IO_REQUEST *pioSendPci,
    LPCBYTE pbSendBuffer, DWORD cbSendLength,
    SCARD_IO_REQUEST *pioRecvPci, LPBYTE pbRecvBuffer,
    LPDWORD pcbRecvLength)
{
    LONG rv;
    READER_CONTEXT * rContext = NULL;
    SCARD_IO_HEADER sSendPci, sRecvPci;
    DWORD dwRxLength, tempRxLength;
 
    dwRxLength = *pcbRecvLength;
    *pcbRecvLength = 0;
 
    if (hCard == 0)
        return SCARD_E_INVALID_HANDLE;
 
    /*
     * Must at least have 2 status words even for SCardControl
     */
    if (dwRxLength < 2)
        return SCARD_E_INSUFFICIENT_BUFFER;
 
    /* get rContext corresponding to hCard */
    rv = RFReaderInfoById(hCard, &rContext);
    if (rv != SCARD_S_SUCCESS)
        return rv;
 
    /*
     * Make sure no one has a lock on this reader
     */
    rv = RFCheckSharing(hCard, rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure the reader is working properly
     */
    rv = RFCheckReaderStatus(rContext);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Make sure some event has not occurred
     */
    rv = RFCheckReaderEventState(rContext, hCard);
    if (rv != SCARD_S_SUCCESS)
        goto exit;
 
    /*
     * Check for some common errors
     */
    if (pioSendPci->dwProtocol != SCARD_PROTOCOL_RAW)
    {
        if (rContext->readerState.readerState & SCARD_ABSENT)
        {
            rv = SCARD_E_NO_SMARTCARD;
            goto exit;
        }
    }
 
    if (pioSendPci->dwProtocol != SCARD_PROTOCOL_RAW)
    {
        if (pioSendPci->dwProtocol != SCARD_PROTOCOL_ANY_OLD)
        {
            if (pioSendPci->dwProtocol != rContext->readerState.cardProtocol)
            {
                rv = SCARD_E_PROTO_MISMATCH;
                goto exit;
            }
        }
    }
 
    /*
     * Quick fix: PC/SC starts at 1 for bit masking but the IFD_Handler
     * just wants 0 or 1
     */
 
    sSendPci.Protocol = 0; /* protocol T=0 by default */
 
    if (pioSendPci->dwProtocol == SCARD_PROTOCOL_T1)
    {
        sSendPci.Protocol = 1;
    } else if (pioSendPci->dwProtocol == SCARD_PROTOCOL_RAW)
    {
        /*
         * This is temporary ......
         */
        sSendPci.Protocol = SCARD_PROTOCOL_RAW;
    } else if (pioSendPci->dwProtocol == SCARD_PROTOCOL_ANY_OLD)
    {
      /* Fix by Amira (Athena) */
        unsigned long i;
        unsigned long prot = rContext->readerState.cardProtocol;
 
        for (i = 0 ; prot != 1 && i < 16; i++)
            prot >>= 1;
 
        sSendPci.Protocol = i;
    }
 
    sSendPci.Length = pioSendPci->cbPciLength;
 
    sRecvPci.Protocol = pioRecvPci->dwProtocol;
    sRecvPci.Length = pioRecvPci->cbPciLength;
 
    /* the protocol number is decoded a few lines above */
    Log2(PCSC_LOG_DEBUG, "Send Protocol: T=%ld", sSendPci.Protocol);
 
    tempRxLength = dwRxLength;
 
    if ((pioSendPci->dwProtocol == SCARD_PROTOCOL_RAW)
        && (rContext->version == IFD_HVERSION_2_0))
    {
        rv = IFDControl_v2(rContext, (PUCHAR) pbSendBuffer, cbSendLength,
            pbRecvBuffer, &dwRxLength);
    } else
    {
        rv = IFDTransmit(rContext, sSendPci, (PUCHAR) pbSendBuffer,
            cbSendLength, pbRecvBuffer, &dwRxLength, &sRecvPci);
    }
 
    pioRecvPci->dwProtocol = sRecvPci.Protocol;
    pioRecvPci->cbPciLength = sRecvPci.Length;
 
    /*
     * Check for any errors that might have occurred
     */
 
    if (rv != SCARD_S_SUCCESS)
    {
        *pcbRecvLength = 0;
        Log2(PCSC_LOG_ERROR, "Card not transacted: %s", rv2text(rv));
 
        if (SCARD_E_NO_SMARTCARD == rv)
        {
            rContext->readerState.cardAtrLength = 0;
            rContext->readerState.cardProtocol = SCARD_PROTOCOL_UNDEFINED;
            rContext->readerState.readerState = SCARD_ABSENT;
        }
 
        goto exit;
    }
 
    /*
     * Available is less than received
     */
    if (tempRxLength < dwRxLength)
    {
        *pcbRecvLength = 0;
        rv = SCARD_E_INSUFFICIENT_BUFFER;
        goto exit;
    }
 
    /*
     * Successful return
     */
    *pcbRecvLength = dwRxLength;
 
exit:
    UNREF_READER(rContext)
 
    return rv;
}