winscard_clnt.c

Go to the documentation of this file.

/*
 * MUSCLE SmartCard Development ( http://www.linuxnet.com )
 *
 * Copyright (C) 1999-2004
 *  David Corcoran <corcoran@linuxnet.com>
 *  Damien Sauveron <damien.sauveron@labri.fr>
 *  Ludovic Rousseau <ludovic.rousseau@free.fr>
 *
 * $Id: winscard_clnt.c 2915 2008-04-28 09:28:05Z rousseau $
 */

#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 "misc.h"
#include "pcscd.h"
#include "winscard.h"
#include "debug.h"
#include "thread_generic.h"
#include "strlcpycat.h"

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

#define SCARD_PROTOCOL_ANY_OLD  0x1000

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif

#undef DO_PROFILE
#ifdef DO_PROFILE

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

struct timeval profile_time_start;
FILE *fd;
char profile_tty;
char fct_name[100];

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

static void profile_start(const char *f)
{
    static char initialized = FALSE;

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

        initialized = TRUE;
        sprintf(filename, "%s-%d", PROFILE_FILE, getuid());
        fd = fopen(filename, "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");

        if (isatty(fileno(stderr)))
            profile_tty = TRUE;
        else
            profile_tty = FALSE;
    }

    /* PROFILE_END was not called before? */
    if (profile_tty && fct_name[0])
        printf("\33[01;34m WARNING: %s starts before %s finishes\33[0m\n",
            f, fct_name);

    strlcpy(fct_name, f, sizeof(fct_name));

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

/* r = a - b */
static long int time_sub(struct timeval *a, struct timeval *b)
{
    struct timeval r;
    r.tv_sec = a -> tv_sec - b -> tv_sec;
    r.tv_usec = a -> tv_usec - b -> tv_usec;
    if (r.tv_usec < 0)
    {
        r.tv_sec--;
        r.tv_usec += 1000000;
    }

    return r.tv_sec * 1000000 + r.tv_usec;
} /* time_sub */


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

    gettimeofday(&profile_time_end, NULL);
    d = time_sub(&profile_time_end, &profile_time_start);

    if (profile_tty)
    {
        if (fct_name[0])
        {
            if (strncmp(fct_name, f, sizeof(fct_name)))
                printf("\33[01;34m WARNING: %s ends before %s\33[0m\n",
                        f, fct_name);
        }
        else
            printf("\33[01;34m WARNING: %s ends but we lost its start\33[0m\n",
                f);

        /* allow to detect missing PROFILE_END calls */
        fct_name[0] = '\0';

        if (rv != SCARD_S_SUCCESS)
            fprintf(stderr,
                "\33[01;31mRESULT %s \33[35m%ld \33[34m0x%08lX %s\33[0m\n",
                f, d, rv, pcsc_stringify_error(rv));
        else
            fprintf(stderr, "\33[01;31mRESULT %s \33[35m%ld\33[0m\n", f, d);
    }
    fprintf(fd, "%s %ld\n", f, d);
    fflush(fd);
} /* profile_end */

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

struct _psChannelMap
{
    SCARDHANDLE hCard;
    LPSTR readerName;
};

typedef struct _psChannelMap CHANNEL_MAP, *PCHANNEL_MAP;

static struct _psContextMap
{
    DWORD dwClientID;               
    SCARDCONTEXT hContext;          
    DWORD contextBlockStatus;
    PCSCLITE_MUTEX_T mMutex;        
    CHANNEL_MAP psChannelMap[PCSCLITE_MAX_APPLICATION_CONTEXT_CHANNELS];
} psContextMap[PCSCLITE_MAX_APPLICATION_CONTEXTS];

static short isExecuted = 0;


static time_t daemon_ctime = 0;
static pid_t daemon_pid = 0;
static pid_t client_pid = 0;

static int mapAddr = 0;

static PCSCLITE_MUTEX clientMutex = PTHREAD_MUTEX_INITIALIZER;

static PREADER_STATE readerStates[PCSCLITE_MAX_READERS_CONTEXTS];

PCSC_API SCARD_IO_REQUEST g_rgSCardT0Pci = { SCARD_PROTOCOL_T0, 8 };
PCSC_API SCARD_IO_REQUEST g_rgSCardT1Pci = { SCARD_PROTOCOL_T1, 8 };
PCSC_API SCARD_IO_REQUEST g_rgSCardRawPci = { SCARD_PROTOCOL_RAW, 8 };


