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; }