You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
675 lines
20 KiB
675 lines
20 KiB
// CardFinder.cpp -- CardFinder class implementation
|
|
|
|
// (c) Copyright Schlumberger Technology Corp., unpublished work, created
|
|
// 1999. This computer program includes Confidential, Proprietary
|
|
// Information and is a Trade Secret of Schlumberger Technology Corp. All
|
|
// use, disclosure, and/or reproduction is prohibited unless authorized
|
|
// in writing. All Rights Reserved.
|
|
|
|
#if defined(_UNICODE)
|
|
#if !defined(UNICODE)
|
|
#define UNICODE
|
|
#endif //!UNICODE
|
|
#endif //_UNICODE
|
|
|
|
#if defined(UNICODE)
|
|
#if !defined(_UNICODE)
|
|
#define _UNICODE
|
|
#endif //!_UNICODE
|
|
#endif //UNICODE
|
|
|
|
#include "StdAfx.h"
|
|
|
|
#include <string>
|
|
#include <numeric>
|
|
|
|
#include <Windows.h>
|
|
#include <WinUser.h>
|
|
|
|
#include <scuOsExc.h>
|
|
#include <scuCast.h>
|
|
|
|
#include "PromptUser.h"
|
|
#include "CardFinder.h"
|
|
#include "CspProfile.h"
|
|
#include "StResource.h"
|
|
#include "ExceptionContext.h"
|
|
#include "Blob.h"
|
|
|
|
using namespace std;
|
|
using namespace scu;
|
|
using namespace cci;
|
|
using namespace ProviderProfile;
|
|
|
|
using CardFinder::DialogDisplayMode;
|
|
|
|
/////////////////////////// LOCAL/HELPER /////////////////////////////////
|
|
|
|
namespace
|
|
{
|
|
// Lengths as specified by OPENCARDNAME
|
|
size_t const cMaxCardNameLength = 256;
|
|
size_t const cMaxReaderNameLength = 256;
|
|
|
|
// In a preemptive, multi-threaded, environment it's assumed
|
|
// access to these scratch buffers does not need to be mutually
|
|
// exclusive.
|
|
TCHAR CardNamesScratchBuffer[cMaxCardNameLength];
|
|
TCHAR ReaderNamesScratchBuffer[cMaxReaderNameLength];
|
|
|
|
DWORD
|
|
AsDialogFlag(DialogDisplayMode ddm)
|
|
{
|
|
DWORD dwDialogFlag;
|
|
|
|
switch (ddm)
|
|
{
|
|
case CardFinder::ddmNever:
|
|
dwDialogFlag = SC_DLG_NO_UI;
|
|
break;
|
|
|
|
case CardFinder::ddmIfNecessary:
|
|
dwDialogFlag = SC_DLG_MINIMAL_UI;
|
|
break;
|
|
|
|
case CardFinder::ddmAlways:
|
|
dwDialogFlag = SC_DLG_FORCE_UI;
|
|
break;
|
|
|
|
default:
|
|
throw scu::OsException(E_INVALIDARG);
|
|
}
|
|
|
|
return dwDialogFlag;
|
|
}
|
|
|
|
vector<string> &
|
|
CardNameAccumulator(vector<string> &rvs,
|
|
CardProfile &rcp)
|
|
{
|
|
rvs.push_back(rcp.RegistryName());
|
|
return rvs;
|
|
}
|
|
|
|
vector<CString>
|
|
csCardNameAccumulator(vector<CString> &rvs,
|
|
CardProfile &rcp)
|
|
{
|
|
rvs.push_back(rcp.csRegistryName());
|
|
return rvs;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
/////////////////////////// PUBLIC /////////////////////////////////
|
|
|
|
// Types
|
|
// C'tors/D'tors
|
|
CardFinder::CardFinder(DialogDisplayMode ddm,
|
|
HWND hwnd,
|
|
CString const &rsDialogTitle)
|
|
: m_sDialogTitle(rsDialogTitle),
|
|
m_ddm(ddm),
|
|
m_hwnd(hwnd),
|
|
m_apmszSupportedCards(),
|
|
m_opcnDlgCtrl(),
|
|
#if SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
m_opcnCriteria(),
|
|
m_sInsertPrompt(StringResource(IDS_INS_SLB_CRYPTO_CARD).AsCString()),
|
|
#endif
|
|
m_cspec(),
|
|
m_hscardctx()
|
|
{
|
|
|
|
m_hscardctx.Establish();
|
|
|
|
// TO DO: Since the CCI doesn't provide enough information about
|
|
// the cards, the CSP creates its own version for CSP
|
|
// registration. Rather than use the CCI's KnownCards routine to
|
|
// get the card names, the CSPs version is used until the CCI
|
|
// provides enough information.
|
|
vector<CardProfile> vcp(CspProfile::Instance().Cards());
|
|
m_apmszSupportedCards =
|
|
auto_ptr<MultiStringZ>(new MultiStringZ(accumulate(vcp.begin(),
|
|
vcp.end(),
|
|
vector<CString>(),
|
|
csCardNameAccumulator)));
|
|
|
|
// Fill the Open Card Name Dialog, pvUserData which is set by
|
|
// DoFind.
|
|
m_opcnDlgCtrl.dwStructSize = sizeof(m_opcnDlgCtrl); // REQUIRED
|
|
m_opcnDlgCtrl.hSCardContext = m_hscardctx.AsSCARDCONTEXT(); // REQUIRED
|
|
m_opcnDlgCtrl.hwndOwner = m_hwnd; // OPTIONAL
|
|
m_opcnDlgCtrl.dwFlags = AsDialogFlag(DisplayMode()); // OPTIONAL -- default is SC_DLG_MINIMAL_UI
|
|
m_opcnDlgCtrl.lpstrTitle = (LPCTSTR)m_sDialogTitle; // OPTIONAL
|
|
m_opcnDlgCtrl.dwShareMode = SCARD_SHARE_SHARED; // OPTIONAL - if lpfnConnect is NULL, dwShareMode and
|
|
m_opcnDlgCtrl.dwPreferredProtocols = SCARD_PROTOCOL_T0; // OPTIONAL dwPreferredProtocols will be used to
|
|
// connect to the selected card
|
|
m_opcnDlgCtrl.lpstrRdr = ReaderNamesScratchBuffer; // REQUIRED [IN|OUT] Name of selected reader
|
|
m_opcnDlgCtrl.nMaxRdr = sizeof ReaderNamesScratchBuffer /
|
|
sizeof *ReaderNamesScratchBuffer; // REQUIRED [IN|OUT]
|
|
m_opcnDlgCtrl.lpstrCard = CardNamesScratchBuffer; // REQUIRED [IN|OUT] Name of selected card
|
|
m_opcnDlgCtrl.nMaxCard = sizeof CardNamesScratchBuffer /
|
|
sizeof *CardNamesScratchBuffer; // REQUIRED [IN|OUT]
|
|
m_opcnDlgCtrl.dwActiveProtocol = 0; // [OUT] set only if dwShareMode not NULL
|
|
m_opcnDlgCtrl.hCardHandle = NULL; // [OUT] set if a card connection was indicated
|
|
|
|
CheckFn(IsValid);
|
|
ConnectFn(Connect);
|
|
DisconnectFn(Disconnect);
|
|
|
|
#if !SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
|
|
m_opcnDlgCtrl.lpstrGroupNames = 0;
|
|
m_opcnDlgCtrl.nMaxGroupNames = 0;
|
|
m_opcnDlgCtrl.lpstrCardNames = (LPTSTR)m_apmszSupportedCards->csData();
|
|
m_opcnDlgCtrl.nMaxCardNames = m_apmszSupportedCards->csLength();
|
|
m_opcnDlgCtrl.rgguidInterfaces = 0;
|
|
m_opcnDlgCtrl.cguidInterfaces = 0;
|
|
|
|
#else
|
|
m_opcnDlgCtrl.lpstrSearchDesc = (LPCTSTR)m_sInsertPrompt; // OPTIONAL (eg. "Please insert your <brandname> smart card.")
|
|
m_opcnDlgCtrl.hIcon = NULL; // OPTIONAL 32x32 icon for your brand insignia
|
|
m_opcnDlgCtrl.pOpenCardSearchCriteria = &m_opcnCriteria; // OPTIONAL
|
|
|
|
m_opcnCriteria.dwStructSize = sizeof(m_opcnCriteria);
|
|
m_opcnCriteria.lpstrGroupNames = 0; // OPTIONAL reader groups to include in
|
|
m_opcnCriteria.nMaxGroupNames = 0; // search. NULL defaults to
|
|
// SCard$DefaultReaders
|
|
m_opcnCriteria.rgguidInterfaces = 0; // OPTIONAL requested interfaces
|
|
m_opcnCriteria.cguidInterfaces = 0; // supported by card's SSP
|
|
m_opcnCriteria.lpstrCardNames = (LPTSTR)m_apmszSupportedCards->csData(); // OPTIONAL requested card names; all cards w/
|
|
m_opcnCriteria.nMaxCardNames = m_apmszSupportedCards->csLength(); // matching ATRs will be accepted
|
|
m_opcnCriteria.dwShareMode = SCARD_SHARE_SHARED; // OPTIONAL must be set if lpfnCheck is not null
|
|
m_opcnCriteria.dwPreferredProtocols = SCARD_PROTOCOL_T0; // OPTIONAL
|
|
|
|
#endif // !SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
|
|
}
|
|
|
|
CardFinder::~CardFinder()
|
|
{}
|
|
|
|
// Operators
|
|
// Operations
|
|
|
|
Secured<HCardContext>
|
|
CardFinder::Find(CSpec const &rcsReader)
|
|
{
|
|
DoFind(rcsReader);
|
|
|
|
return CardFound();
|
|
}
|
|
|
|
// Access
|
|
|
|
DialogDisplayMode
|
|
CardFinder::DisplayMode() const
|
|
{
|
|
return m_ddm;
|
|
}
|
|
|
|
HWND
|
|
CardFinder::Window() const
|
|
{
|
|
return m_hwnd;
|
|
}
|
|
|
|
// Predicates
|
|
// Static Variables
|
|
|
|
/////////////////////////// PROTECTED /////////////////////////////////
|
|
|
|
// C'tors/D'tors
|
|
// Operators
|
|
// Operations
|
|
|
|
void
|
|
CardFinder::CardFound(Secured<HCardContext> const &rshcardctx)
|
|
{
|
|
m_shcardctx = rshcardctx;
|
|
}
|
|
|
|
SCARDHANDLE
|
|
CardFinder::DoConnect(string const &rsSelectedReader)
|
|
{
|
|
SCARDHANDLE hSCard = reinterpret_cast<SCARDHANDLE>(INVALID_HANDLE_VALUE);
|
|
|
|
// If the reader spec's match...
|
|
if (CSpec::Equiv(CardSpec().Reader(), rsSelectedReader))
|
|
{
|
|
HCardContext hcardctx(rsSelectedReader);
|
|
CardFound(Secured<HCardContext>(hcardctx));
|
|
}
|
|
else
|
|
{
|
|
CardFound(Secured<HCardContext>(0));
|
|
hSCard = 0;
|
|
}
|
|
|
|
return hSCard;
|
|
}
|
|
|
|
void
|
|
CardFinder::DoDisconnect()
|
|
{
|
|
CardFound(Secured<HCardContext>(0));
|
|
}
|
|
|
|
void
|
|
CardFinder::DoFind(CSpec const &rcspec)
|
|
{
|
|
m_cspec = rcspec;
|
|
|
|
// Bind to the callers call context
|
|
UserData(reinterpret_cast<void *>(this));
|
|
|
|
// Cache to override later
|
|
OpenCardNameType opencardname(m_opcnDlgCtrl);
|
|
bool fContinue = true;
|
|
|
|
do
|
|
{
|
|
DWORD dwStatus(SelectCard(opencardname));
|
|
DoProcessSelection(dwStatus, opencardname, fContinue);
|
|
} while (fContinue);
|
|
|
|
OnError();
|
|
}
|
|
|
|
void
|
|
CardFinder::DoOnError()
|
|
{
|
|
scu::Exception const *pexc = Exception();
|
|
if (pexc && (ddmNever != DisplayMode()))
|
|
{
|
|
switch (pexc->Facility())
|
|
{
|
|
case scu::Exception::fcOS:
|
|
{
|
|
OsException const *pOsExc =
|
|
DownCast<OsException const *>(pexc);
|
|
switch (pOsExc->Cause())
|
|
{
|
|
case SCARD_E_UNSUPPORTED_FEATURE:
|
|
YNPrompt(IDS_NOT_CAPI_ENABLED);
|
|
ClearException();
|
|
break;
|
|
|
|
case ERROR_INVALID_PARAMETER:
|
|
YNPrompt(IDS_READER_NOT_MATCH);
|
|
ClearException();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case scu::Exception::fcCCI:
|
|
{
|
|
cci::Exception const *pCciExc =
|
|
DownCast<cci::Exception const *>(pexc);
|
|
if (ccNotPersonalized == pCciExc->Cause())
|
|
{
|
|
YNPrompt(IDS_CARD_NOT_INIT);
|
|
ClearException();
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CardFinder::DoProcessSelection(DWORD dwStatus,
|
|
OpenCardNameType &ropencardname,
|
|
bool &rfContinue)
|
|
{
|
|
rfContinue = true;
|
|
|
|
// Handle the error conditions
|
|
if (Exception() &&
|
|
!((SCARD_E_CANCELLED == dwStatus) ||
|
|
(SCARD_W_CANCELLED_BY_USER == dwStatus)))
|
|
rfContinue = false;
|
|
else
|
|
{
|
|
WorkaroundOpenCardDefect(ropencardname, dwStatus);
|
|
|
|
if (SCARD_S_SUCCESS != dwStatus)
|
|
{
|
|
// Translate the cancellation error as needed.
|
|
if ((SCARD_E_CANCELLED == dwStatus) ||
|
|
(SCARD_W_CANCELLED_BY_USER == dwStatus))
|
|
{
|
|
if (ddmNever == DisplayMode())
|
|
{
|
|
if ((SCARD_E_CANCELLED == dwStatus) &&
|
|
!CardFound())
|
|
// SCARD_E_NO_SMARTCARD is returned
|
|
// because the Smart Card Dialog will
|
|
// return SCARD_E_CANCELLED when the GUI
|
|
// is not allowed and there is no smart
|
|
// card in the reader, so the error is
|
|
// translated here.
|
|
dwStatus = SCARD_E_NO_SMARTCARD;
|
|
else
|
|
// NTE_BAD_KEYSET is returned because some version
|
|
// of a Microsoft application would go into an
|
|
// infinite loop when ERROR_CANCELLED was returned
|
|
// under these conditions. Doug Barlow at
|
|
// Microsoft noticed the behaviour and implemented
|
|
// the workaround. It's unclear what that
|
|
// application was and if the workaround remains
|
|
// necessary.
|
|
dwStatus = NTE_BAD_KEYSET; // how can this happen?
|
|
}
|
|
else
|
|
dwStatus = ERROR_CANCELLED;
|
|
}
|
|
|
|
Exception(auto_ptr<scu::Exception const>(scu::OsException(dwStatus).Clone()));
|
|
rfContinue = false;
|
|
}
|
|
else
|
|
rfContinue = false;
|
|
}
|
|
|
|
if (SC_DLG_MINIMAL_UI == ropencardname.dwFlags)
|
|
ropencardname.dwFlags = SC_DLG_FORCE_UI;
|
|
}
|
|
|
|
void
|
|
CardFinder::YNPrompt(UINT uID) const
|
|
{
|
|
int iResponse = PromptUser(Window(), uID, MB_YESNO | MB_ICONWARNING);
|
|
|
|
switch (iResponse)
|
|
{
|
|
case IDABORT: // fall-through intentional
|
|
case IDCANCEL:
|
|
case IDNO:
|
|
throw scu::OsException(ERROR_CANCELLED);
|
|
break;
|
|
|
|
case IDOK:
|
|
case IDYES:
|
|
case IDRETRY:
|
|
break;
|
|
|
|
case 0:
|
|
throw scu::OsException(GetLastError());
|
|
break;
|
|
|
|
default:
|
|
throw scu::OsException(ERROR_INTERNAL_ERROR);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Access
|
|
|
|
CSpec const &
|
|
CardFinder::CardSpec() const
|
|
{
|
|
return m_cspec;
|
|
}
|
|
|
|
Secured<HCardContext>
|
|
CardFinder::CardFound() const
|
|
{
|
|
return m_shcardctx;
|
|
}
|
|
|
|
// Predicates
|
|
|
|
bool
|
|
CardFinder::DoIsValid()
|
|
{
|
|
Secured<HCardContext> shcardctx(CardFound());
|
|
if (shcardctx &&
|
|
!shcardctx->Card()->IsCAPIEnabled())
|
|
throw scu::OsException(SCARD_E_UNSUPPORTED_FEATURE);
|
|
|
|
return (shcardctx != 0);
|
|
}
|
|
|
|
// Static Variables
|
|
|
|
|
|
/////////////////////////// PRIVATE /////////////////////////////////
|
|
|
|
// C'tors/D'tors
|
|
// Operators
|
|
// Operations
|
|
|
|
void
|
|
CardFinder::CheckFn(LPOCNCHKPROC lpfnCheck)
|
|
{
|
|
|
|
#if !SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
m_opcnDlgCtrl.lpfnCheck = lpfnCheck;
|
|
#else
|
|
m_opcnCriteria.lpfnCheck = lpfnCheck;
|
|
#endif
|
|
|
|
}
|
|
|
|
SCARDHANDLE __stdcall
|
|
CardFinder::Connect(SCARDCONTEXT scardctx,
|
|
LPTSTR szReader,
|
|
LPTSTR mszCards,
|
|
LPVOID lpvUserData)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CardFinder *pfinder =
|
|
reinterpret_cast<CardFinder *>(lpvUserData);
|
|
|
|
SCARDHANDLE hResult = reinterpret_cast<SCARDHANDLE>(INVALID_HANDLE_VALUE);
|
|
|
|
EXCCTX_TRY
|
|
{
|
|
// Starting fresh, clear any earler exception
|
|
pfinder->ClearException();
|
|
string sSelectedReader(StringResource::AsciiFromUnicode(szReader));
|
|
hResult =
|
|
pfinder->DoConnect(sSelectedReader);
|
|
}
|
|
|
|
EXCCTX_CATCH(pfinder, false);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
void
|
|
CardFinder::ConnectFn(LPOCNCONNPROC lpfnConnect)
|
|
{
|
|
|
|
m_opcnDlgCtrl.lpfnConnect = lpfnConnect;
|
|
|
|
#if SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
m_opcnCriteria.lpfnConnect = m_opcnDlgCtrl.lpfnConnect;
|
|
#endif
|
|
}
|
|
|
|
void __stdcall
|
|
CardFinder::Disconnect(SCARDCONTEXT scardctx,
|
|
SCARDHANDLE hSCard,
|
|
LPVOID lpvUserData)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CardFinder *pfinder =
|
|
reinterpret_cast<CardFinder *>(lpvUserData);
|
|
|
|
EXCCTX_TRY
|
|
{
|
|
pfinder->DoDisconnect();
|
|
}
|
|
|
|
EXCCTX_CATCH(pfinder, false);
|
|
}
|
|
|
|
void
|
|
CardFinder::DisconnectFn(LPOCNDSCPROC lpfnDisconnect)
|
|
{
|
|
|
|
#if !SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
m_opcnDlgCtrl.lpfnDisconnect = lpfnDisconnect;
|
|
#else
|
|
m_opcnCriteria.lpfnDisconnect = lpfnDisconnect;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
CardFinder::OnError()
|
|
{
|
|
if (Exception())
|
|
{
|
|
DoOnError();
|
|
PropagateException();
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
CardFinder::SelectCard(OpenCardNameType &ropcn)
|
|
{
|
|
#if !SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
return GetOpenCardName(&ropcn);
|
|
#else
|
|
return SCardUIDlgSelectCard(&ropcn);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
CardFinder::UserData(void *pvUserData)
|
|
{
|
|
m_opcnDlgCtrl.pvUserData = pvUserData;
|
|
|
|
#if SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
m_opcnCriteria.pvUserData = m_opcnDlgCtrl.pvUserData;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
CardFinder::WorkaroundOpenCardDefect(OpenCardNameType const &ropcnDlgCtrl,
|
|
DWORD &rdwStatus)
|
|
{
|
|
// On systems using Smart Card Kit v1.0 and prior (in other words
|
|
// systems prior to Windows 2000/NT 5.0), MS' GetOpenCardName
|
|
// (scarddlg.dll) has a defect that manifests when the check
|
|
// routine always returns FALSE. In this case, the common dialog
|
|
// will call connect routine one additional time without calling
|
|
// check or disconnect routine. Therefore upon return, it appears
|
|
// a card match was found when there really wasn't. The
|
|
// workaround is to make additional calls to the check routine
|
|
// after the call to GetOpenCardName. If there isn't a match,
|
|
// then the card is invalid and should act as if the card was not
|
|
// connected. Fortunately, this workaround behaves correctly on
|
|
// the good scarddlg.dll as well (post Smart Card Kit v1.0).
|
|
|
|
if (SCARD_S_SUCCESS == rdwStatus)
|
|
{
|
|
try
|
|
{
|
|
LPOCNCHKPROC lpfnCheck = CheckFn();
|
|
LPOCNDSCPROC lpfnDisconnect = DisconnectFn();
|
|
|
|
if (CardFound() &&
|
|
!lpfnCheck(ropcnDlgCtrl.hSCardContext, 0, this))
|
|
lpfnDisconnect(ropcnDlgCtrl.hSCardContext, 0, this);
|
|
|
|
if (!CardFound() &&
|
|
(SC_DLG_MINIMAL_UI == ropcnDlgCtrl.dwFlags))
|
|
{
|
|
// A card didn't matched and the user wasn't actually
|
|
// prompted, so force the smart card dialog to prompt
|
|
// the user to select a card.
|
|
lpfnDisconnect(ropcnDlgCtrl.hSCardContext, 0, this);
|
|
|
|
OpenCardNameType opencardname = ropcnDlgCtrl;
|
|
opencardname.dwFlags = SC_DLG_FORCE_UI;
|
|
|
|
rdwStatus = SelectCard(opencardname);
|
|
|
|
if ((SCARD_S_SUCCESS == rdwStatus) &&
|
|
!Exception() &&
|
|
!lpfnCheck(opencardname.hSCardContext, 0, this))
|
|
lpfnDisconnect(opencardname.hSCardContext, 0, this);
|
|
}
|
|
}
|
|
|
|
catch (...)
|
|
{
|
|
// propagate the exception here if one didn't occur in
|
|
// one of the callback routines.
|
|
if (!Exception())
|
|
throw;
|
|
}
|
|
|
|
OnError();
|
|
}
|
|
}
|
|
|
|
// Access
|
|
|
|
LPOCNCHKPROC
|
|
CardFinder::CheckFn() const
|
|
{
|
|
#if !SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
return m_opcnDlgCtrl.lpfnCheck;
|
|
#else
|
|
return m_opcnCriteria.lpfnCheck;
|
|
#endif
|
|
}
|
|
|
|
LPOCNDSCPROC
|
|
CardFinder::DisconnectFn() const
|
|
{
|
|
#if !SLBCSP_USE_SCARDUIDLGSELECTCARD
|
|
return m_opcnDlgCtrl.lpfnDisconnect;
|
|
#else
|
|
return m_opcnCriteria.lpfnDisconnect;
|
|
#endif
|
|
}
|
|
|
|
// Predicates
|
|
|
|
BOOL __stdcall
|
|
CardFinder::IsValid(SCARDCONTEXT scardctx,
|
|
SCARDHANDLE hSCard,
|
|
LPVOID lpvUserData)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CardFinder *pfinder =
|
|
reinterpret_cast<CardFinder *>(lpvUserData);
|
|
|
|
bool fResult = false;
|
|
|
|
EXCCTX_TRY
|
|
{
|
|
fResult = pfinder->DoIsValid();
|
|
}
|
|
|
|
// Throwing the callback exception is optional because the
|
|
// Microsoft Smart Card Dialog sensitive to throwing from the
|
|
// IsValid callback, particularly when multiple readers are
|
|
// connected.
|
|
EXCCTX_CATCH(pfinder, false);
|
|
|
|
return fResult
|
|
? TRUE
|
|
: FALSE;
|
|
}
|
|
|
|
|
|
// Static Variables
|
|
|