static LONG SCardAddContext(SCARDCONTEXT, DWORD);
static LONG SCardGetContextIndice(SCARDCONTEXT);
static LONG SCardGetContextIndiceTH(SCARDCONTEXT);
static LONG SCardRemoveContext(SCARDCONTEXT);
static LONG SCardCleanContext(LONG indice);

static LONG SCardAddHandle(SCARDHANDLE, DWORD, LPCSTR);
static LONG SCardGetIndicesFromHandle(SCARDHANDLE, PDWORD, PDWORD);
static LONG SCardGetIndicesFromHandleTH(SCARDHANDLE, PDWORD, PDWORD);
static LONG SCardRemoveHandle(SCARDHANDLE);

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

void DESTRUCTOR SCardUnload(void);

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

inline static LONG SCardUnlockThread(void)
{
    return SYS_MutexUnLock(&clientMutex);
}

static LONG SCardEstablishContextTH(DWORD, LPCVOID, LPCVOID, LPSCARDCONTEXT);

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

    PROFILE_START

    /* Check if the server is running */
    rv = SCardCheckDaemonAvailability();
    if (SCARD_E_INVALID_HANDLE == rv)
        /* we reconnected to a daemon or we got called from a forked child */
        rv = SCardCheckDaemonAvailability();

    if (rv != SCARD_S_SUCCESS)
        return rv;

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

    PROFILE_END(rv)

    return rv;
}

