winscard_clnt.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) 2003-2004
 *  Damien Sauveron <damien.sauveron@labri.fr>
 * Copyright (C) 2005
 *  Martin Paljak <martin@paljak.pri.ee>
 * Copyright (C) 2002-2025
 *  Ludovic Rousseau <ludovic.rousseau@free.fr>
 * Copyright (C) 2009
 *  Jean-Luc Giraud <jlgiraud@googlemail.com>
 *
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 <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/un.h>
#include <errno.h>
#include <stddef.h>
#include <sys/time.h>
#include <pthread.h>
#include <sys/wait.h>
#include <stdbool.h>

#include "misc.h"
#include "pcscd.h"
#include "winscard.h"
#include "debuglog.h"

#include "eventhandler.h"
#include "sys_generic.h"
#include "winscard_msg.h"
#include "utils.h"

/* Display, on stderr, a trace of the WinSCard calls with arguments and
 * results */
//#define DO_TRACE

/* Profile the execution time of WinSCard calls */
//#define DO_PROFILE


static bool sharing_shall_block = true;
static int Protocol_version;

#define COLOR_RED "\33[01;31m"
#define COLOR_GREEN "\33[32m"
#define COLOR_BLUE "\33[34m"
#define COLOR_MAGENTA "\33[35m"
#define COLOR_NORMAL "\33[0m"

#ifdef DO_TRACE

#include <stdio.h>
#include <stdarg.h>

static void trace(const char *func, const char direction, const char *fmt, ...)
{
    va_list args;

    fprintf(stderr, COLOR_GREEN "%c " COLOR_BLUE "[%lX] " COLOR_GREEN "%s ",
        direction, pthread_self(), func);

    fprintf(stderr, COLOR_MAGENTA);
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);

    fprintf(stderr, COLOR_NORMAL "\n");
}

#define API_TRACE_IN(...) trace(__FUNCTION__, '<', __VA_ARGS__);
#define API_TRACE_OUT(...) trace(__FUNCTION__, '>', __VA_ARGS__);
#else
#define API_TRACE_IN(...)
#define API_TRACE_OUT(...)
#endif

#ifdef DO_PROFILE

#define PROFILE_FILE "/tmp/pcsc_profile"
#include <stdio.h>
#include <sys/time.h>

/* we can profile a maximum of 5 simultaneous calls */
#define MAX_THREADS 5
pthread_t threads[MAX_THREADS];
struct timeval profile_time_start[MAX_THREADS];
FILE *profile_fd;
bool profile_tty;

#define PROFILE_START profile_start();
#define PROFILE_END(rv) profile_end(__FUNCTION__, rv);

static void profile_start(void)
{
    static bool initialized = false;
    pthread_t t;
    int i;

    if (!initialized)
    {
        char filename[80];

        initialized = true;
        sprintf(filename, "%s-%d", PROFILE_FILE, getuid());
        profile_fd = fopen(filename, "a+");
        if (NULL == profile_fd)
        {
            fprintf(stderr, COLOR_RED "Can't open %s: %s" COLOR_NORMAL "\n",
                PROFILE_FILE, strerror(errno));
            exit(-1);
        }
        fprintf(profile_fd, "\nStart a new profile\n");

        if (isatty(fileno(stderr)))
            profile_tty = true;
        else
            profile_tty = false;
    }

    t = pthread_self();
    for (i=0; i<MAX_THREADS; i++)
        if (pthread_equal(0, threads[i]))
        {
            threads[i] = t;
            break;
        }

    gettimeofday(&profile_time_start[i], NULL);
} /* profile_start */

static void profile_end(const char *f, LONG rv)
{
    struct timeval profile_time_end;
    long d;
    pthread_t t;
    int i;

    gettimeofday(&profile_time_end, NULL);

    t = pthread_self();
    for (i=0; i<MAX_THREADS; i++)
        if (pthread_equal(t, threads[i]))
            break;

    if (i>=MAX_THREADS)
    {
        fprintf(stderr, COLOR_BLUE " WARNING: no start info for %s\n", f);
        return;
    }

    d = time_sub(&profile_time_end, &profile_time_start[i]);

    /* free this entry */
    threads[i] = 0;

    if (profile_tty)
    {
        fprintf(stderr,
            COLOR_RED "RESULT %s " COLOR_MAGENTA "%ld "
            COLOR_BLUE "0x%08lX" COLOR_NORMAL "\n",
            f, d, rv);
    }
    fprintf(profile_fd, "%s %ld\n", f, d);
    fflush(profile_fd);
} /* profile_end */

#else
#define PROFILE_START
#define PROFILE_END(rv)
#endif

struct _psChannelMap
{
    SCARDHANDLE hCard;
    LPSTR readerName;
};

typedef struct _psChannelMap CHANNEL_MAP;

static int CHANNEL_MAP_seeker(const void *el, const void *key)
{
    const CHANNEL_MAP * channelMap = el;

    if ((el == NULL) || (key == NULL))
    {
        Log3(PCSC_LOG_CRITICAL,
            "CHANNEL_MAP_seeker called with NULL pointer: el=%p, key=%p",
            el, key);
        return 0;
    }

    if (channelMap->hCard == *(SCARDHANDLE *)key)
        return 1;

    return 0;
}

struct _psContextMap
{
    DWORD dwClientID;               
    SCARDCONTEXT hContext;          
    pthread_mutex_t mMutex;         
    list_t channelMapList;
    bool cancellable;               
};
typedef struct _psContextMap SCONTEXTMAP;

static list_t contextMapList;
pthread_mutex_t contextMapList_lock;    
static int SCONTEXTMAP_seeker(const void *el, const void *key)
{
    const SCONTEXTMAP * contextMap = el;

    if ((el == NULL) || (key == NULL))
    {
        Log3(PCSC_LOG_CRITICAL,
            "SCONTEXTMAP_seeker called with NULL pointer: el=%p, key=%p",
            el, key);
        return 0;
    }

    if (contextMap->hContext == *(SCARDCONTEXT *) key)
        return 1;

    return 0;
}

static bool isExecuted = false;
static pthread_once_t init_lib_control = PTHREAD_ONCE_INIT;


static pthread_mutex_t clientMutex = PTHREAD_MUTEX_INITIALIZER;

int pcsclite_max_reader_context = 0;
static READER_STATE * readerStates = NULL;
static pthread_mutex_t readerStatesMutex = PTHREAD_MUTEX_INITIALIZER;


static LONG SCardAddContext(SCARDCONTEXT, DWORD);
static SCONTEXTMAP * SCardGetAndLockContext(SCARDCONTEXT);
static SCONTEXTMAP * SCardGetContextTH(SCARDCONTEXT);
static void SCardRemoveContext(SCARDCONTEXT);
static void SCardCleanContext(SCONTEXTMAP *);

static LONG SCardAddHandle(SCARDHANDLE, SCONTEXTMAP *, LPCSTR);
static LONG SCardGetContextChannelAndLockFromHandle(SCARDHANDLE,
    /*@out@*/ SCONTEXTMAP * *, /*@out@*/ CHANNEL_MAP * *);
static LONG SCardGetContextAndChannelFromHandleTH(SCARDHANDLE,
    /*@out@*/ SCONTEXTMAP * *, /*@out@*/ CHANNEL_MAP * *);
static void SCardRemoveHandle(SCARDHANDLE);

static LONG SCardGetSetAttrib(SCARDHANDLE hCard, int command, DWORD dwAttrId,
    LPBYTE pbAttr, LPDWORD pcbAttrLen);

static LONG getReaderEvents(SCONTEXTMAP * currentContextMap, int *readerEvents);
static LONG getReaderStates(SCONTEXTMAP * currentContextMap);
static LONG getReaderStatesAndRegisterForEvents(SCONTEXTMAP * currentContextMap);
static LONG unregisterFromEvents(SCONTEXTMAP * currentContextMap);

/*
 * Thread safety functions
 */
inline static void SCardLockThread(void)
{
    pthread_mutex_lock(&clientMutex);
}

inline static void SCardUnlockThread(void)
{
    pthread_mutex_unlock(&clientMutex);
}

static bool SCardGetContextValidity(SCARDCONTEXT hContext)
{
    SCONTEXTMAP * currentContextMap;

    SCardLockThread();
    currentContextMap = SCardGetContextTH(hContext);
    SCardUnlockThread();

    return currentContextMap != NULL;
}

static LONG SCardEstablishContextTH(DWORD, LPCVOID, LPCVOID,
    /*@out@*/ LPSCARDCONTEXT);

LONG SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1,
    LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
{
    LONG rv;

    API_TRACE_IN("%ld, %p, %p", dwScope, pvReserved1, pvReserved2)
    PROFILE_START

    /* Check if the server is running */
    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        goto end;

    SCardLockThread();
    rv = SCardEstablishContextTH(dwScope, pvReserved1,
        pvReserved2, phContext);
    SCardUnlockThread();

end:
    PROFILE_END(rv)
    API_TRACE_OUT("%ld", *phContext)

    return rv;
}

