/**
* Sends an asynchronous event to any waiting client
*/
LONG EHSignalEventToClients(void)
{
LONG rv = SCARD_S_SUCCESS;
int32_t filedes;
(void)pthread_mutex_lock(&ClientsWaitingForEvent_lock);
(void)list_iterator_start(&ClientsWaitingForEvent);
while (list_iterator_hasnext(&ClientsWaitingForEvent))
{
filedes = *(int32_t *)list_iterator_next(&ClientsWaitingForEvent);
rv = MSGSignalClient(filedes, SCARD_S_SUCCESS);
}
(void)list_iterator_stop(&ClientsWaitingForEvent);
(void)list_clear(&ClientsWaitingForEvent);
(void)pthread_mutex_unlock(&ClientsWaitingForEvent_lock);
return rv;
} /* EHSignalEventToClients */
static void ContextThread(LPVOID newContext)
{
SCONTEXT * threadContext = (SCONTEXT *) newContext;
int32_t filedes = threadContext->dwClientID;
if (IsClientAuthorized(filedes, "access_pcsc", NULL) == 0)
{
Log1(PCSC_LOG_CRITICAL, "Rejected unauthorized PC/SC client");
goto exit;
}
else
{
Log1(PCSC_LOG_DEBUG, "Authorized PC/SC client");
}
Log3(PCSC_LOG_DEBUG, "Thread is started: dwClientID=%d, threadContext @%p",
threadContext->dwClientID, threadContext);
while (1)
{
struct rxHeader header;
int32_t ret = MessageReceive(&header, sizeof(header), filedes);
if (ret != SCARD_S_SUCCESS)
{
/* Clean up the dead client */
Log2(PCSC_LOG_DEBUG, "Client die: %d", filedes);
EHTryToUnregisterClientForEvent(filedes);
goto exit;
}
if ((header.command > CMD_ENUM_FIRST)
&& (header.command < CMD_ENUM_LAST))
Log3(PCSC_LOG_DEBUG, "Received command: %s from client %d",
CommandsText[header.command], filedes);
switch (header.command)
{
/* pcsc-lite client/server protocol version */
case CMD_VERSION:
{
struct version_struct veStr;
READ_BODY(veStr)
Log3(PCSC_LOG_DEBUG, "Client is protocol version %d:%d",
veStr.major, veStr.minor);
veStr.rv = SCARD_S_SUCCESS;
/* client and server use different protocol */
if ((veStr.major != PROTOCOL_VERSION_MAJOR)
|| (veStr.minor != PROTOCOL_VERSION_MINOR))
{
Log3(PCSC_LOG_CRITICAL, "Client protocol is %d:%d",
veStr.major, veStr.minor);
Log3(PCSC_LOG_CRITICAL, "Server protocol is %d:%d",
PROTOCOL_VERSION_MAJOR, PROTOCOL_VERSION_MINOR);
veStr.rv = SCARD_E_NO_SERVICE;
}
/* set the server protocol version */
veStr.major = PROTOCOL_VERSION_MAJOR;
veStr.minor = PROTOCOL_VERSION_MINOR;
/* send back the response */
WRITE_BODY(veStr)
}
break;
case CMD_GET_READERS_STATE:
{
/* nothing to read */
#ifdef USE_USB
/* wait until all readers are ready */
RFWaitForReaderInit();
#endif
/* dump the readers state */
ret = MessageSend(readerStates, sizeof(readerStates), filedes);
}
break;
case CMD_WAIT_READER_STATE_CHANGE:
{
struct wait_reader_state_change waStr;
READ_BODY(waStr)
/* add the client fd to the list */
EHRegisterClientForEvent(filedes);
/* We do not send anything here.
* Either the client will timeout or the server will
* answer if an event occurs */
}
break;
case CMD_STOP_WAITING_READER_STATE_CHANGE:
{
struct wait_reader_state_change waStr;
READ_BODY(waStr)
/* add the client fd to the list */
waStr.rv = EHUnregisterClientForEvent(filedes);
WRITE_BODY(waStr)
}
break;
case SCARD_ESTABLISH_CONTEXT:
{
struct establish_struct esStr;
SCARDCONTEXT hContext;
READ_BODY(esStr)
hContext = esStr.hContext;
esStr.rv = SCardEstablishContext(esStr.dwScope, 0, 0,
&hContext);
esStr.hContext = hContext;
if (esStr.rv == SCARD_S_SUCCESS)
esStr.rv = MSGAddContext(esStr.hContext, threadContext);
WRITE_BODY(esStr)
}
break;
case SCARD_RELEASE_CONTEXT:
{
struct release_struct reStr;
READ_BODY(reStr)
reStr.rv = SCardReleaseContext(reStr.hContext);
if (reStr.rv == SCARD_S_SUCCESS)
reStr.rv = MSGRemoveContext(reStr.hContext, threadContext);
WRITE_BODY(reStr)
}
break;
case SCARD_CONNECT:
{
struct connect_struct coStr;
SCARDHANDLE hCard;
DWORD dwActiveProtocol;
READ_BODY(coStr)
coStr.szReader[sizeof(coStr.szReader)-1] = 0;
hCard = coStr.hCard;
dwActiveProtocol = coStr.dwActiveProtocol;
if (IsClientAuthorized(filedes, "access_card", coStr.szReader) == 0)
{
Log2(PCSC_LOG_CRITICAL, "Rejected unauthorized client for '%s'", coStr.szReader);
goto exit;
}
else
{
Log2(PCSC_LOG_DEBUG, "Authorized client for '%s'", coStr.szReader);
}
coStr.rv = SCardConnect(coStr.hContext, coStr.szReader,
coStr.dwShareMode, coStr.dwPreferredProtocols,
&hCard, &dwActiveProtocol);
coStr.hCard = hCard;
coStr.dwActiveProtocol = dwActiveProtocol;
if (coStr.rv == SCARD_S_SUCCESS)
coStr.rv = MSGAddHandle(coStr.hContext, coStr.hCard,
threadContext);
WRITE_BODY(coStr)
}
break;
case SCARD_RECONNECT:
{
struct reconnect_struct rcStr;
DWORD dwActiveProtocol;
READ_BODY(rcStr)
if (MSGCheckHandleAssociation(rcStr.hCard, threadContext))
goto exit;
rcStr.rv = SCardReconnect(rcStr.hCard, rcStr.dwShareMode,
rcStr.dwPreferredProtocols, rcStr.dwInitialization,
&dwActiveProtocol);
rcStr.dwActiveProtocol = dwActiveProtocol;
WRITE_BODY(rcStr)
}
break;
case SCARD_DISCONNECT:
{
struct disconnect_struct diStr;
READ_BODY(diStr)
if (MSGCheckHandleAssociation(diStr.hCard, threadContext))
goto exit;
diStr.rv = SCardDisconnect(diStr.hCard, diStr.dwDisposition);
if (SCARD_S_SUCCESS == diStr.rv)
diStr.rv = MSGRemoveHandle(diStr.hCard, threadContext);
WRITE_BODY(diStr)
}
break;
case SCARD_BEGIN_TRANSACTION:
{
struct begin_struct beStr;
READ_BODY(beStr)
if (MSGCheckHandleAssociation(beStr.hCard, threadContext))
goto exit;
beStr.rv = SCardBeginTransaction(beStr.hCard);
WRITE_BODY(beStr)
}
break;
case SCARD_END_TRANSACTION:
{
struct end_struct enStr;
READ_BODY(enStr)
if (MSGCheckHandleAssociation(enStr.hCard, threadContext))
goto exit;
enStr.rv = SCardEndTransaction(enStr.hCard,
enStr.dwDisposition);
WRITE_BODY(enStr)
}
break;
case SCARD_CANCEL:
{
struct cancel_struct caStr;
SCONTEXT * psTargetContext = NULL;
READ_BODY(caStr)
/* find the client */
(void)pthread_mutex_lock(&contextsList_lock);
psTargetContext = (SCONTEXT *) list_seek(&contextsList,
&caStr.hContext);
(void)pthread_mutex_unlock(&contextsList_lock);
if (psTargetContext != NULL)
{
uint32_t fd = psTargetContext->dwClientID;
caStr.rv = MSGSignalClient(fd, SCARD_E_CANCELLED);
/* the client should not receive the event
* notification now the waiting has been cancelled */
EHUnregisterClientForEvent(fd);
}
else
caStr.rv = SCARD_E_INVALID_HANDLE;
WRITE_BODY(caStr)
}
break;
case SCARD_STATUS:
{
struct status_struct stStr;
READ_BODY(stStr)
if (MSGCheckHandleAssociation(stStr.hCard, threadContext))
goto exit;
/* only hCard and return value are used by the client */
stStr.rv = SCardStatus(stStr.hCard, NULL, NULL, NULL,
NULL, 0, NULL);
WRITE_BODY(stStr)
}
break;
case SCARD_TRANSMIT:
{
struct transmit_struct trStr;
unsigned char pbSendBuffer[MAX_BUFFER_SIZE_EXTENDED];
unsigned char pbRecvBuffer[MAX_BUFFER_SIZE_EXTENDED];
SCARD_IO_REQUEST ioSendPci;
SCARD_IO_REQUEST ioRecvPci;
DWORD cbRecvLength;
READ_BODY(trStr)
if (MSGCheckHandleAssociation(trStr.hCard, threadContext))
goto exit;
/* avoids buffer overflow */
if ((trStr.pcbRecvLength > sizeof(pbRecvBuffer))
|| (trStr.cbSendLength > sizeof(pbSendBuffer)))
goto buffer_overflow;
/* read sent buffer */
ret = MessageReceive(pbSendBuffer, trStr.cbSendLength, filedes);
if (ret != SCARD_S_SUCCESS)
{
Log2(PCSC_LOG_DEBUG, "Client die: %d", filedes);
goto exit;
}
ioSendPci.dwProtocol = trStr.ioSendPciProtocol;
ioSendPci.cbPciLength = trStr.ioSendPciLength;
ioRecvPci.dwProtocol = trStr.ioRecvPciProtocol;
ioRecvPci.cbPciLength = trStr.ioRecvPciLength;
cbRecvLength = sizeof pbRecvBuffer;
trStr.rv = SCardTransmit(trStr.hCard, &ioSendPci,
pbSendBuffer, trStr.cbSendLength, &ioRecvPci,
pbRecvBuffer, &cbRecvLength);
if (cbRecvLength > trStr.pcbRecvLength)
/* The client buffer is not large enough.
* The pbRecvBuffer buffer will NOT be sent a few
* lines bellow. So no buffer overflow is expected. */
trStr.rv = SCARD_E_INSUFFICIENT_BUFFER;
trStr.ioSendPciProtocol = ioSendPci.dwProtocol;
trStr.ioSendPciLength = ioSendPci.cbPciLength;
trStr.ioRecvPciProtocol = ioRecvPci.dwProtocol;
trStr.ioRecvPciLength = ioRecvPci.cbPciLength;
trStr.pcbRecvLength = cbRecvLength;
WRITE_BODY(trStr)
/* write received buffer */
if (SCARD_S_SUCCESS == trStr.rv)
ret = MessageSend(pbRecvBuffer, cbRecvLength, filedes);
}
break;
case SCARD_CONTROL:
{
struct control_struct ctStr;
unsigned char pbSendBuffer[MAX_BUFFER_SIZE_EXTENDED];
unsigned char pbRecvBuffer[MAX_BUFFER_SIZE_EXTENDED];
DWORD dwBytesReturned;
READ_BODY(ctStr)
if (MSGCheckHandleAssociation(ctStr.hCard, threadContext))
goto exit;
/* avoids buffer overflow */
if ((ctStr.cbRecvLength > sizeof(pbRecvBuffer))
|| (ctStr.cbSendLength > sizeof(pbSendBuffer)))
{
goto buffer_overflow;
}
/* read sent buffer */
ret = MessageReceive(pbSendBuffer, ctStr.cbSendLength, filedes);
if (ret != SCARD_S_SUCCESS)
{
Log2(PCSC_LOG_DEBUG, "Client die: %d", filedes);
goto exit;
}
dwBytesReturned = ctStr.dwBytesReturned;
ctStr.rv = SCardControl(ctStr.hCard, ctStr.dwControlCode,
pbSendBuffer, ctStr.cbSendLength,
pbRecvBuffer, ctStr.cbRecvLength,
&dwBytesReturned);
ctStr.dwBytesReturned = dwBytesReturned;
WRITE_BODY(ctStr)
/* write received buffer */
if (SCARD_S_SUCCESS == ctStr.rv)
ret = MessageSend(pbRecvBuffer, dwBytesReturned, filedes);
}
break;
case SCARD_GET_ATTRIB:
{
struct getset_struct gsStr;
DWORD cbAttrLen;
READ_BODY(gsStr)
if (MSGCheckHandleAssociation(gsStr.hCard, threadContext))
goto exit;
/* avoids buffer overflow */
if (gsStr.cbAttrLen > sizeof(gsStr.pbAttr))
goto buffer_overflow;
cbAttrLen = gsStr.cbAttrLen;
gsStr.rv = SCardGetAttrib(gsStr.hCard, gsStr.dwAttrId,
gsStr.pbAttr, &cbAttrLen);
gsStr.cbAttrLen = cbAttrLen;
WRITE_BODY(gsStr)
}
break;
case SCARD_SET_ATTRIB:
{
struct getset_struct gsStr;
READ_BODY(gsStr)
if (MSGCheckHandleAssociation(gsStr.hCard, threadContext))
goto exit;
/* avoids buffer overflow */
if (gsStr.cbAttrLen > sizeof(gsStr.pbAttr))
goto buffer_overflow;
gsStr.rv = SCardSetAttrib(gsStr.hCard, gsStr.dwAttrId,
gsStr.pbAttr, gsStr.cbAttrLen);
WRITE_BODY(gsStr)
}
break;
default:
Log2(PCSC_LOG_CRITICAL, "Unknown command: %d", header.command);
goto exit;
}
/* MessageSend() failed */
if (ret != SCARD_S_SUCCESS)
{
/* Clean up the dead client */
Log2(PCSC_LOG_DEBUG, "Client die: %d", filedes);
goto exit;
}
}
buffer_overflow:
Log2(PCSC_LOG_DEBUG, "Buffer overflow detected: %d", filedes);
goto exit;
wrong_length:
Log2(PCSC_LOG_DEBUG, "Wrong length: %d", filedes);
exit:
(void)close(filedes);
(void)MSGCleanupClient(threadContext);
(void)pthread_exit((LPVOID) NULL);
}