static LONG SCardEstablishContextTH(DWORD dwScope, LPCVOID pvReserved1,
    LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
{
    LONG rv;
    int i;
    establish_struct scEstablishStruct;
    sharedSegmentMsg msgStruct;
    uint32_t dwClientID = 0;

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

    /*
     * Do this only once:
     * - Initialize debug of need.
     * - Set up the memory mapped structures for reader states.
     * - Allocate each reader structure.
     * - Initialize context struct.
     */
    if (isExecuted == 0)
    {
        int pageSize;

        /*
         * Do any system initilization here
         */
        SYS_Initialize();

        /*
         * Set up the memory mapped reader stats structures
         */
        mapAddr = SYS_OpenFile(PCSCLITE_PUBSHM_FILE, O_RDONLY, 0);
        if (mapAddr < 0)
        {
            Log3(PCSC_LOG_CRITICAL, "Cannot open public shared file %s: %s",
                PCSCLITE_PUBSHM_FILE, strerror(errno));
            return SCARD_E_NO_SERVICE;
        }

        /* close on exec so that child processes do not inherits the file
         * descriptor. The child process will call SCardEstablishContext()
         * if needed. */
        fcntl(mapAddr, F_SETFD, FD_CLOEXEC);

        pageSize = SYS_GetPageSize();

        /*
         * Allocate each reader structure in the memory map
         */
        for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
        {
            readerStates[i] =
                (PREADER_STATE)SYS_PublicMemoryMap(sizeof(READER_STATE),
                mapAddr, (i * pageSize));
            if (readerStates[i] == NULL)
            {
                Log2(PCSC_LOG_CRITICAL, "Cannot public memory map: %s",
                    strerror(errno));
                SYS_CloseFile(mapAddr); /* Close the memory map file */
                return SCARD_F_INTERNAL_ERROR;
            }
        }

        /*
         * Initializes the application contexts and all channels for each one
         */
        for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
        {
            int j;

            /*
             * Initially set the context struct to zero
             */
            psContextMap[i].dwClientID = 0;
            psContextMap[i].hContext = 0;
            psContextMap[i].contextBlockStatus = BLOCK_STATUS_RESUME;
            psContextMap[i].mMutex = NULL;

            for (j = 0; j < PCSCLITE_MAX_APPLICATION_CONTEXT_CHANNELS; j++)
            {
                /*
                 * Initially set the hcard structs to zero
                 */
                psContextMap[i].psChannelMap[j].hCard = 0;
                psContextMap[i].psChannelMap[j].readerName = NULL;
            }
        }

    }

    /*
     * Is there a free slot for this connection ?
     */

    for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
    {
        if (psContextMap[i].dwClientID == 0)
            break;
    }

    if (i == PCSCLITE_MAX_APPLICATION_CONTEXTS)
    {
        return SCARD_E_NO_MEMORY;
    }

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

    {   /* exchange client/server protocol versions */
        version_struct *veStr;

        memset(&msgStruct, 0, sizeof(msgStruct));
        msgStruct.mtype = CMD_VERSION;
        msgStruct.user_id = SYS_GetUID();
        msgStruct.group_id = SYS_GetGID();
        msgStruct.command = 0;
        msgStruct.date = time(NULL);

        veStr = (version_struct *) msgStruct.data;
        veStr->major = PROTOCOL_VERSION_MAJOR;
        veStr->minor = PROTOCOL_VERSION_MINOR;

        if (-1 == SHMMessageSend(&msgStruct, sizeof(msgStruct), dwClientID,
            PCSCLITE_MCLIENT_ATTEMPTS))
            return SCARD_E_NO_SERVICE;

        /*
         * Read a message from the server
         */
        if (-1 == SHMMessageReceive(&msgStruct, sizeof(msgStruct), dwClientID,
            PCSCLITE_CLIENT_ATTEMPTS))
        {
            Log1(PCSC_LOG_CRITICAL, "Your pcscd is too old and does not support CMD_VERSION");
            return SCARD_F_COMM_ERROR;
        }

        Log3(PCSC_LOG_INFO, "Server is protocol version %d:%d",
            veStr->major, veStr->minor);

        if (veStr->rv != SCARD_S_SUCCESS)
            return veStr->rv;

        isExecuted = 1;
    }


    if (dwScope != SCARD_SCOPE_USER && dwScope != SCARD_SCOPE_TERMINAL &&
        dwScope != SCARD_SCOPE_SYSTEM && dwScope != SCARD_SCOPE_GLOBAL)
    {
        return SCARD_E_INVALID_VALUE;
    }

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

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

    if (rv == -1)
        return SCARD_E_NO_SERVICE;

    /*
     * Read the response from the server
     */
    rv = SHMClientRead(&msgStruct, dwClientID, PCSCLITE_CLIENT_ATTEMPTS);

    if (rv == -1)
        return SCARD_F_COMM_ERROR;

    memcpy(&scEstablishStruct, &msgStruct.data, sizeof(scEstablishStruct));

    if (scEstablishStruct.rv != SCARD_S_SUCCESS)
        return scEstablishStruct.rv;

    *phContext = scEstablishStruct.phContext;

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

    return rv;
}

LONG SCardReleaseContext(SCARDCONTEXT hContext)
{
    LONG rv;
    release_struct scReleaseStruct;
    sharedSegmentMsg msgStruct;
    LONG dwContextIndex;

    PROFILE_START

    /*
     * Make sure this context has been opened    
     * and get dwContextIndex
     */      
    dwContextIndex = SCardGetContextIndice(hContext);    
    if (dwContextIndex == -1)    
        return SCARD_E_INVALID_HANDLE;

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
    {
        /*
         * Remove the local context from the stack
         */
        SCardLockThread();
        SCardRemoveContext(hContext);
        SCardUnlockThread();

        return rv;
    }

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

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

    rv = WrapSHMWrite(SCARD_RELEASE_CONTEXT,
        psContextMap[dwContextIndex].dwClientID,
        sizeof(scReleaseStruct),
        PCSCLITE_MCLIENT_ATTEMPTS, (void *) &scReleaseStruct);

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_NO_SERVICE;
    }

    /*
     * Read a message from the server
     */
    rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
        PCSCLITE_CLIENT_ATTEMPTS);
    memcpy(&scReleaseStruct, &msgStruct.data, sizeof(scReleaseStruct));

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_F_COMM_ERROR;
    }

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

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

    PROFILE_END(scReleaseStruct.rv)

    return scReleaseStruct.rv;
}

LONG SCardSetTimeout(SCARDCONTEXT hContext, DWORD dwTimeout)
{
    /*
     * Deprecated
     */

    return SCARD_S_SUCCESS;
}