#ifdef DESTRUCTOR
DESTRUCTOR static void destructor(void)
{
    (void)pthread_mutex_lock(&contextMapList_lock);
    list_destroy(&contextMapList);
    (void)pthread_mutex_unlock(&contextMapList_lock);

    (void)pthread_mutex_destroy(&contextMapList_lock);
}
#endif

/*
 * Do this only once:
 * - Initialize context list.
 */
static void init_lib(void)
{
    int lrv;

    /* NOTE: The list will be freed only if DESTRUCTOR is defined.
     * Applications which load and unload the library may leak
     * the list's internal structures. */
    lrv = list_init(&contextMapList);
    if (lrv < 0)
    {
        Log2(PCSC_LOG_CRITICAL, "list_init failed with return value: %d",
            lrv);
        return;
    }

    lrv = list_attributes_seeker(&contextMapList,
            SCONTEXTMAP_seeker);
    if (lrv <0)
    {
        Log2(PCSC_LOG_CRITICAL,
            "list_attributes_seeker failed with return value: %d", lrv);
        list_destroy(&contextMapList);
        return;
    }

    if (SYS_GetEnv("PCSCLITE_NO_BLOCKING"))
    {
        Log1(PCSC_LOG_INFO, "Disable shared blocking");
        sharing_shall_block = false;
    }

    (void)pthread_mutex_init(&contextMapList_lock, NULL);

    isExecuted = true;
}

