static int32_t pcsc_check_card_inserted(struct s_reader *pcsc_reader)
{
struct pcsc_data *crdr_data = pcsc_reader->crdr_data;
DWORD dwState, dwAtrLen, dwReaderLen;
unsigned char pbAtr[64];
SCARDHANDLE rv;
dwAtrLen = sizeof(pbAtr);
rv=0;
dwState=0;
dwReaderLen=0;
// Do we have a card ?
if (!crdr_data->pcsc_has_card && !crdr_data->hCard) {
// try connecting to the card
rv = SCardConnect(crdr_data->hContext, crdr_data->pcsc_name, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &crdr_data->hCard, &crdr_data->dwActiveProtocol);
if (rv == (LONG)SCARD_E_NO_SMARTCARD) {
// no card in pcsc_reader
crdr_data->pcsc_has_card=0;
if(crdr_data->hCard) {
SCardDisconnect(crdr_data->hCard, SCARD_RESET_CARD);
crdr_data->hCard=0;
}
// rdr_debug_mask(pcsc_reader, D_DEVICE, "PCSC card in %s removed / absent [dwstate=%lx rv=(%lx)]", crdr_data->pcsc_name, dwState, (unsigned long)rv );
return OK;
}
else if (rv == (LONG)SCARD_W_UNRESPONSIVE_CARD) {
// there is a problem with the card in the pcsc_reader
crdr_data->pcsc_has_card=0;
crdr_data->hCard=0;
rdr_log(pcsc_reader, "PCSC card in %s is unresponsive. Eject and re-insert please.", crdr_data->pcsc_name);
return ERROR;
}
else if( rv == SCARD_S_SUCCESS ) {
// we have a card
crdr_data->pcsc_has_card=1;
rdr_log(pcsc_reader, "PCSC was opened with handle: %ld", (long)crdr_data->hCard);
}
else {
// if we get here we have a bigger problem -> display status and debug
// rdr_debug_mask(pcsc_reader, D_DEVICE, "PCSC pcsc_reader %s status [dwstate=%lx rv=(%lx)]", crdr_data->pcsc_name, dwState, (unsigned long)rv );
return ERROR;
}
}
// if we get there the card is ready, check its status
rv = SCardStatus(crdr_data->hCard, NULL, &dwReaderLen, &dwState, &crdr_data->dwActiveProtocol, pbAtr, &dwAtrLen);
if (rv == SCARD_S_SUCCESS && (dwState & (SCARD_PRESENT | SCARD_NEGOTIABLE | SCARD_POWERED ) )) {
return OK;
}
else {
SCardDisconnect(crdr_data->hCard, SCARD_RESET_CARD);
crdr_data->hCard = 0;
crdr_data->pcsc_has_card = 0;
}
return ERROR;
}
int32_t pcsc_check_card_inserted(struct s_reader *pcsc_reader)
{
DWORD dwState, dwAtrLen, dwReaderLen;
BYTE pbAtr[64];
LONG rv;
dwAtrLen = sizeof(pbAtr);
rv=0;
dwState=0;
dwReaderLen=0;
// Do we have a card ?
if (!pcsc_reader->pcsc_has_card && !(SCARDHANDLE)(pcsc_reader->hCard)) {
// try connecting to the card
rv = SCardConnect(pcsc_reader->hContext, pcsc_reader->pcsc_name, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &pcsc_reader->hCard, &pcsc_reader->dwActiveProtocol);
if (rv==SCARD_E_NO_SMARTCARD) {
// no card in pcsc_reader
pcsc_reader->pcsc_has_card=0;
if((SCARDHANDLE)(pcsc_reader->hCard)) {
SCardDisconnect((SCARDHANDLE)(pcsc_reader->hCard),SCARD_RESET_CARD);
pcsc_reader->hCard=0;
}
// rdr_debug_mask(pcsc_reader, D_DEVICE, "PCSC card in %s removed / absent [dwstate=%lx rv=(%lx)]", pcsc_reader->pcsc_name, dwState, (unsigned long)rv );
return 0;
}
else if( rv == SCARD_W_UNRESPONSIVE_CARD ) {
// there is a problem with the card in the pcsc_reader
pcsc_reader->pcsc_has_card=0;
pcsc_reader->hCard=0;
rdr_log(pcsc_reader, "PCSC card in %s is unresponsive. Eject and re-insert please.", pcsc_reader->pcsc_name);
return 0;
}
else if( rv == SCARD_S_SUCCESS ) {
// we have a card
pcsc_reader->pcsc_has_card=1;
}
else {
// if we get here we have a bigger problem -> display status and debug
// rdr_debug_mask(pcsc_reader, D_DEVICE, "PCSC pcsc_reader %s status [dwstate=%lx rv=(%lx)]", pcsc_reader->pcsc_name, dwState, (unsigned long)rv );
return 0;
}
}
// if we get there the card is ready, check its status
rv = SCardStatus((SCARDHANDLE)(pcsc_reader->hCard), NULL, &dwReaderLen, &dwState, &pcsc_reader->dwActiveProtocol, pbAtr, &dwAtrLen);
if (rv == SCARD_S_SUCCESS && (dwState & (SCARD_PRESENT | SCARD_NEGOTIABLE | SCARD_POWERED ) )) {
return CARD_INSERTED;
}
else {
SCardDisconnect((SCARDHANDLE)(pcsc_reader->hCard),SCARD_RESET_CARD);
pcsc_reader->hCard=0;
pcsc_reader->pcsc_has_card=0;
}
return 0;
}
static void smartcard_check_status (SCARDCONTEXT hContext,
const char* pReader,
SCARDHANDLE hCardHandle, /* Can be 0 on the first call */
SCARDHANDLE* newCardHandle, /* The handle returned */
DWORD* pdwState) {
if (hCardHandle == 0) {
DWORD dwAP;
LONG result = SCardConnect(hContext, pReader, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &hCardHandle, &dwAP);
if (SCARD_S_SUCCESS != result) {
hCardHandle = 0;
if (SCARD_E_NO_SMARTCARD == result || SCARD_W_REMOVED_CARD == result) {
*pdwState = SCARD_ABSENT;
}
else {
*pdwState = SCARD_UNKNOWN;
}
if (newCardHandle == NULL) {
(void) SCardDisconnect(hCardHandle, SCARD_LEAVE_CARD);
hCardHandle = 0;
}
else {
*newCardHandle = hCardHandle;
}
}
}
char szReader[200];
DWORD cch = sizeof(szReader);
BYTE bAttr[32];
DWORD cByte = 32;
LONG result = SCardStatus(hCardHandle, /* Unfortunately we can't use NULL here */ szReader, &cch, pdwState, NULL, (LPBYTE)&bAttr, &cByte);
if (SCARD_S_SUCCESS != result) {
if (SCARD_E_NO_SMARTCARD == result || SCARD_W_REMOVED_CARD == result) {
*pdwState = SCARD_ABSENT;
}
else {
*pdwState = SCARD_UNKNOWN;
}
}
if (newCardHandle == NULL) {
(void) SCardDisconnect(hCardHandle, SCARD_LEAVE_CARD);
hCardHandle = 0;
}
else {
*newCardHandle = hCardHandle;
}
}
/*
* Class: com_ibm_opencard_terminal_pcsc10_OCFPCSC1
* Method: SCardDisconnect
* Signature: (II)V
*/
JNIEXPORT void JNICALL Java_com_ibm_opencard_terminal_pcsc10_OCFPCSC1_SCardDisconnect
(JNIEnv *env, jobject obj, jint card, jint disposition) {
long returnCode;
CONTEXT_INFO cInfo;
// get the contextInfo from the table
cInfo = getContextInfoViaCardHandle((SCARDHANDLE)card);
if (cInfo.context == 0) {
throwPcscException(env, obj, "SCardDisconnect", "PC/SC Wrapper Error: couldn't get context information record", 0);
return;
}
returnCode = SCardDisconnect((SCARDHANDLE)card, (DWORD)disposition);
if ((returnCode != SCARD_S_SUCCESS) && (returnCode != SCARD_W_REMOVED_CARD)) {
throwPcscException(env, obj, "SCardDisconnect", "PC/SC Error SCardDisconnect", returnCode);
return;
}
// delete cardHandle and active protocol in context info record
cInfo.cardHandle = 0;
cInfo.protocol = 0;
// store the modified context informations
if (setContextInformation(cInfo) != 0) {
throwPcscException(env, obj, "SCardDisconnect", "PC/SC Wrapper Error: update of context information record failed", 0);
return;
}
return;
}
static uint32 handle_Disconnect(IRP* irp)
{
LONG rv;
SCARDCONTEXT hContext;
SCARDHANDLE hCard;
DWORD dwDisposition = 0;
stream_seek(irp->input, 0x20);
stream_read_uint32(irp->input, dwDisposition);
stream_seek(irp->input, 4);
stream_read_uint32(irp->input, hContext);
stream_seek(irp->input, 4);
stream_read_uint32(irp->input, hCard);
DEBUG_SCARD("(context: 0x%08x, hcard: 0x%08x, disposition: 0x%08x)",
(unsigned) hContext, (unsigned) hCard, (unsigned) dwDisposition);
rv = SCardDisconnect(hCard, (DWORD) dwDisposition);
if (rv != SCARD_S_SUCCESS)
DEBUG_SCARD("Failure: %s (0x%08x)", pcsc_stringify_error(rv), (unsigned) rv);
else
DEBUG_SCARD("Success");
sc_output_alignment(irp, 8);
return rv;
}
static void smartcard_check_status (SCARDCONTEXT hContext,
const char* pReader,
SCARDHANDLE hCardHandle, /* Can be 0 on the first call */
SCARDHANDLE* newCardHandle, /* The handle returned */
DWORD* pdwState) {
DWORD shareMode = SCARD_SHARE_SHARED;
DWORD preferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
DWORD dwAP;
LONG result;
if (hCardHandle == 0) {
result = SCardConnect(hContext, pReader, shareMode, preferredProtocols, &hCardHandle, &dwAP);
DEBUG_SCARD_STATUS("SCardConnect", result);
if (SCARD_S_SUCCESS != result) {
hCardHandle = 0;
}
}
char szReader[200];
DWORD cch = sizeof(szReader);
BYTE bAttr[32];
DWORD cByte = 32;
size_t countStatusAttempts = 0;
while (hCardHandle && (countStatusAttempts < 2)) {
*pdwState = SCARD_UNKNOWN;
result = SCardStatus(hCardHandle, /* Unfortunately we can't use NULL here */ szReader, &cch, pdwState, NULL, (LPBYTE)&bAttr, &cByte);
DEBUG_SCARD_STATUS("SCardStatus", result);
countStatusAttempts++;
if ((SCARD_W_RESET_CARD == result) && (countStatusAttempts < 2)) {
result = SCardReconnect(hCardHandle, shareMode, preferredProtocols, SCARD_RESET_CARD, &dwAP);
DEBUG_SCARD_STATUS("SCardReconnect", result);
if (SCARD_S_SUCCESS != result) {
break;
}
}
else {
break;
}
}
if (SCARD_S_SUCCESS != result) {
if (SCARD_E_NO_SMARTCARD == result || SCARD_W_REMOVED_CARD == result) {
*pdwState = SCARD_ABSENT;
}
else {
*pdwState = SCARD_UNKNOWN;
}
}
if (newCardHandle == NULL) {
result = SCardDisconnect(hCardHandle, SCARD_LEAVE_CARD);
DEBUG_SCARD_STATUS("SCardDisconnect", result);
}
else {
*newCardHandle = hCardHandle;
}
}
silvia_pcsc_card::~silvia_pcsc_card()
{
if (connected)
{
SCardDisconnect(card_handle, SCARD_UNPOWER_CARD);
}
}
logicalaccess::PCSCConnection::~PCSCConnection()
{
if (handle_)
{
SCardDisconnect(handle_, SCARD_LEAVE_CARD);
}
}
BOOL PCSC_IccDisconnect (MRTD_CTX_ST * ctx)
{
LONG rc;
if (ctx == NULL)
return FALSE;
if (!ctx->pcsc_reader)
return FALSE;
if (ctx->reader.pcsc.hcard)
{
rc = SCardDisconnect (ctx->reader.pcsc.hcard, SCARD_EJECT_CARD);
if (rc != SCARD_S_SUCCESS)
{
MrtdVerbose("SCardDisconnect : PC/SC error %08lX", rc);
}
ctx->reader.pcsc.hcard = 0;
}
if (ctx->reader.pcsc.hcontext)
{
SCardReleaseContext (ctx->reader.pcsc.hcontext);
if (rc != SCARD_S_SUCCESS)
{
MrtdVerbose("SCardReleaseContext : PC/SC error %08lX", rc);
}
ctx->reader.pcsc.hcontext = 0;
}
ctx->pcsc_reader = FALSE;
return TRUE;
}
static long sendAPDUS(SCARDCONTEXT ctx, const char *readerName, int apduCount, const char **apdus)
{
SCARDHANDLE hCard;
DWORD protocol;
char debugString[2048];
printf("Using reader \"%s\"\n\n", readerName);
sprintf_s(debugString, 2047, "Using reader \"%s\"\n\n", readerName);
DebugMessage(debugString);
long ret = SCardConnectA(ctx, readerName,
SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &hCard, &protocol);
CHECK_PCSC_RET("SCardConnect", ret);
if (SCARD_S_SUCCESS == ret)
{
unsigned char recvBuf[258];
DWORD recvBufLen;
for (int i = 0; i < apduCount; i++)
{
recvBufLen = (DWORD) sizeof(recvBuf);
sendAPDU(hCard, apdus[i], recvBuf, &recvBufLen, NULL, 0, true);
}
ret = SCardDisconnect(hCard, SCARD_LEAVE_CARD);
CHECK_PCSC_RET("SCardDisconnect", ret);
}
return 0;
}
//PCSCREADERDLL_API LONG CCONV PCSC_GetReaderList(HANDLE ContextNo, int * ReaderCount, char ResponseBuffer[MAX_READER_NAME])
PCSCREADERDLL_API LONG CCONV PCSC_GetReaderList(int * ReaderCount, char ResponseBuffer[MAX_READER_NAME])
{
unsigned long ResponseLength;
int j, StringLen;
unsigned char ReaderNameTmp[MAX_READER_NAME];
ret = SCardEstablishContext(SCARD_SCOPE_USER, NULL, NULL, &ContextHandle);
if (ret != SCARD_S_SUCCESS)
{
return ret;
}
//The SCardListCards function searches the smart card database
//and provides a list of named cards previously introduced to the system by the user.
//
//The caller specifies an ATR string, a set of interface identifiers (GUIDs), or both.
//If both an ATR string and an identifier array are supplied, the cards returned
//will match the ATR string supplied and support the interfaces specified.
ret = SCardListReaders(ContextHandle, NULL, NULL, &ResponseLength);
if (ret != SCARD_S_SUCCESS)
{
return ret;
}
ret = SCardListReaders(ContextHandle, NULL, (char *)ResponseBuffer, &ResponseLength);
if (ret != SCARD_S_SUCCESS)
{
return ret;
}
j=0;
// ReaderID = 0;
StringLen = 0;
while ((unsigned long)StringLen < (ResponseLength - 1))
{
strcpy((char*)ReaderNameTmp, (char*)ResponseBuffer+StringLen);
ret = SCardConnect(ContextHandle, (char *)ReaderNameTmp, SCARD_SHARE_DIRECT, 0, &SCardHandle, &ActiveProtocol);
if ((ret == SCARD_S_SUCCESS)||(ret == SCARD_W_REMOVED_CARD))
{
j++;
ReaderStatus[j-1][0]=0;
ReaderStatus[j-1][1]=0;
SCardDisconnect(SCardHandle, SCARD_EJECT_CARD);
StringLen += (int)strlen((char*)ReaderNameTmp);
StringLen += 1;
}
else{
return ret;
}
}
*ReaderCount = j;
return EXCUTE_SUC ;
}
static int32_t pcsc_close(struct s_reader *pcsc_reader)
{
struct pcsc_data *crdr_data = pcsc_reader->crdr_data;
rdr_log_dbg(pcsc_reader, D_IFD, "PCSC : Closing device %s", pcsc_reader->device);
SCardDisconnect(crdr_data->hCard, SCARD_LEAVE_CARD);
SCardReleaseContext(crdr_data->hContext);
return OK;
}
void QPCSCReader::disconnect( Reset reset )
{
if( d->card )
SCardDisconnect( d->card, reset );
d->proto = 0;
d->card = 0;
d->updateState();
}
void pcsc_close(struct s_reader *pcsc_reader)
{
rdr_debug_mask(pcsc_reader, D_IFD, "PCSC : Closing device %s", pcsc_reader->device);
SCardDisconnect((SCARDHANDLE)(pcsc_reader->hCard),SCARD_LEAVE_CARD);
SCardReleaseContext(pcsc_reader->hContext);
pcsc_reader->hCard=0;
pcsc_reader->pcsc_has_card=0;
}
JNIEXPORT jint JNICALL GEN_FUNCNAME(Card_NativeDisconnect)
(JNIEnv *env, jobject _this, jint param)
{
SCARDHANDLE card;
card = (SCARDHANDLE) (*env)->GetLongField(env, _this, CardField);
return SCardDisconnect(card, param);
}
long CardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
{
long lRet = SCardDisconnect(hCard, dwDisposition);
//printf("SCardDisconnect(hCard=0x%0x, disp=0x%0x): r = 0x%0x (%d)\n\n",
// hCard, dwDisposition, lRet, lRet);
return lRet;
}
void
acr122_close (nfc_device *pnd)
{
SCardDisconnect (DRIVER_DATA (pnd)->hCard, SCARD_LEAVE_CARD);
acr122_free_scardcontext ();
pn53x_data_free (pnd);
nfc_device_free (pnd);
}
int
Test_CardConnecting()
{
int trycnt;
long result;
printf("==============================================================\n");
printf("Part B : Card Connect/Disconnect\n");
printf("==============================================================\n");
trycnt = 0;
printf("Testing");
while(trycnt < 5)
{
trycnt++;
printf("...");
#ifdef LINUX_OS
fflush(stdout);
#endif
result = SCardConnect( ScardContext,
ScardReaderState[CurrentReader].szReader,
SCARD_SHARE_EXCLUSIVE,
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,
&ScardHandle[CurrentReader],
&ScardProtocol[CurrentReader]);
if(result != SCARD_S_SUCCESS)
{
MyPrintf(strlen("Testing"), strlen("..."), trycnt * 2 - 1, "Failed\n");
PRINTERR(("SCardConnect Fail : %08X\n", result));
return FALSE;
}
printf("...");
#ifdef LINUX_OS
fflush(stdout);
#endif
result = SCardDisconnect(ScardHandle[CurrentReader],
SCARD_UNPOWER_CARD);
if(result != SCARD_S_SUCCESS)
{
MyPrintf(strlen("Testing"), strlen("..."), trycnt * 2, "Failed\n");
PRINTERR(("SCardDisconnect Fail : %08X\n", result));
return FALSE;
}
}
MyPrintf(strlen("Testing"), strlen("..."), trycnt * 2, "Passed\n");
printf("\n Part B Test Successfully\n\n");
return TRUE;
}
/*
* utilities for creating and destroying the private applet data
*/
static void
passthru_delete_applet_private(VCardAppletPrivate *applet_private)
{
if (applet_private == NULL) {
return;
}
if (applet_private->hCard) {
SCardDisconnect(applet_private->hCard,SCARD_LEAVE_CARD);
}
if (applet_private->reader_name != NULL) {
free(applet_private->reader_name);
}
free(applet_private);
}
int CPCSCMngr::CloseSession() {
int status = STAT_OK;
// CLOSE ACTUAL SESION
if (m_hCard) {
SCardDisconnect(m_hCard, SCARD_LEAVE_CARD);
m_hCard = NULL;
}
if (m_cardContext) {
SCardReleaseContext(m_cardContext);
m_cardContext = NULL;
}
return status;
}
LC_CLIENT_RESULT LC_Client_ReleaseCard(LC_CLIENT *cl, LC_CARD *card) {
LONG rv;
assert(cl);
assert(card);
rv=SCardDisconnect(LC_Card_GetSCardHandle(card), SCARD_RESET_CARD);
if (rv!=SCARD_S_SUCCESS) {
DBG_ERROR(LC_LOGDOMAIN, "SCardDisconnect: %04lx", (long unsigned int) rv);
return LC_Client_ResultIoError;
}
return LC_Client_ResultOk;
}
bool CPCSCClass::Disconnect(DWORD EndDisposition)
{
RetCode = SCardDisconnect(hCard,EndDisposition);
if (RetCode != SCARD_S_SUCCESS)
{
mylog.AddToLogs(m_logobj,"error: SCardDisconnect failed");
mylog.AddToLogs(m_logobj,TranslatePCSCError());
return false;
}
mylog.AddToLogs(m_logobj,"SCardDisconnect Success");
return true;
}
static UINT32 smartcard_Disconnect_Call(SMARTCARD_DEVICE* smartcard, SMARTCARD_OPERATION* operation, HCardAndDisposition_Call* call)
{
LONG status;
Long_Return ret;
status = ret.ReturnCode = SCardDisconnect(operation->hCard, call->dwDisposition);
smartcard_trace_long_return(smartcard, &ret, "Disconnect");
if (status != SCARD_S_SUCCESS)
return status;
return ret.ReturnCode;
}
int closePCSCSlot(struct p11Slot_t *slot)
{
LONG rc;
FUNC_CALLED();
#ifdef DEBUG
debug("Trying to close slot (%i, %s)\n", slot->id, slot->readername);
#endif
slotCounter--;
if (slotCounter == 0 && globalContext) {
#ifdef DEBUG
debug("Releasing global PC/SC context\n");
#endif
rc = SCardReleaseContext(globalContext);
#ifdef DEBUG
debug("SCardReleaseContext (%i, %s): %s\n", slot->id, slot->readername, pcsc_error_to_string(rc));
#endif
globalContext = 0;
}
/* No token in slot */
if (!slot->card) {
slot->closed = TRUE;
FUNC_RETURNS(CKR_OK);
}
rc = SCardDisconnect(slot->card, SCARD_UNPOWER_CARD);
#ifdef DEBUG
debug("SCardDisconnect (%i, %s): %s\n", slot->id, slot->readername, pcsc_error_to_string(rc));
debug("Releasing slot specific PC/SC context - slot counter is %i\n", slotCounter);
#endif
rc = SCardReleaseContext(slot->context);
#ifdef DEBUG
debug("SCardReleaseContext (%i, %s): %s\n", slot->id, slot->readername, pcsc_error_to_string(rc));
#endif
slot->context = 0;
slot->card = 0;
slot->closed = TRUE;
FUNC_RETURNS(CKR_OK);
}
static int testCardFunctionality(SCARDCONTEXT ctx, const char *readerName)
{
SCARDHANDLE hCard;
DWORD protocol;
int errCount = 0;
printf("Using reader \"%s\"\n\n", readerName);
long ret = SCardConnectA(ctx, readerName,
SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &hCard, &protocol);
CHECK_PCSC_RET("SCardConnect", ret);
if (SCARD_S_SUCCESS == ret)
{
delayMS(200);
printf("--- Get Response tests ---\n");
errCount += testGetResponse(hCard);
printf("\n--- Get Response tests within a transaction ---\n");
ret = SCardBeginTransaction(hCard);
CHECK_PCSC_RET("SCardBeginTransaction", ret);
errCount += testGetResponse(hCard);
ret = SCardEndTransaction(hCard, SCARD_LEAVE_CARD);
CHECK_PCSC_RET("SCardBeginTransaction", ret);
printf("\n--- Test reading a long file ---\n");
errCount += testLongFileRead(hCard);
printf("\n--- Test reading a long file within a transaction ---\n");
ret = SCardBeginTransaction(hCard);
CHECK_PCSC_RET("SCardBeginTransaction", ret);
errCount += testLongFileRead(hCard);
ret = SCardEndTransaction(hCard, SCARD_LEAVE_CARD);
CHECK_PCSC_RET("SCardBeginTransaction", ret);
printf("\n--- Misc tests ---\n");
errCount += testMisc(hCard);
ret = SCardDisconnect(hCard, SCARD_LEAVE_CARD);
CHECK_PCSC_RET("SCardDisconnect", ret);
}
if (errCount == 0)
printf("\nFunctional tests done, no errors\n");
else
printf("\nFunctional tests done, %d errors\n", errCount);
return 0;
}
static int testConnect(SCARDCONTEXT ctx, const char *readerName)
{
int returnValue = 0;
SCARDHANDLE hCard;
DWORD protocol;
long ret = SCardConnectA(ctx, readerName,
SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &hCard, &protocol);
if (SCARD_S_SUCCESS != ret)
returnValue |= 0x1; //-------1
if (SCARD_S_SUCCESS == ret)
{
delayMS(200);
unsigned char recvBuf[258];
DWORD recvBufLen;
recvBufLen = (DWORD) sizeof(recvBuf);
sendAPDU(hCard, "00:A4:04:0C:0C:A0:00:00:01:77:50:4B:43:53:2D:31:35", recvBuf, &recvBufLen, NULL, 0, true);
if (!(recvBufLen == 2))
returnValue |= 0x2; //------1-
if (!(recvBuf[0] == 0x90 && recvBuf[1] == 0x00))
returnValue |= 0x2; //------1-
ret = SCardDisconnect(hCard, SCARD_LEAVE_CARD);
if (SCARD_S_SUCCESS != ret)
returnValue |= 0x4; //-----1--
ret = SCardDisconnect(1111, SCARD_LEAVE_CARD);
if (SCARD_S_SUCCESS == ret)
returnValue |= 0x4; //-----1--
}
return returnValue;
}
/**
* checkForRemovedPCSCToken looks into a specific slot for a removed token.
*
* @param slot Pointer to slot structure.
*
* @return
* <P><TABLE>
* <TR><TD>Code</TD><TD>Meaning</TD></TR>
* <TR>
* <TD>CKR_OK </TD>
* <TD>Success </TD>
* </TR>
* <TR>
* <TD>CKR_HOST_MEMORY </TD>
* <TD>Error getting memory (malloc) </TD>
* </TR>
* <TR>
* <TD>CKR_GENERAL_ERROR </TD>
* <TD>Error opening slot directory </TD>
* </TR>
* </TABLE></P>
*/
static int checkForRemovedPCSCToken(struct p11Slot_t *slot)
{
int rc;
LONG rv;
FUNC_CALLED();
if (slot->closed) {
FUNC_RETURNS(CKR_TOKEN_NOT_PRESENT);
}
if (!slot->card) {
FUNC_RETURNS(CKR_TOKEN_NOT_PRESENT);
}
rv = SCardStatus(slot->card, NULL, 0, 0, 0, 0, 0);
#ifdef DEBUG
debug("SCardStatus: %s\n", pcsc_error_to_string(rv));
#endif
if (rv == SCARD_S_SUCCESS) {
FUNC_RETURNS(CKR_OK);
} else if ((rv == SCARD_W_REMOVED_CARD) || (rv == SCARD_E_INVALID_HANDLE) || (rv == SCARD_E_READER_UNAVAILABLE)) {
rc = removeToken(slot);
if (rc != CKR_OK) {
FUNC_RETURNS(rc);
}
rc = SCardDisconnect(slot->card, SCARD_UNPOWER_CARD);
#ifdef DEBUG
debug("SCardDisconnect (%i, %s): %s\n", slot->id, slot->readername, pcsc_error_to_string(rc));
#endif
// Check if a new token was inserted in the meantime
rc = checkForNewPCSCToken(slot);
if (rc == CKR_TOKEN_NOT_PRESENT) {
FUNC_RETURNS(CKR_DEVICE_REMOVED);
}
} else {
FUNC_FAILS(CKR_DEVICE_ERROR, "Error getting PC/SC card terminal status");
}
FUNC_RETURNS(rc);
}
/* -------------------------------------------------------------------------- */
LONG sc_done (sc_context *ctx, DWORD lvSt)
{
LONG rc=SCARD_S_SUCCESS;
register BYTE i=0xFF;
rc=SCardDisconnect(ctx->hCard, lvSt); /* SCARD_LEAVE_CARD); */
if (rc==SCARD_S_SUCCESS)
{
if (ctx->rdr != NULL) SCardFreeMemory( ctx->hCtx, ctx->rdr);
ctx->rdrsz=0; ctx->rdr = NULL;
rc=SCardReleaseContext(ctx->hCtx);
}
while(i-- > 0) ctx->sw[i]=0;
ctx->rw = 0;
return rc;
} /* sc_finish */
static int pcsc_disconnect(cardreader_t *cr)
{
pcsc_data_t* pcsc = cr->extra_data;
pcsc->status = SCardDisconnect(pcsc->hcard,SCARD_UNPOWER_CARD);
if (pcsc->status==SCARD_S_SUCCESS)
{
cr->connected=0;
log_printf(LOG_INFO,"Disconnected reader");
return 1;
}
log_printf(LOG_ERROR,"Failed to disconnect reader: %s (error 0x%08x).",
pcsc_stringify_error(pcsc->status),
pcsc->status );
return 0;
}
BOOL TestDesfire(SCARDCONTEXT hContext, const char *szReader)
{
SCARDHANDLE hCard;
DWORD dwProtocol;
LONG rc;
BOOL f;
printf("Testing the Desfire library on this card...\n");
/*
* Connect to the card, accept either T=0 or T=1
* ---------------------------------------------
*/
rc = SCardConnect(hContext,
szReader,
SCARD_SHARE_SHARED,
SCARD_PROTOCOL_T0|SCARD_PROTOCOL_T1,
&hCard,
&dwProtocol);
if (rc != SCARD_S_SUCCESS)
{
printf("\tSCardConnect error %08lX\n",rc);
return FALSE;
}
printf("\tConnected to the card, protocol ");
switch (dwProtocol)
{
case SCARD_PROTOCOL_T0 : printf("T=0"); break;
case SCARD_PROTOCOL_T1 : printf("T=1"); break;
default : printf("%08lX", dwProtocol);
}
printf("\n");
SCardDesfire_AttachLibrary(hCard);
f = TestDesfire_Ex(hCard);
SCardDesfire_DetachLibrary(hCard);
SCardDisconnect(hCard, SCARD_EJECT_CARD);
printf("\n\n\n");
return f;
}