LONG SCardConnect(SCARDCONTEXT hContext, LPCSTR szReader,
    DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
    LPDWORD pdwActiveProtocol)
{
    LONG rv;
    connect_struct scConnectStruct;
    sharedSegmentMsg msgStruct;
    LONG dwContextIndex;

    PROFILE_START

    /*
     * 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;

    if (!(dwPreferredProtocols & SCARD_PROTOCOL_T0) &&
        !(dwPreferredProtocols & SCARD_PROTOCOL_T1) &&
        !(dwPreferredProtocols & SCARD_PROTOCOL_RAW) &&
        !(dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD))
    {
        return SCARD_E_INVALID_VALUE;
    }

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this context has been opened
     */
    dwContextIndex = SCardGetContextIndice(hContext);
    if (dwContextIndex == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

    strncpy(scConnectStruct.szReader, szReader, MAX_READERNAME);

    scConnectStruct.hContext = hContext;
    scConnectStruct.dwShareMode = dwShareMode;
    scConnectStruct.dwPreferredProtocols = dwPreferredProtocols;
    scConnectStruct.phCard = 0;
    scConnectStruct.pdwActiveProtocol = 0;
    scConnectStruct.rv = SCARD_S_SUCCESS;

    rv = WrapSHMWrite(SCARD_CONNECT, psContextMap[dwContextIndex].dwClientID,
        sizeof(scConnectStruct),
        PCSCLITE_CLIENT_ATTEMPTS, (void *) &scConnectStruct);

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_NO_SERVICE;
    }

    /*
     * Read a message from the server
     */
    rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
        PCSCLITE_CLIENT_ATTEMPTS);

    memcpy(&scConnectStruct, &msgStruct.data, sizeof(scConnectStruct));

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_F_COMM_ERROR;
    }

    *phCard = scConnectStruct.phCard;
    *pdwActiveProtocol = scConnectStruct.pdwActiveProtocol;

    if (scConnectStruct.rv == SCARD_S_SUCCESS)
    {
        /*
         * Keep track of the handle locally
         */
        rv = SCardAddHandle(*phCard, dwContextIndex, szReader);
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

        PROFILE_END(rv)

        return rv;
    }

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

    PROFILE_END(scConnectStruct.rv)

    return scConnectStruct.rv;
}

LONG SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,
    DWORD dwPreferredProtocols, DWORD dwInitialization,
    LPDWORD pdwActiveProtocol)
{
    LONG rv;
    reconnect_struct scReconnectStruct;
    sharedSegmentMsg msgStruct;
    int i;
    DWORD dwContextIndex, dwChannelIndex;

    PROFILE_START

    if (dwInitialization != SCARD_LEAVE_CARD &&
        dwInitialization != SCARD_RESET_CARD &&
        dwInitialization != SCARD_UNPOWER_CARD &&
        dwInitialization != SCARD_EJECT_CARD)
    {
        return SCARD_E_INVALID_VALUE;
    }

    if (!(dwPreferredProtocols & SCARD_PROTOCOL_T0) &&
        !(dwPreferredProtocols & SCARD_PROTOCOL_T1) &&
        !(dwPreferredProtocols & SCARD_PROTOCOL_RAW) &&
        !(dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD))
    {
        return SCARD_E_INVALID_VALUE;
    }

    if (pdwActiveProtocol == NULL)
        return SCARD_E_INVALID_PARAMETER;

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);


    for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
    {
        char *r = psContextMap[dwContextIndex].psChannelMap[dwChannelIndex].readerName;

        /* by default r == NULL */
        if (r && strcmp(r, (readerStates[i])->readerName) == 0)
            break;
    }

    if (i == PCSCLITE_MAX_READERS_CONTEXTS)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_READER_UNAVAILABLE;
    }

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

        rv = WrapSHMWrite(SCARD_RECONNECT, psContextMap[dwContextIndex].dwClientID,
            sizeof(scReconnectStruct),
            PCSCLITE_CLIENT_ATTEMPTS, (void *) &scReconnectStruct);

        if (rv == -1)
        {
            SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
            return SCARD_E_NO_SERVICE;
        }

        /*
         * Read a message from the server
         */
        rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
            PCSCLITE_CLIENT_ATTEMPTS);

        memcpy(&scReconnectStruct, &msgStruct.data, sizeof(scReconnectStruct));

        if (rv == -1)
        {
            SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
            return SCARD_F_COMM_ERROR;
        }
    } while (SCARD_E_SHARING_VIOLATION == scReconnectStruct.rv);

    *pdwActiveProtocol = scReconnectStruct.pdwActiveProtocol;

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

    PROFILE_END(scReconnectStruct.rv)

    return scReconnectStruct.rv;
}

LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
{
    LONG rv;
    disconnect_struct scDisconnectStruct;
    sharedSegmentMsg msgStruct;
    DWORD dwContextIndex, dwChannelIndex;

    PROFILE_START

    if (dwDisposition != SCARD_LEAVE_CARD &&
        dwDisposition != SCARD_RESET_CARD &&
        dwDisposition != SCARD_UNPOWER_CARD &&
        dwDisposition != SCARD_EJECT_CARD)
    {
        return SCARD_E_INVALID_VALUE;
    }

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

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

    rv = WrapSHMWrite(SCARD_DISCONNECT, psContextMap[dwContextIndex].dwClientID,
        sizeof(scDisconnectStruct),
        PCSCLITE_CLIENT_ATTEMPTS, (void *) &scDisconnectStruct);

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_NO_SERVICE;
    }

    /*
     * Read a message from the server
     */
    rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
        PCSCLITE_CLIENT_ATTEMPTS);

    memcpy(&scDisconnectStruct, &msgStruct.data,
        sizeof(scDisconnectStruct));

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_F_COMM_ERROR;
    }

    SCardRemoveHandle(hCard);

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

    PROFILE_END(scDisconnectStruct.rv)

    return scDisconnectStruct.rv;
}