static LONG SCardEstablishContextTH(DWORD dwScope,
    /*@unused@*/ LPCVOID pvReserved1,
    /*@unused@*/ LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
{
    LONG rv;
    struct establish_struct scEstablishStruct;
    uint32_t dwClientID = 0;
    struct version_struct veStr;

    (void)pvReserved1;
    (void)pvReserved2;
    if (phContext == NULL)
        return SCARD_E_INVALID_PARAMETER;
    else
        *phContext = 0;

    pthread_once(&init_lib_control, init_lib);
    if (!isExecuted)
        return SCARD_E_NO_MEMORY;

    /* Establishes a connection to the server */
    if (ClientSetupSession(&dwClientID) != 0)
    {
        return SCARD_E_NO_SERVICE;
    }

    veStr.major = PROTOCOL_VERSION_MAJOR;
    veStr.minor = PROTOCOL_VERSION_MINOR;

connect_again:
    /* exchange client/server protocol versions */

    veStr.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(CMD_VERSION, dwClientID, sizeof(veStr),
            &veStr);
    if (rv != SCARD_S_SUCCESS)
        goto cleanup;

    /* Read a message from the server */
    rv = MessageReceive(&veStr, sizeof(veStr), dwClientID);
    if (rv != SCARD_S_SUCCESS)
    {
        Log1(PCSC_LOG_CRITICAL,
                "Your pcscd is too old and does not support CMD_VERSION");
        goto cleanup;
    }

    Log3(PCSC_LOG_INFO, "Server is protocol version %d:%d",
            veStr.major, veStr.minor);
    Log3(PCSC_LOG_INFO, "Client is protocol version %d:%d",
            PROTOCOL_VERSION_MAJOR, PROTOCOL_VERSION_MINOR);

    if (SCARD_E_SERVICE_STOPPED == veStr.rv)
    {
        /* server complained about our protocol version? */
        if (PROTOCOL_VERSION_MAJOR == veStr.major)
        {
            if (PROTOCOL_VERSION_MINOR_CLIENT_BACKWARD <= veStr.minor)
            {
                /* try again with the protocol version proposed by
                 * the server */
                Log1(PCSC_LOG_INFO, "Using backward compatibility");
                goto connect_again;
            }
        }
    }

    if (veStr.rv != SCARD_S_SUCCESS)
    {
        rv = veStr.rv;
        goto cleanup;
    }

    /* store protocol version of the server */
    Protocol_version = veStr.major * 1000 + veStr.minor;

again:
    /*
     * Try to establish an Application Context with the server
     */
    scEstablishStruct.dwScope = dwScope;
    scEstablishStruct.hContext = 0;
    scEstablishStruct.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(SCARD_ESTABLISH_CONTEXT, dwClientID,
        sizeof(scEstablishStruct), (void *) &scEstablishStruct);

    if (rv != SCARD_S_SUCCESS)
        goto cleanup;

    /*
     * Read the response from the server
     */
    rv = MessageReceive(&scEstablishStruct, sizeof(scEstablishStruct),
        dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto cleanup;

    if (scEstablishStruct.rv != SCARD_S_SUCCESS)
    {
        rv = scEstablishStruct.rv;
        goto cleanup;
    }

    /* check we do not reuse an existing hContext */
    if (NULL != SCardGetContextTH(scEstablishStruct.hContext))
        /* we do not need to release the allocated context since
         * SCardReleaseContext() does nothing on the server side */
        goto again;

    *phContext = scEstablishStruct.hContext;

    /*
     * Allocate the new hContext - if allocator full return an error
     */
    rv = SCardAddContext(*phContext, dwClientID);

    return rv;

cleanup:
    ClientCloseSession(dwClientID);

    return rv;
}

LONG SCardReleaseContext(SCARDCONTEXT hContext)
{
    LONG rv;
    struct release_struct scReleaseStruct;
    SCONTEXTMAP * currentContextMap;

    API_TRACE_IN("%ld", hContext)
    PROFILE_START

    /*
     * Make sure this context has been opened
     * and get currentContextMap
     */
    currentContextMap = SCardGetAndLockContext(hContext);
    if (NULL == currentContextMap)
    {
        rv = SCARD_E_INVALID_HANDLE;
        goto error;
    }

    scReleaseStruct.hContext = hContext;
    scReleaseStruct.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(SCARD_RELEASE_CONTEXT,
        currentContextMap->dwClientID,
        sizeof(scReleaseStruct), (void *) &scReleaseStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scReleaseStruct, sizeof(scReleaseStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    rv = scReleaseStruct.rv;
end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    /*
     * Remove the local context from the stack
     */
    SCardLockThread();
    SCardRemoveContext(hContext);
    SCardUnlockThread();

error:
    PROFILE_END(rv)
    API_TRACE_OUT("")

    return rv;
}

LONG SCardConnect(SCARDCONTEXT hContext, LPCSTR szReader,
    DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
    LPDWORD pdwActiveProtocol)
{
    LONG rv;
    struct connect_struct scConnectStruct;
    SCONTEXTMAP * currentContextMap;

    PROFILE_START
    API_TRACE_IN("%ld %s %ld %ld", hContext, szReader, dwShareMode, dwPreferredProtocols)

    /*
     * Check for NULL parameters
     */
    if (phCard == NULL || pdwActiveProtocol == NULL)
        return SCARD_E_INVALID_PARAMETER;
    else
        *phCard = 0;

    if (szReader == NULL)
        return SCARD_E_UNKNOWN_READER;

    /*
     * Check for uninitialized strings
     */
    if (strlen(szReader) > MAX_READERNAME)
        return SCARD_E_INVALID_VALUE;

    /*
     * Make sure this context has been opened
     */
    currentContextMap = SCardGetAndLockContext(hContext);
    if (NULL == currentContextMap)
        return SCARD_E_INVALID_HANDLE;

    memset(scConnectStruct.szReader, 0, sizeof scConnectStruct.szReader);
    strncpy(scConnectStruct.szReader, szReader, sizeof scConnectStruct.szReader);
    scConnectStruct.szReader[sizeof scConnectStruct.szReader -1] = '\0';

    scConnectStruct.hContext = hContext;
    scConnectStruct.dwShareMode = dwShareMode;
    scConnectStruct.dwPreferredProtocols = dwPreferredProtocols;
    scConnectStruct.hCard = 0;
    scConnectStruct.dwActiveProtocol = 0;
    scConnectStruct.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(SCARD_CONNECT, currentContextMap->dwClientID,
        sizeof(scConnectStruct), (void *) &scConnectStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scConnectStruct, sizeof(scConnectStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    *phCard = scConnectStruct.hCard;
    *pdwActiveProtocol = scConnectStruct.dwActiveProtocol;

    if (scConnectStruct.rv == SCARD_S_SUCCESS)
    {
        /*
         * Keep track of the handle locally
         */
        rv = SCardAddHandle(*phCard, currentContextMap, szReader);
    }
    else
        rv = scConnectStruct.rv;

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    PROFILE_END(rv)
    API_TRACE_OUT("%d", *pdwActiveProtocol)

    return rv;
}

LONG SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,
    DWORD dwPreferredProtocols, DWORD dwInitialization,
    LPDWORD pdwActiveProtocol)
{
    LONG rv;
    struct reconnect_struct scReconnectStruct;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;

    PROFILE_START
    API_TRACE_IN("%ld %ld %ld", hCard, dwShareMode, dwPreferredProtocols)

    if (pdwActiveProtocol == NULL)
        return SCARD_E_INVALID_PARAMETER;

    /* Retry loop for blocking behaviour */
retry:

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
        &pChannelMap);
    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    scReconnectStruct.hCard = hCard;
    scReconnectStruct.dwShareMode = dwShareMode;
    scReconnectStruct.dwPreferredProtocols = dwPreferredProtocols;
    scReconnectStruct.dwInitialization = dwInitialization;
    scReconnectStruct.dwActiveProtocol = *pdwActiveProtocol;
    scReconnectStruct.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(SCARD_RECONNECT, currentContextMap->dwClientID,
        sizeof(scReconnectStruct), (void *) &scReconnectStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scReconnectStruct, sizeof(scReconnectStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    rv = scReconnectStruct.rv;

    if (sharing_shall_block && (SCARD_E_SHARING_VIOLATION == rv))
    {
        (void)pthread_mutex_unlock(&currentContextMap->mMutex);
        (void)SYS_USleep(PCSCLITE_LOCK_POLL_RATE);
        goto retry;
    }

    *pdwActiveProtocol = scReconnectStruct.dwActiveProtocol;

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    PROFILE_END(rv)
    API_TRACE_OUT("%ld", *pdwActiveProtocol)

    return rv;
}

LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
{
    LONG rv;
    struct disconnect_struct scDisconnectStruct;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;

    PROFILE_START
    API_TRACE_IN("%ld %ld", hCard, dwDisposition)

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
        &pChannelMap);
    if (rv == -1)
    {
        rv = SCARD_E_INVALID_HANDLE;
        goto error;
    }

    scDisconnectStruct.hCard = hCard;
    scDisconnectStruct.dwDisposition = dwDisposition;
    scDisconnectStruct.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(SCARD_DISCONNECT, currentContextMap->dwClientID,
        sizeof(scDisconnectStruct), (void *) &scDisconnectStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scDisconnectStruct, sizeof(scDisconnectStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    if (SCARD_S_SUCCESS == scDisconnectStruct.rv)
        SCardRemoveHandle(hCard);
    rv = scDisconnectStruct.rv;

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

error:
    PROFILE_END(rv)
    API_TRACE_OUT("")

    return rv;
}

LONG SCardBeginTransaction(SCARDHANDLE hCard)
{

    LONG rv;
    struct begin_struct scBeginStruct;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;

    PROFILE_START
    API_TRACE_IN("%ld", hCard)

    /*
     * Query the server every so often until the sharing violation ends
     * and then hold the lock for yourself.
     */

    for(;;)
    {
        /*
         * Make sure this handle has been opened
         */
        rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
            &pChannelMap);
        if (rv == -1)
            return SCARD_E_INVALID_HANDLE;

        scBeginStruct.hCard = hCard;
        scBeginStruct.rv = SCARD_S_SUCCESS;

        rv = MessageSendWithHeader(SCARD_BEGIN_TRANSACTION,
            currentContextMap->dwClientID,
            sizeof(scBeginStruct), (void *) &scBeginStruct);

        if (rv != SCARD_S_SUCCESS)
            break;

        /*
         * Read a message from the server
         */
        rv = MessageReceive(&scBeginStruct, sizeof(scBeginStruct),
            currentContextMap->dwClientID);

        if (rv != SCARD_S_SUCCESS)
            break;

        rv = scBeginStruct.rv;

        if (SCARD_E_SHARING_VIOLATION != rv)
            break;

        (void)pthread_mutex_unlock(&currentContextMap->mMutex);
        (void)SYS_USleep(PCSCLITE_LOCK_POLL_RATE);
    }

    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    PROFILE_END(rv)
    API_TRACE_OUT("")

    return rv;
}

LONG SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition)
{
    LONG rv;
    struct end_struct scEndStruct;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;

    PROFILE_START
    API_TRACE_IN("%ld", hCard)

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
        &pChannelMap);
    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    scEndStruct.hCard = hCard;
    scEndStruct.dwDisposition = dwDisposition;
    scEndStruct.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(SCARD_END_TRANSACTION,
        currentContextMap->dwClientID,
        sizeof(scEndStruct), (void *) &scEndStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scEndStruct, sizeof(scEndStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    rv = scEndStruct.rv;

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    PROFILE_END(rv)
    API_TRACE_OUT("")

    return rv;
}

LONG SCardStatus(SCARDHANDLE hCard, LPSTR szReaderName,
    LPDWORD pcchReaderLen, LPDWORD pdwState,
    LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
{
    DWORD dwReaderLen, dwAtrLen;
    LONG rv;
    int i;
    struct status_struct scStatusStruct;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;
    char *r;
    char *bufReader = NULL;
    LPBYTE bufAtr = NULL;
    DWORD dummy = 0;

    PROFILE_START

    /* default output values */
    if (pdwState)
        *pdwState = 0;

    if (pdwProtocol)
        *pdwProtocol = 0;

    /* Check for NULL parameters */
    if (pcchReaderLen == NULL)
        pcchReaderLen = &dummy;

    if (pcbAtrLen == NULL)
        pcbAtrLen = &dummy;

    /* length passed from caller */
    dwReaderLen = *pcchReaderLen;
    dwAtrLen = *pcbAtrLen;

    *pcchReaderLen = 0;
    *pcbAtrLen = 0;

    /* Retry loop for blocking behaviour */
retry:

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
        &pChannelMap);
    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    /* lock access to readerStates[] */
    (void)pthread_mutex_lock(&readerStatesMutex);

    /* synchronize reader states with daemon */
    rv = getReaderStates(currentContextMap);
    if (rv != SCARD_S_SUCCESS)
        goto end;

    r = pChannelMap->readerName;
    for (i = 0; i < pcsclite_max_reader_context; i++)
    {
        /* by default r == NULL */
        if (r && strcmp(r, readerStates[i].readerName) == 0)
            break;
    }

    if (i == pcsclite_max_reader_context)
    {
        rv = SCARD_E_READER_UNAVAILABLE;
        goto end;
    }

    /* initialise the structure */
    memset(&scStatusStruct, 0, sizeof(scStatusStruct));
    scStatusStruct.hCard = hCard;

    rv = MessageSendWithHeader(SCARD_STATUS, currentContextMap->dwClientID,
        sizeof(scStatusStruct), (void *) &scStatusStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scStatusStruct, sizeof(scStatusStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    rv = scStatusStruct.rv;

    if (sharing_shall_block && (SCARD_E_SHARING_VIOLATION == rv))
    {
        (void)pthread_mutex_unlock(&currentContextMap->mMutex);
        (void)pthread_mutex_unlock(&readerStatesMutex);
        (void)SYS_USleep(PCSCLITE_LOCK_POLL_RATE);
        goto retry;
    }

    if (rv != SCARD_S_SUCCESS && rv != SCARD_E_INSUFFICIENT_BUFFER)
    {
        /*
         * An event must have occurred
         */
        goto end;
    }

    /*
     * Now continue with the client side SCardStatus
     */

    *pcchReaderLen = strlen(pChannelMap->readerName) + 1;
    *pcbAtrLen = readerStates[i].cardAtrLength;

    if (pdwState)
        *pdwState = (readerStates[i].eventCounter << 16) + readerStates[i].readerState;

    if (pdwProtocol)
        *pdwProtocol = readerStates[i].cardProtocol;

    if (SCARD_AUTOALLOCATE == dwReaderLen)
    {
        dwReaderLen = *pcchReaderLen;
        if (NULL == szReaderName)
        {
            rv = SCARD_E_INVALID_PARAMETER;
            goto end;
        }
        bufReader = malloc(dwReaderLen);
        if (NULL == bufReader)
        {
            rv = SCARD_E_NO_MEMORY;
            goto end;
        }
        *(char **)szReaderName = bufReader;
    }
    else
        bufReader = szReaderName;

    /* return SCARD_E_INSUFFICIENT_BUFFER only if buffer pointer is non NULL */
    if (bufReader)
    {
        if (*pcchReaderLen > dwReaderLen)
            rv = SCARD_E_INSUFFICIENT_BUFFER;

        strncpy(bufReader, pChannelMap->readerName, dwReaderLen);
    }

    if (SCARD_AUTOALLOCATE == dwAtrLen)
    {
        dwAtrLen = *pcbAtrLen;
        if (NULL == pbAtr)
        {
            rv = SCARD_E_INVALID_PARAMETER;
            goto end;
        }
        bufAtr = malloc(dwAtrLen);
        if (NULL == bufAtr)
        {
            rv = SCARD_E_NO_MEMORY;
            goto end;
        }
        *(LPBYTE *)pbAtr = bufAtr;
    }
    else
        bufAtr = pbAtr;

    if (bufAtr)
    {
        if (*pcbAtrLen > dwAtrLen)
            rv = SCARD_E_INSUFFICIENT_BUFFER;

        memcpy(bufAtr, readerStates[i].cardAtr, min(*pcbAtrLen, dwAtrLen));
    }

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);
    (void)pthread_mutex_unlock(&readerStatesMutex);

    PROFILE_END(rv)

    return rv;
}

LONG SCardGetStatusChange(SCARDCONTEXT hContext, DWORD dwTimeout,
    SCARD_READERSTATE *rgReaderStates, DWORD cReaders)
{
    SCARD_READERSTATE *currReader;
    READER_STATE *rContext;
    long dwTime;
    DWORD dwBreakFlag = 0;
    unsigned int j;
    SCONTEXTMAP * currentContextMap;
    int currentReaderCount = 0;
    LONG rv = SCARD_S_SUCCESS;
    int pnp_reader = -1;

    PROFILE_START
    API_TRACE_IN("%ld %ld %d", hContext, dwTimeout, cReaders)
#ifdef DO_TRACE
    for (j=0; j<cReaders; j++)
    {
        API_TRACE_IN("[%d] %s %lX %lX (%d)", j, rgReaderStates[j].szReader,
            rgReaderStates[j].dwCurrentState, rgReaderStates[j].dwEventState,
            rgReaderStates[j].cbAtr)
    }
#endif

    if (rgReaderStates == NULL && cReaders > 0)
    {
        rv = SCARD_E_INVALID_PARAMETER;
        goto error;
    }

    /* Check the integrity of the reader states structures */
    for (j = 0; j < cReaders; j++)
    {
        if (rgReaderStates[j].szReader == NULL)
            return SCARD_E_INVALID_VALUE;
    }

    /* return if all readers are SCARD_STATE_IGNORE */
    if (cReaders > 0)
    {
        int nbNonIgnoredReaders = cReaders;

        for (j=0; j<cReaders; j++)
            if (rgReaderStates[j].dwCurrentState & SCARD_STATE_IGNORE)
                nbNonIgnoredReaders--;

        if (0 == nbNonIgnoredReaders)
        {
            rv = SCARD_S_SUCCESS;
            goto error;
        }
    }
    else
    {
        /* reader list is empty */
        rv = SCARD_S_SUCCESS;
        goto error;
    }

    /*
     * Make sure this context has been opened
     */
    currentContextMap = SCardGetAndLockContext(hContext);
    if (NULL == currentContextMap)
    {
        rv = SCARD_E_INVALID_HANDLE;
        goto error;
    }

    /* lock access to readerStates[] */
    (void)pthread_mutex_lock(&readerStatesMutex);

    /* synchronize reader states with daemon */
    rv = getReaderStatesAndRegisterForEvents(currentContextMap);

    if (rv != SCARD_S_SUCCESS)
    {
        (void)pthread_mutex_unlock(&readerStatesMutex);
        goto end;
    }

    /* check all the readers are already known */
    for (j=0; j<cReaders; j++)
    {
        const char *readerName;
        int i;

        readerName = rgReaderStates[j].szReader;
        for (i = 0; i < pcsclite_max_reader_context; i++)
        {
            if (strcmp(readerName, readerStates[i].readerName) == 0)
                break;
        }

        /* The requested reader name is not recognized */
        if (i == pcsclite_max_reader_context)
        {
            /* PnP special reader? */
            if (strcasecmp(readerName, "\\\\?PnP?\\Notification") != 0)
            {
                rv = SCARD_E_UNKNOWN_READER;
                (void)pthread_mutex_unlock(&readerStatesMutex);
                goto end;
            }
            else
                pnp_reader = j;
        }
    }
    (void)pthread_mutex_unlock(&readerStatesMutex);

    /* Clear the event state for all readers */
    for (j = 0; j < cReaders; j++)
        rgReaderStates[j].dwEventState = 0;

    /* Now is where we start our event checking loop */
    Log2(PCSC_LOG_DEBUG, "Event Loop Start, dwTimeout: %ld", dwTimeout);

    /* index of the PnP readerin rgReaderStates[] */
    if (pnp_reader >= 0)
    {
        int readerEvents;
        currReader = &rgReaderStates[pnp_reader];

        /* PnP special reader */
        if (SCARD_S_SUCCESS == getReaderEvents(currentContextMap, &readerEvents))
        {
            int previousReaderEvents = currReader->dwCurrentState >> 16;

            // store readerEvents in .dwEventState high word
            currReader->dwEventState = (currReader->dwEventState & 0xFFFF) + (readerEvents << 16);
            if (
                /* the value has changed since the last call */
                (previousReaderEvents != readerEvents)
                /* backward compatibility: only if we had a non-null
                 * reader events value */
                && previousReaderEvents)
            {
                currReader->dwEventState |= SCARD_STATE_CHANGED;
                rv = SCARD_S_SUCCESS;
                dwBreakFlag = 1;
            }
        }
    }

    /* Get the initial reader count on the system */
    for (int k=0; k < pcsclite_max_reader_context; k++)
        if (readerStates[k].readerName[0] != '\0')
            currentReaderCount++;

    /* catch possible sign extension problems from 32 to 64-bits integers */
    if ((DWORD)-1 == dwTimeout)
        dwTimeout = INFINITE;
    if (INFINITE == dwTimeout)
        dwTime = 60*1000;   /* "infinite" timeout */
    else
        dwTime = dwTimeout;

    j = 0;
    do
    {
        currReader = &rgReaderStates[j];

        /* Ignore for IGNORED readers */
        if (!(currReader->dwCurrentState & SCARD_STATE_IGNORE))
        {
            const char *readerName;
            int i;

            /* lock access to readerStates[] */
            (void)pthread_mutex_lock(&readerStatesMutex);

            /* Looks for correct readernames */
            readerName = currReader->szReader;
            for (i = 0; i < pcsclite_max_reader_context; i++)
            {
                if (strcmp(readerName, readerStates[i].readerName) == 0)
                    break;
            }

            /* The requested reader name is not recognized */
            if (i == pcsclite_max_reader_context)
            {
                /* PnP special reader? */
                if (strcasecmp(readerName, "\\\\?PnP?\\Notification") == 0)
                {
                    int k, newReaderCount = 0;

                    for (k=0; k < pcsclite_max_reader_context; k++)
                        if (readerStates[k].readerName[0] != '\0')
                            newReaderCount++;

                    if (newReaderCount != currentReaderCount)
                    {
                        int readerEvents;

                        Log1(PCSC_LOG_INFO, "Reader list changed");
                        currentReaderCount = newReaderCount;

                        if (SCARD_S_SUCCESS == getReaderEvents(currentContextMap, &readerEvents))
                        {
                            // store readerEvents in .dwEventState high word
                            currReader->dwEventState = (currReader->dwEventState & 0xFFFF) + (readerEvents << 16);
                        }

                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        dwBreakFlag = 1;
                    }
                }
                else
                {
                    currReader->dwEventState =
                        SCARD_STATE_UNKNOWN | SCARD_STATE_UNAVAILABLE;
                    if (!(currReader->dwCurrentState & SCARD_STATE_UNKNOWN))
                    {
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        /*
                         * Spec says use SCARD_STATE_IGNORE but a removed USB
                         * reader with eventState fed into currentState will
                         * be ignored forever
                         */
                        dwBreakFlag = 1;
                    }
                }
            }
            else
            {
                uint32_t readerState;

                /* The reader has come back after being away */
                if (currReader->dwCurrentState & SCARD_STATE_UNKNOWN)
                {
                    currReader->dwEventState |= SCARD_STATE_CHANGED;
                    currReader->dwEventState &= ~SCARD_STATE_UNKNOWN;
                    Log0(PCSC_LOG_DEBUG);
                    dwBreakFlag = 1;
                }

                /* Set the reader status structure */
                rContext = &readerStates[i];

                /* Now we check all the Reader States */
                readerState = rContext->readerState;

                /* only if current state has an non null event counter */
                if (currReader->dwCurrentState & 0xFFFF0000)
                {
                    unsigned int currentCounter;

                    currentCounter = (currReader->dwCurrentState >> 16) & 0xFFFF;

                    /* has the event counter changed since the last call? */
                    if (rContext->eventCounter != currentCounter)
                    {
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }
                }

                /* add an event counter in the upper word of dwEventState */
                currReader->dwEventState = ((currReader->dwEventState & 0xffff )
                    | (rContext->eventCounter << 16));

                /* Check if the reader is in the correct state */
                if (readerState & SCARD_UNKNOWN)
                {
                    /* reader is in bad state */
                    currReader->dwEventState = SCARD_STATE_UNAVAILABLE;
                    if (!(currReader->dwCurrentState & SCARD_STATE_UNAVAILABLE))
                    {
                        /* App thinks reader is in good state and it is not */
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }
                }
                else
                {
                    /* App thinks reader in bad state but it is not */
                    if (currReader-> dwCurrentState & SCARD_STATE_UNAVAILABLE)
                    {
                        currReader->dwEventState &= ~SCARD_STATE_UNAVAILABLE;
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }
                }

                /* Check for card presence in the reader */
                if (readerState & SCARD_PRESENT)
                {
#ifndef DISABLE_AUTO_POWER_ON
                    /* card present but not yet powered up */
                    if (0 == rContext->cardAtrLength)
                        /* Allow the status thread to convey information */
                        (void)SYS_USleep(PCSCLITE_STATUS_POLL_RATE + 10);
#endif

                    currReader->cbAtr = rContext->cardAtrLength;
                    memcpy(currReader->rgbAtr, rContext->cardAtr,
                        currReader->cbAtr);
                }
                else
                    currReader->cbAtr = 0;

                /* Card is now absent */
                if (readerState & SCARD_ABSENT)
                {
                    currReader->dwEventState |= SCARD_STATE_EMPTY;
                    currReader->dwEventState &= ~SCARD_STATE_PRESENT;
                    currReader->dwEventState &= ~SCARD_STATE_UNAWARE;
                    currReader->dwEventState &= ~SCARD_STATE_IGNORE;
                    currReader->dwEventState &= ~SCARD_STATE_UNKNOWN;
                    currReader->dwEventState &= ~SCARD_STATE_UNAVAILABLE;
                    currReader->dwEventState &= ~SCARD_STATE_ATRMATCH;
                    currReader->dwEventState &= ~SCARD_STATE_MUTE;
                    currReader->dwEventState &= ~SCARD_STATE_INUSE;

                    /* After present the rest are assumed */
                    if (currReader->dwCurrentState & SCARD_STATE_PRESENT)
                    {
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }
                }
                /* Card is now present */
                else if (readerState & SCARD_PRESENT)
                {
                    currReader->dwEventState |= SCARD_STATE_PRESENT;
                    currReader->dwEventState &= ~SCARD_STATE_EMPTY;
                    currReader->dwEventState &= ~SCARD_STATE_UNAWARE;
                    currReader->dwEventState &= ~SCARD_STATE_IGNORE;
                    currReader->dwEventState &= ~SCARD_STATE_UNKNOWN;
                    currReader->dwEventState &= ~SCARD_STATE_UNAVAILABLE;
                    currReader->dwEventState &= ~SCARD_STATE_MUTE;

                    if (currReader->dwCurrentState & SCARD_STATE_EMPTY)
                    {
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }

                    if (readerState & SCARD_SWALLOWED)
                    {
                        currReader->dwEventState |= SCARD_STATE_MUTE;
                        if (!(currReader->dwCurrentState & SCARD_STATE_MUTE))
                        {
                            currReader->dwEventState |= SCARD_STATE_CHANGED;
                            Log0(PCSC_LOG_DEBUG);
                            dwBreakFlag = 1;
                        }
                    }
                    else
                    {
                        /* App thinks card is mute but it is not */
                        if (currReader->dwCurrentState & SCARD_STATE_MUTE)
                        {
                            currReader->dwEventState |= SCARD_STATE_CHANGED;
                            Log0(PCSC_LOG_DEBUG);
                            dwBreakFlag = 1;
                        }
                    }
                }

                /* Now figure out sharing modes */
                if (rContext->readerSharing == PCSCLITE_SHARING_EXCLUSIVE_CONTEXT)
                {
                    currReader->dwEventState |= SCARD_STATE_EXCLUSIVE;
                    currReader->dwEventState &= ~SCARD_STATE_INUSE;
                    if (currReader->dwCurrentState & SCARD_STATE_INUSE)
                    {
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }
                }
                else if (rContext->readerSharing >= PCSCLITE_SHARING_LAST_CONTEXT)
                {
                    /* A card must be inserted for it to be INUSE */
                    if (readerState & SCARD_PRESENT)
                    {
                        currReader->dwEventState |= SCARD_STATE_INUSE;
                        currReader->dwEventState &= ~SCARD_STATE_EXCLUSIVE;
                        if (currReader-> dwCurrentState & SCARD_STATE_EXCLUSIVE)
                        {
                            currReader->dwEventState |= SCARD_STATE_CHANGED;
                            Log0(PCSC_LOG_DEBUG);
                            dwBreakFlag = 1;
                        }
                    }
                }
                else if (rContext->readerSharing == PCSCLITE_SHARING_NO_CONTEXT)
                {
                    currReader->dwEventState &= ~SCARD_STATE_INUSE;
                    currReader->dwEventState &= ~SCARD_STATE_EXCLUSIVE;

                    if (currReader->dwCurrentState & SCARD_STATE_INUSE)
                    {
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }
                    else if (currReader-> dwCurrentState
                        & SCARD_STATE_EXCLUSIVE)
                    {
                        currReader->dwEventState |= SCARD_STATE_CHANGED;
                        Log0(PCSC_LOG_DEBUG);
                        dwBreakFlag = 1;
                    }
                }

                if (currReader->dwCurrentState == SCARD_STATE_UNAWARE)
                {
                    /*
                     * Break out of the while .. loop and return status
                     * once all the status's for all readers is met
                     */
                    currReader->dwEventState |= SCARD_STATE_CHANGED;
                    Log0(PCSC_LOG_DEBUG);
                    dwBreakFlag = 1;
                }
            }   /* End of SCARD_STATE_UNKNOWN */

            (void)pthread_mutex_unlock(&readerStatesMutex);
        }   /* End of SCARD_STATE_IGNORE */

        /* Counter and resetter */
        j++;
        if (j == cReaders)
        {
            /* go back to the first reader */
            j = 0;

            /* Declare all the break conditions */

            /* Break if UNAWARE is set and all readers have been checked */
            if (dwBreakFlag == 1)
                break;

            /* Only sleep once for each cycle of reader checks. */
            {
                struct wait_reader_state_change waitStatusStruct = {0};
                struct timeval before, after;

                gettimeofday(&before, NULL);

                waitStatusStruct.rv = SCARD_S_SUCCESS;

                /* another thread can do SCardCancel() */
                currentContextMap->cancellable = true;

                /*
                 * Read a message from the server
                 */
                rv = MessageReceiveTimeout(CMD_WAIT_READER_STATE_CHANGE,
                    &waitStatusStruct, sizeof(waitStatusStruct),
                    currentContextMap->dwClientID, dwTime);

                /* SCardCancel() will return immediately with success
                 * because something changed on the daemon side. */
                currentContextMap->cancellable = false;

                /* timeout */
                if (SCARD_E_TIMEOUT == rv)
                {
                    /* ask server to remove us from the event list */
                    rv = unregisterFromEvents(currentContextMap);
                }

                if (rv != SCARD_S_SUCCESS)
                    goto end;

                /* an event occurs or SCardCancel() was called */
                if (SCARD_S_SUCCESS != waitStatusStruct.rv)
                {
                    rv = waitStatusStruct.rv;
                    goto end;
                }

                /* synchronize reader states with daemon */
                (void)pthread_mutex_lock(&readerStatesMutex);
                rv = getReaderStatesAndRegisterForEvents(currentContextMap);
                (void)pthread_mutex_unlock(&readerStatesMutex);
                if (rv != SCARD_S_SUCCESS)
                    goto end;

                if (INFINITE != dwTimeout)
                {
                    long int diff;

                    gettimeofday(&after, NULL);
                    diff = time_sub(&after, &before);
                    dwTime -= diff/1000;
                }
            }

            if (dwTimeout != INFINITE)
            {
                /* If time is greater than timeout and all readers have been
                 * checked
                 */
                if (dwTime <= 0)
                {
                    rv = SCARD_E_TIMEOUT;
                    goto end;
                }
            }
        }
    }
    while (1);

end:
    Log1(PCSC_LOG_DEBUG, "Event Loop End");

    /* if SCardCancel() has been used then the client is already
     * unregistered */
    if (SCARD_E_CANCELLED != rv)
        (void)unregisterFromEvents(currentContextMap);

    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

error:
    PROFILE_END(rv)
#ifdef DO_TRACE
    for (j=0; j<cReaders; j++)
    {
        API_TRACE_OUT("[%d] %s %lX %lX (%d)", j, rgReaderStates[j].szReader,
            rgReaderStates[j].dwCurrentState, rgReaderStates[j].dwEventState,
            rgReaderStates[j].cbAtr)
    }
#endif

    return rv;
}

LONG SCardControl(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID pbSendBuffer,
    DWORD cbSendLength, LPVOID pbRecvBuffer, DWORD cbRecvLength,
    LPDWORD lpBytesReturned)
{
    LONG rv;
    struct control_struct scControlStruct;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;

    PROFILE_START

    /* 0 bytes received by default */
    if (NULL != lpBytesReturned)
        *lpBytesReturned = 0;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
        &pChannelMap);
    if (rv == -1)
    {
        PROFILE_END(SCARD_E_INVALID_HANDLE)
        return SCARD_E_INVALID_HANDLE;
    }

    if (cbSendLength > MAX_BUFFER_SIZE_EXTENDED)
    {
        rv = SCARD_E_INSUFFICIENT_BUFFER;
        goto end;
    }

    scControlStruct.hCard = hCard;
    scControlStruct.dwControlCode = dwControlCode;
    scControlStruct.cbSendLength = cbSendLength;
    scControlStruct.cbRecvLength = cbRecvLength;
    scControlStruct.dwBytesReturned = 0;
    scControlStruct.rv = 0;

    rv = MessageSendWithHeader(SCARD_CONTROL, currentContextMap->dwClientID,
        sizeof(scControlStruct), &scControlStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /* write the sent buffer */
    rv = MessageSend((char *)pbSendBuffer, cbSendLength,
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scControlStruct, sizeof(scControlStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    if (SCARD_S_SUCCESS == scControlStruct.rv)
    {
        if (scControlStruct.dwBytesReturned > cbRecvLength)
        {
            if (NULL != lpBytesReturned)
                *lpBytesReturned = scControlStruct.dwBytesReturned;
            rv = SCARD_E_INSUFFICIENT_BUFFER;
            goto end;
        }

        /* read the received buffer */
        rv = MessageReceive(pbRecvBuffer, scControlStruct.dwBytesReturned,
            currentContextMap->dwClientID);

        if (rv != SCARD_S_SUCCESS)
            goto end;

    }

    if (NULL != lpBytesReturned)
        *lpBytesReturned = scControlStruct.dwBytesReturned;

    rv = scControlStruct.rv;

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    PROFILE_END(rv)

    return rv;
}

LONG SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr,
    LPDWORD pcbAttrLen)
{
    LONG ret;
    unsigned char *buf = NULL;

    PROFILE_START

    if (NULL == pcbAttrLen)
    {
        ret = SCARD_E_INVALID_PARAMETER;
        goto end;
    }

    if (SCARD_AUTOALLOCATE == *pcbAttrLen)
    {
        if (NULL == pbAttr)
            return SCARD_E_INVALID_PARAMETER;

        *pcbAttrLen = MAX_BUFFER_SIZE;
        buf = malloc(*pcbAttrLen);
        if (NULL == buf)
        {
            ret = SCARD_E_NO_MEMORY;
            goto end;
        }

        *(unsigned char **)pbAttr = buf;
    }
    else
    {
        buf = pbAttr;

        /* if only get the length */
        if (NULL == pbAttr)
            /* use a reasonable size */
            *pcbAttrLen = MAX_BUFFER_SIZE;
    }

    ret = SCardGetSetAttrib(hCard, SCARD_GET_ATTRIB, dwAttrId, buf,
        pcbAttrLen);

end:
    PROFILE_END(ret)

    return ret;
}

LONG SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr,
    DWORD cbAttrLen)
{
    LONG ret;

    PROFILE_START

    if (NULL == pbAttr || 0 == cbAttrLen)
        return SCARD_E_INVALID_PARAMETER;

    ret = SCardGetSetAttrib(hCard, SCARD_SET_ATTRIB, dwAttrId, (LPBYTE)pbAttr,
        &cbAttrLen);

    PROFILE_END(ret)

    return ret;
}

static LONG SCardGetSetAttrib(SCARDHANDLE hCard, int command, DWORD dwAttrId,
    LPBYTE pbAttr, LPDWORD pcbAttrLen)
{
    LONG rv;
    struct getset_struct scGetSetStruct;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
        &pChannelMap);
    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    if (*pcbAttrLen > MAX_BUFFER_SIZE)
    {
        rv = SCARD_E_INSUFFICIENT_BUFFER;
        goto end;
    }

    scGetSetStruct.hCard = hCard;
    scGetSetStruct.dwAttrId = dwAttrId;
    scGetSetStruct.rv = SCARD_E_NO_SERVICE;
    memset(scGetSetStruct.pbAttr, 0, sizeof(scGetSetStruct.pbAttr));
    if (SCARD_SET_ATTRIB == command)
    {
        memcpy(scGetSetStruct.pbAttr, pbAttr, *pcbAttrLen);
        scGetSetStruct.cbAttrLen = *pcbAttrLen;
    }
    else
        /* we can get up to the communication buffer size */
        scGetSetStruct.cbAttrLen = sizeof scGetSetStruct.pbAttr;

    rv = MessageSendWithHeader(command, currentContextMap->dwClientID,
        sizeof(scGetSetStruct), &scGetSetStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scGetSetStruct, sizeof(scGetSetStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    if ((SCARD_S_SUCCESS == scGetSetStruct.rv) && (SCARD_GET_ATTRIB == command))
    {
        /*
         * Copy and zero it so any secret information is not leaked
         */
        if (*pcbAttrLen < scGetSetStruct.cbAttrLen)
        {
            /* restrict the value of scGetSetStruct.cbAttrLen to avoid a
             * buffer overflow in the memcpy() below */
            DWORD correct_value = scGetSetStruct.cbAttrLen;
            scGetSetStruct.cbAttrLen = *pcbAttrLen;
            *pcbAttrLen = correct_value;

            scGetSetStruct.rv = SCARD_E_INSUFFICIENT_BUFFER;
        }
        else
            *pcbAttrLen = scGetSetStruct.cbAttrLen;

        if (pbAttr)
            memcpy(pbAttr, scGetSetStruct.pbAttr, scGetSetStruct.cbAttrLen);

        memset(scGetSetStruct.pbAttr, 0x00, sizeof(scGetSetStruct.pbAttr));
    }
    rv = scGetSetStruct.rv;

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    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;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * pChannelMap;
    struct transmit_struct scTransmitStruct;

    PROFILE_START

    if (pbSendBuffer == NULL || pbRecvBuffer == NULL ||
            pcbRecvLength == NULL || pioSendPci == NULL)
        return SCARD_E_INVALID_PARAMETER;

    /* Retry loop for blocking behaviour */
retry:

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetContextChannelAndLockFromHandle(hCard, &currentContextMap,
        &pChannelMap);
    if (rv == -1)
    {
        *pcbRecvLength = 0;
        PROFILE_END(SCARD_E_INVALID_HANDLE)
        return SCARD_E_INVALID_HANDLE;
    }

    if (cbSendLength > MAX_BUFFER_SIZE_EXTENDED)
    {
        rv = SCARD_E_INSUFFICIENT_BUFFER;
        goto end;
    }

    scTransmitStruct.hCard = hCard;
    scTransmitStruct.cbSendLength = cbSendLength;
    scTransmitStruct.pcbRecvLength = *pcbRecvLength;
    scTransmitStruct.ioSendPciProtocol = pioSendPci->dwProtocol;
    scTransmitStruct.ioSendPciLength = pioSendPci->cbPciLength;
    scTransmitStruct.rv = SCARD_S_SUCCESS;

    if (pioRecvPci)
    {
        scTransmitStruct.ioRecvPciProtocol = pioRecvPci->dwProtocol;
        scTransmitStruct.ioRecvPciLength = pioRecvPci->cbPciLength;
    }
    else
    {
        scTransmitStruct.ioRecvPciProtocol = SCARD_PROTOCOL_ANY;
        scTransmitStruct.ioRecvPciLength = sizeof(SCARD_IO_REQUEST);
    }

    rv = MessageSendWithHeader(SCARD_TRANSMIT, currentContextMap->dwClientID,
        sizeof(scTransmitStruct), (void *) &scTransmitStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /* write the sent buffer */
    rv = MessageSend((void *)pbSendBuffer, cbSendLength,
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scTransmitStruct, sizeof(scTransmitStruct),
        currentContextMap->dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    if (SCARD_S_SUCCESS == scTransmitStruct.rv)
    {
        if (scTransmitStruct.pcbRecvLength > *pcbRecvLength)
        {
            *pcbRecvLength = scTransmitStruct.pcbRecvLength;
            rv = SCARD_E_INSUFFICIENT_BUFFER;
            goto end;
        }

        /* read the received buffer */
        rv = MessageReceive(pbRecvBuffer, scTransmitStruct.pcbRecvLength,
            currentContextMap->dwClientID);

        if (rv != SCARD_S_SUCCESS)
            goto end;

        if (pioRecvPci)
        {
            pioRecvPci->dwProtocol = scTransmitStruct.ioRecvPciProtocol;
            pioRecvPci->cbPciLength = scTransmitStruct.ioRecvPciLength;
        }
    }

    rv = scTransmitStruct.rv;

    if (sharing_shall_block && (SCARD_E_SHARING_VIOLATION == rv))
    {
        (void)pthread_mutex_unlock(&currentContextMap->mMutex);
        (void)SYS_USleep(PCSCLITE_LOCK_POLL_RATE);
        goto retry;
    }

    *pcbRecvLength = scTransmitStruct.pcbRecvLength;

end:
    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    PROFILE_END(rv)

    return rv;
}

LONG SCardListReaders(SCARDCONTEXT hContext, /*@unused@*/ LPCSTR mszGroups,
    LPSTR mszReaders, LPDWORD pcchReaders)
{
    DWORD dwReadersLen = 0;
    int i;
    SCONTEXTMAP * currentContextMap;
    LONG rv = SCARD_S_SUCCESS;
    char *buf = NULL;

    (void)mszGroups;
    PROFILE_START
    API_TRACE_IN("%ld", hContext)

    /*
     * Check for NULL parameters
     */
    if (pcchReaders == NULL)
        return SCARD_E_INVALID_PARAMETER;

    /*
     * Make sure this context has been opened
     */
    currentContextMap = SCardGetAndLockContext(hContext);
    if (NULL == currentContextMap)
    {
        PROFILE_END(SCARD_E_INVALID_HANDLE)
        return SCARD_E_INVALID_HANDLE;
    }

    /* lock access to readerStates[] */
    (void)pthread_mutex_lock(&readerStatesMutex);

    /* synchronize reader states with daemon */
    rv = getReaderStates(currentContextMap);
    if (rv != SCARD_S_SUCCESS)
        goto end;

    dwReadersLen = 0;
    for (i = 0; i < pcsclite_max_reader_context; i++)
        if (readerStates[i].readerName[0] != '\0')
            dwReadersLen += strlen(readerStates[i].readerName) + 1;

    /* for the last NULL byte */
    dwReadersLen += 1;

    if (1 == dwReadersLen)
    {
        rv = SCARD_E_NO_READERS_AVAILABLE;
        goto end;
    }

    if (SCARD_AUTOALLOCATE == *pcchReaders)
    {
        if (NULL == mszReaders)
        {
            rv = SCARD_E_INVALID_PARAMETER;
            goto end;
        }
        buf = malloc(dwReadersLen);
        if (NULL == buf)
        {
            rv = SCARD_E_NO_MEMORY;
            goto end;
        }
        *(char **)mszReaders = buf;
    }
    else
    {
        buf = mszReaders;

        /* not enough place to store the reader names */
        if ((NULL != mszReaders) && (*pcchReaders < dwReadersLen))
        {
            rv = SCARD_E_INSUFFICIENT_BUFFER;
            goto end;
        }
    }

    if (mszReaders == NULL) /* text array not allocated */
        goto end;

    for (i = 0; i < pcsclite_max_reader_context; i++)
    {
        if (readerStates[i].readerName[0] != '\0')
        {
            /*
             * Build the multi-string
             */
            strcpy(buf, readerStates[i].readerName);
            buf += strlen(readerStates[i].readerName)+1;
        }
    }
    *buf = '\0';    /* Add the last null */

end:
    /* set the reader names length */
    *pcchReaders = dwReadersLen;

    (void)pthread_mutex_unlock(&currentContextMap->mMutex);
    (void)pthread_mutex_unlock(&readerStatesMutex);

    PROFILE_END(rv)
    API_TRACE_OUT("%d", *pcchReaders)

    return rv;
}

LONG SCardFreeMemory(SCARDCONTEXT hContext, LPCVOID pvMem)
{
    LONG rv = SCARD_S_SUCCESS;

    PROFILE_START

    /*
     * Make sure this context has been opened
     */
    if (! SCardGetContextValidity(hContext))
        return SCARD_E_INVALID_HANDLE;

    free((void *)pvMem);

    PROFILE_END(rv)

    return rv;
}

LONG SCardListReaderGroups(SCARDCONTEXT hContext, LPSTR mszGroups,
    LPDWORD pcchGroups)
{
    LONG rv = SCARD_S_SUCCESS;
    SCONTEXTMAP * currentContextMap;
    char *buf = NULL;

    PROFILE_START

    /* Multi-string with two trailing \0 */
    const char ReaderGroup[] = "SCard$DefaultReaders\0";
    const unsigned int dwGroups = sizeof(ReaderGroup);

    /*
     * Make sure this context has been opened
     */
    currentContextMap = SCardGetAndLockContext(hContext);
    if (NULL == currentContextMap)
        return SCARD_E_INVALID_HANDLE;

    if (SCARD_AUTOALLOCATE == *pcchGroups)
    {
        if (NULL == mszGroups)
        {
            rv = SCARD_E_INVALID_PARAMETER;
            goto end;
        }
        buf = malloc(dwGroups);
        if (NULL == buf)
        {
            rv = SCARD_E_NO_MEMORY;
            goto end;
        }
        *(char **)mszGroups = buf;
    }
    else
    {
        buf = mszGroups;

        if ((NULL != mszGroups) && (*pcchGroups < dwGroups))
        {
            rv = SCARD_E_INSUFFICIENT_BUFFER;
            goto end;
        }
    }

    if (buf)
        memcpy(buf, ReaderGroup, dwGroups);

end:
    *pcchGroups = dwGroups;

    (void)pthread_mutex_unlock(&currentContextMap->mMutex);

    PROFILE_END(rv)

    return rv;
}

LONG SCardCancel(SCARDCONTEXT hContext)
{
    SCONTEXTMAP * currentContextMap;
    LONG rv = SCARD_S_SUCCESS;
    uint32_t dwClientID = 0;
    struct cancel_struct scCancelStruct;
    bool cancellable;

    PROFILE_START
    API_TRACE_IN("%ld", hContext)

    /*
     * Make sure this context has been opened
     */
    (void)SCardLockThread();
    currentContextMap = SCardGetContextTH(hContext);

    if (NULL == currentContextMap)
    {
        (void)SCardUnlockThread();
        rv = SCARD_E_INVALID_HANDLE;
        goto error;
    }
    cancellable = currentContextMap->cancellable;
    (void)SCardUnlockThread();

    if (! cancellable)
    {
        rv = SCARD_S_SUCCESS;
        goto error;
    }

    /* create a new connection to the server */
    if (ClientSetupSession(&dwClientID) != 0)
    {
        rv = SCARD_E_NO_SERVICE;
        goto error;
    }

    scCancelStruct.hContext = hContext;
    scCancelStruct.rv = SCARD_S_SUCCESS;

    rv = MessageSendWithHeader(SCARD_CANCEL, dwClientID,
        sizeof(scCancelStruct), (void *) &scCancelStruct);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    /*
     * Read a message from the server
     */
    rv = MessageReceive(&scCancelStruct, sizeof(scCancelStruct), dwClientID);

    if (rv != SCARD_S_SUCCESS)
        goto end;

    rv = scCancelStruct.rv;
end:
    ClientCloseSession(dwClientID);

error:
    PROFILE_END(rv)
    API_TRACE_OUT("")

    return rv;
}

LONG SCardIsValidContext(SCARDCONTEXT hContext)
{
    LONG rv;

    PROFILE_START
    API_TRACE_IN("%ld", hContext)

    rv = SCARD_S_SUCCESS;

    /*
     * Make sure this context has been opened
     */
    if (! SCardGetContextValidity(hContext))
        rv = SCARD_E_INVALID_HANDLE;

    PROFILE_END(rv)
    API_TRACE_OUT("")

    return rv;
}

static LONG SCardAddContext(SCARDCONTEXT hContext, DWORD dwClientID)
{
    int lrv;
    SCONTEXTMAP * newContextMap;

    newContextMap = malloc(sizeof(SCONTEXTMAP));
    if (NULL == newContextMap)
        return SCARD_E_NO_MEMORY;

    Log2(PCSC_LOG_DEBUG, "Allocating new SCONTEXTMAP @%p", newContextMap);
    newContextMap->hContext = hContext;
    newContextMap->dwClientID = dwClientID;
    newContextMap->cancellable = false;

    (void)pthread_mutex_init(&newContextMap->mMutex, NULL);

    lrv = list_init(&newContextMap->channelMapList);
    if (lrv < 0)
    {
        Log2(PCSC_LOG_CRITICAL, "list_init failed with return value: %d", lrv);
        goto error;
    }

    lrv = list_attributes_seeker(&newContextMap->channelMapList,
        CHANNEL_MAP_seeker);
    if (lrv <0)
    {
        Log2(PCSC_LOG_CRITICAL,
            "list_attributes_seeker failed with return value: %d", lrv);
        list_destroy(&newContextMap->channelMapList);
        goto error;
    }

    (void)pthread_mutex_lock(&contextMapList_lock);
    lrv = list_append(&contextMapList, newContextMap);
    (void)pthread_mutex_unlock(&contextMapList_lock);
    if (lrv < 0)
    {
        Log2(PCSC_LOG_CRITICAL, "list_append failed with return value: %d",
            lrv);
        list_destroy(&newContextMap->channelMapList);
        goto error;
    }

    return SCARD_S_SUCCESS;

error:

    (void)pthread_mutex_destroy(&newContextMap->mMutex);
    free(newContextMap);

    return SCARD_E_NO_MEMORY;
}

static SCONTEXTMAP * SCardGetAndLockContext(SCARDCONTEXT hContext)
{
    SCONTEXTMAP * currentContextMap;

    SCardLockThread();
    currentContextMap = SCardGetContextTH(hContext);

    /* lock the context (if available) */
    if (NULL != currentContextMap)
        (void)pthread_mutex_lock(&currentContextMap->mMutex);

    SCardUnlockThread();

    return currentContextMap;
}

static SCONTEXTMAP * SCardGetContextTH(SCARDCONTEXT hContext)
{
    SCONTEXTMAP * currentContextMap;

    (void)pthread_mutex_lock(&contextMapList_lock);
    currentContextMap = list_seek(&contextMapList, &hContext);
    (void)pthread_mutex_unlock(&contextMapList_lock);

    return currentContextMap;
}

static void SCardRemoveContext(SCARDCONTEXT hContext)
{
    SCONTEXTMAP * currentContextMap;
    currentContextMap = SCardGetContextTH(hContext);

    if (NULL != currentContextMap)
        SCardCleanContext(currentContextMap);
}

static void SCardCleanContext(SCONTEXTMAP * targetContextMap)
{
    int list_index, lrv;
    int listSize;
    CHANNEL_MAP * currentChannelMap;

    targetContextMap->hContext = 0;
    ClientCloseSession(targetContextMap->dwClientID);
    targetContextMap->dwClientID = 0;
    (void)pthread_mutex_destroy(&targetContextMap->mMutex);

    listSize = list_size(&targetContextMap->channelMapList);
    for (list_index = 0; list_index < listSize; list_index++)
    {
        currentChannelMap = list_get_at(&targetContextMap->channelMapList,
            list_index);
        if (NULL == currentChannelMap)
        {
            Log2(PCSC_LOG_CRITICAL, "list_get_at failed for index %d",
                list_index);
            continue;
        }
        else
        {
            free(currentChannelMap->readerName);
            free(currentChannelMap);
        }

    }
    list_destroy(&targetContextMap->channelMapList);

    (void)pthread_mutex_lock(&contextMapList_lock);
    lrv = list_delete(&contextMapList, targetContextMap);
    (void)pthread_mutex_unlock(&contextMapList_lock);
    if (lrv < 0)
    {
        Log2(PCSC_LOG_CRITICAL,
            "list_delete failed with return value: %d", lrv);
    }

    free(targetContextMap);

    return;
}

/*
 * Functions for managing hCard values returned from SCardConnect.
 */

static LONG SCardAddHandle(SCARDHANDLE hCard, SCONTEXTMAP * currentContextMap,
    LPCSTR readerName)
{
    CHANNEL_MAP * newChannelMap;
    int lrv = -1;

    newChannelMap = malloc(sizeof(CHANNEL_MAP));
    if (NULL == newChannelMap)
        return SCARD_E_NO_MEMORY;

    newChannelMap->hCard = hCard;
    newChannelMap->readerName = strdup(readerName);

    lrv = list_append(&currentContextMap->channelMapList, newChannelMap);
    if (lrv < 0)
    {
        free(newChannelMap->readerName);
        free(newChannelMap);
        Log2(PCSC_LOG_CRITICAL, "list_append failed with return value: %d",
            lrv);
        return SCARD_E_NO_MEMORY;
    }

    return SCARD_S_SUCCESS;
}

static void SCardRemoveHandle(SCARDHANDLE hCard)
{
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * currentChannelMap;
    int lrv;
    LONG rv;

    rv = SCardGetContextAndChannelFromHandleTH(hCard, &currentContextMap,
        &currentChannelMap);
    if (rv == -1)
        return;

    free(currentChannelMap->readerName);

    lrv = list_delete(&currentContextMap->channelMapList, currentChannelMap);
    if (lrv < 0)
    {
        Log2(PCSC_LOG_CRITICAL,
            "list_delete failed with return value: %d", lrv);
    }

    free(currentChannelMap);

    return;
}

static LONG SCardGetContextChannelAndLockFromHandle(SCARDHANDLE hCard,
    SCONTEXTMAP **targetContextMap, CHANNEL_MAP ** targetChannelMap)
{
    LONG rv;

    if (0 == hCard)
        return -1;

    SCardLockThread();
    rv = SCardGetContextAndChannelFromHandleTH(hCard, targetContextMap,
        targetChannelMap);

    if (SCARD_S_SUCCESS == rv)
        (void)pthread_mutex_lock(&(*targetContextMap)->mMutex);

    SCardUnlockThread();

    return rv;
}

static LONG SCardGetContextAndChannelFromHandleTH(SCARDHANDLE hCard,
    SCONTEXTMAP **targetContextMap, CHANNEL_MAP ** targetChannelMap)
{
    LONG rv = -1;
    int listSize;
    int list_index;
    SCONTEXTMAP * currentContextMap;
    CHANNEL_MAP * currentChannelMap;

    /* Best to get the caller a crash early if we fail unsafely */
    *targetContextMap = NULL;
    *targetChannelMap = NULL;

    (void)pthread_mutex_lock(&contextMapList_lock);
    listSize = list_size(&contextMapList);

    for (list_index = 0; list_index < listSize; list_index++)
    {
        currentContextMap = list_get_at(&contextMapList, list_index);
        if (currentContextMap == NULL)
        {
            Log2(PCSC_LOG_CRITICAL, "list_get_at failed for index %d",
                list_index);
            continue;
        }
        currentChannelMap = list_seek(&currentContextMap->channelMapList,
            &hCard);
        if (currentChannelMap != NULL)
        {
            *targetContextMap = currentContextMap;
            *targetChannelMap = currentChannelMap;
            rv = SCARD_S_SUCCESS;
            break;
        }
    }

    (void)pthread_mutex_unlock(&contextMapList_lock);

    return rv;
}

LONG SCardCheckDaemonAvailability(void)
{
    LONG rv;
    struct stat statBuffer;
    char *socketName;

    socketName = getSocketName();
    rv = stat(socketName, &statBuffer);

    if (rv != 0)
    {
        Log3(PCSC_LOG_INFO, "PCSC Not Running: %s: %s",
            socketName, strerror(errno));
        return SCARD_E_NO_SERVICE;
    }

    return SCARD_S_SUCCESS;
}

static LONG getReaderEvents(SCONTEXTMAP * currentContextMap, int *readerEvents)
{
    int32_t dwClientID = currentContextMap->dwClientID;
    LONG rv;
    struct get_reader_events get_reader_events = {0};

    /* CMD_GET_READER_EVENTS was added in protocol 4:5 */
    if (Protocol_version < 4005)
        return SCARD_E_UNSUPPORTED_FEATURE;

    rv = MessageSendWithHeader(CMD_GET_READER_EVENTS, dwClientID, 0, NULL);
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /* Read a message from the server */
    rv = MessageReceive(&get_reader_events, sizeof(get_reader_events), dwClientID);
    if (rv != SCARD_S_SUCCESS)
        return rv;

    *readerEvents = get_reader_events.readerEvents;

    return SCARD_S_SUCCESS;
}

static LONG getReaderStates(SCONTEXTMAP * currentContextMap)
{
    int32_t dwClientID = currentContextMap->dwClientID;
    LONG rv;
    int32_t array_size;

    if (Protocol_version <= 4005)
        /* protocol up to 4:5 used a fixed size */
        array_size = PCSCLITE_MAX_READERS_CONTEXTS;
    else
    {
        rv = MessageSendWithHeader(CMD_GET_READERS_STATE_SIZE, dwClientID, 0, NULL);
        if (rv != SCARD_S_SUCCESS)
            return rv;

        /* Read a message from the server */
        rv = MessageReceive(&array_size, sizeof(array_size), dwClientID);
        if (rv != SCARD_S_SUCCESS)
            return rv;
    }

    if (array_size > pcsclite_max_reader_context)
    {
        /* need to resize */
        readerStates = realloc(readerStates, array_size * sizeof(readerStates[0]));
        if (NULL == readerStates)
            return SCARD_E_INSUFFICIENT_BUFFER;
        pcsclite_max_reader_context = array_size;
    }

    if (array_size != pcsclite_max_reader_context)
    {
        /* Should never happen */
        return SCARD_E_UNSUPPORTED_FEATURE;
    }

    if (Protocol_version <= 4005)
        rv = MessageSendWithHeader(CMD_GET_READERS_STATE, dwClientID, 0, NULL);
    else
        rv = MessageSendWithHeader(CMD_GET_READERS_STATE_ARRAY, dwClientID, 0, NULL);
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /* Read a message from the server */
    rv = MessageReceive(readerStates, array_size * sizeof(readerStates[0]), dwClientID);
    if (rv != SCARD_S_SUCCESS)
        return rv;

    return SCARD_S_SUCCESS;
}

static LONG getReaderStatesAndRegisterForEvents(SCONTEXTMAP * currentContextMap)
{
    int32_t dwClientID = currentContextMap->dwClientID;
    LONG rv;

    /* Get current reader states from server and register on event list */
    rv = MessageSendWithHeader(CMD_WAIT_READER_STATE_CHANGE, dwClientID,
        0, NULL);
    if (rv != SCARD_S_SUCCESS)
        return rv;

    if (Protocol_version <= 4005)
    {
        /* This should not happen
         * pcsclite_max_reader_context should be set to the backward
         * compatible value from a previous call to getReaderStates()
         * called from SCardStatus() or SCardListReaders() */
        if (pcsclite_max_reader_context != PCSCLITE_MAX_READERS_CONTEXTS)
            return SCARD_E_NO_SERVICE;

        rv = MessageReceive(readerStates, pcsclite_max_reader_context * sizeof(readerStates[0]), dwClientID);
        return rv;
    }
    else
        return getReaderStates(currentContextMap);
}

static LONG unregisterFromEvents(SCONTEXTMAP * currentContextMap)
{
    int32_t dwClientID = currentContextMap->dwClientID;
    LONG rv;
    struct wait_reader_state_change waitStatusStruct = {0};

    /* ask server to remove us from the event list */
    rv = MessageSendWithHeader(CMD_STOP_WAITING_READER_STATE_CHANGE,
        dwClientID, 0, NULL);
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /* This message can be the response to
     * CMD_STOP_WAITING_READER_STATE_CHANGE, an event notification or a
     * cancel notification.
     * The server side ensures, that no more messages will be sent to
     * the client. */

    rv = MessageReceive(&waitStatusStruct, sizeof(waitStatusStruct),
        dwClientID);
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /* if we received a cancel event the return value will be set
     * accordingly */
    rv = waitStatusStruct.rv;

    return rv;
}