LONG SCardBeginTransaction(SCARDHANDLE hCard)
{

    LONG rv;
    begin_struct scBeginStruct;
    int i;
    sharedSegmentMsg msgStruct;
    DWORD dwContextIndex, dwChannelIndex;

    PROFILE_START

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

    for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
    {
        char *r = psContextMap[dwContextIndex].psChannelMap[dwChannelIndex].readerName;

        /* by default r == NULL */
        if (r && strcmp(r, (readerStates[i])->readerName) == 0)
            break;
    }

    if (i == PCSCLITE_MAX_READERS_CONTEXTS)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_READER_UNAVAILABLE;
    }

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

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

    do
    {
        rv = WrapSHMWrite(SCARD_BEGIN_TRANSACTION, psContextMap[dwContextIndex].dwClientID,
            sizeof(scBeginStruct),
            PCSCLITE_CLIENT_ATTEMPTS, (void *) &scBeginStruct);

        if (rv == -1)
        {

            SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
            return SCARD_E_NO_SERVICE;
        }

        /*
         * Read a message from the server
         */
        rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
            PCSCLITE_CLIENT_ATTEMPTS);

        memcpy(&scBeginStruct, &msgStruct.data, sizeof(scBeginStruct));

        if (rv == -1)
        {

            SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
            return SCARD_F_COMM_ERROR;
        }

    }
    while (scBeginStruct.rv == SCARD_E_SHARING_VIOLATION);

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

    PROFILE_END(scBeginStruct.rv);

    return scBeginStruct.rv;
}

LONG SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition)
{
    LONG rv;
    end_struct scEndStruct;
    sharedSegmentMsg msgStruct;
    int randnum, i;
    DWORD dwContextIndex, dwChannelIndex;

    PROFILE_START

    /*
     * Zero out everything
     */
    randnum = 0;

    if (dwDisposition != SCARD_LEAVE_CARD &&
        dwDisposition != SCARD_RESET_CARD &&
        dwDisposition != SCARD_UNPOWER_CARD &&
        dwDisposition != SCARD_EJECT_CARD)
    {
        return SCARD_E_INVALID_VALUE;
    }

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

    for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
    {
        char *r = psContextMap[dwContextIndex].psChannelMap[dwChannelIndex].readerName;

        /* by default r == NULL */
        if (r && strcmp(r, (readerStates[i])->readerName) == 0)
            break;
    }

    if (i == PCSCLITE_MAX_READERS_CONTEXTS)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_READER_UNAVAILABLE;
    }

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

    rv = WrapSHMWrite(SCARD_END_TRANSACTION,
        psContextMap[dwContextIndex].dwClientID,
        sizeof(scEndStruct),
        PCSCLITE_CLIENT_ATTEMPTS, (void *) &scEndStruct);

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_NO_SERVICE;
    }

    /*
     * Read a message from the server
     */
    rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
        PCSCLITE_CLIENT_ATTEMPTS);

    memcpy(&scEndStruct, &msgStruct.data, sizeof(scEndStruct));

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_F_COMM_ERROR;
    }

    /*
     * This helps prevent starvation
     */
    randnum = SYS_RandomInt(1000, 10000);
    SYS_USleep(randnum);

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

    PROFILE_END(scEndStruct.rv)

    return scEndStruct.rv;
}

LONG SCardCancelTransaction(SCARDHANDLE hCard)
{
    LONG rv;
    cancel_struct scCancelStruct;
    sharedSegmentMsg msgStruct;
    int i;
    DWORD dwContextIndex, dwChannelIndex;

    PROFILE_START

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

    for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
    {
        char *r = psContextMap[dwContextIndex].psChannelMap[dwChannelIndex].readerName;

        /* by default r == NULL */
        if (r && strcmp(r, (readerStates[i])->readerName) == 0)
            break;
    }

    if (i == PCSCLITE_MAX_READERS_CONTEXTS)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_READER_UNAVAILABLE;
    }

    scCancelStruct.hCard = hCard;

    rv = WrapSHMWrite(SCARD_CANCEL_TRANSACTION,
        psContextMap[dwContextIndex].dwClientID,
        sizeof(scCancelStruct),
        PCSCLITE_CLIENT_ATTEMPTS, (void *) &scCancelStruct);

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_NO_SERVICE;
    }

    /*
     * Read a message from the server
     */
    rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
        PCSCLITE_CLIENT_ATTEMPTS);

    memcpy(&scCancelStruct, &msgStruct.data, sizeof(scCancelStruct));

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_F_COMM_ERROR;
    }

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

    PROFILE_END(scCancelStruct.rv)

    return scCancelStruct.rv;
}

LONG SCardStatus(SCARDHANDLE hCard, LPSTR mszReaderNames,
    LPDWORD pcchReaderLen, LPDWORD pdwState,
    LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
{
    DWORD dwReaderLen, dwAtrLen;
    LONG rv;
    int i;
    status_struct scStatusStruct;
    sharedSegmentMsg msgStruct;
    DWORD dwContextIndex, dwChannelIndex;
    char *r;

    PROFILE_START

    /*
     * Check for NULL parameters
     */

    if (pcchReaderLen == NULL || pcbAtrLen == NULL)
        return SCARD_E_INVALID_PARAMETER;

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

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

    if (pdwProtocol)
        *pdwProtocol = 0;

    *pcchReaderLen = 0;
    *pcbAtrLen = 0;

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this handle has been opened
     */
    rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

    if (rv == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

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

    if (i == PCSCLITE_MAX_READERS_CONTEXTS)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_READER_UNAVAILABLE;
    }

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

    /* those sizes need to be initialised */
    scStatusStruct.pcchReaderLen = sizeof(scStatusStruct.mszReaderNames);
    scStatusStruct.pcbAtrLen = sizeof(scStatusStruct.pbAtr);

    rv = WrapSHMWrite(SCARD_STATUS, psContextMap[dwContextIndex].dwClientID,
        sizeof(scStatusStruct),
        PCSCLITE_CLIENT_ATTEMPTS, (void *) &scStatusStruct);

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_E_NO_SERVICE;
    }

    /*
     * Read a message from the server
     */
    rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,
        PCSCLITE_CLIENT_ATTEMPTS);

    memcpy(&scStatusStruct, &msgStruct.data, sizeof(scStatusStruct));

    if (rv == -1)
    {
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return SCARD_F_COMM_ERROR;
    }

    rv = scStatusStruct.rv;
    if (rv != SCARD_S_SUCCESS && rv != SCARD_E_INSUFFICIENT_BUFFER)
    {
        /*
         * An event must have occurred
         */
        SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);
        return rv;
    }

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

    *pcchReaderLen = strlen(psContextMap[dwContextIndex].psChannelMap[dwChannelIndex].readerName) + 1;
    *pcbAtrLen = (readerStates[i])->cardAtrLength;

    if (pdwState)
        *pdwState = (readerStates[i])->readerState;

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

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

        strncpy(mszReaderNames,
            psContextMap[dwContextIndex].psChannelMap[dwChannelIndex].readerName,
            dwReaderLen);
    }

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

        memcpy(pbAtr, (readerStates[i])->cardAtr,
            min(*pcbAtrLen, dwAtrLen));
    }

    SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

    PROFILE_END(rv)

    return rv;
}

LONG SCardGetStatusChange(SCARDCONTEXT hContext, DWORD dwTimeout,
    LPSCARD_READERSTATE_A rgReaderStates, DWORD cReaders)
{
    PSCARD_READERSTATE_A currReader;
    PREADER_STATE rContext;
    DWORD dwTime = 0;
    DWORD dwState;
    DWORD dwBreakFlag = 0;
    int j;
    LONG dwContextIndex;
    int currentReaderCount = 0;
    LONG rv;

    PROFILE_START

    if (rgReaderStates == NULL && cReaders > 0)
        return SCARD_E_INVALID_PARAMETER;

    rv = SCardCheckDaemonAvailability();
    if (rv != SCARD_S_SUCCESS)
        return rv;

    /*
     * Make sure this context has been opened
     */

    dwContextIndex = SCardGetContextIndice(hContext);
    if (dwContextIndex == -1)
        return SCARD_E_INVALID_HANDLE;

    SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

    /*
     * Application is waiting for a reader - return the first available
     * reader
     */

    if (cReaders == 0)