Al momento sei offline in attesa che la connessione Internet venga ristabilita

Messaggio di errore quando si inserisce una smart card in un lettore in un computer basato su Windows Server 2008 R2 o Windows 7: "il driver di periferica non installato correttamente"

IMPORTANTE: il presente articolo è stato tradotto tramite un software di traduzione automatica di Microsoft ed eventualmente revisionato dalla community Microsoft tramite la tecnologia CTF (Community Translation Framework) o da un traduttore professionista. Microsoft offre articoli tradotti manualmente e altri tradotti automaticamente e rivisti dalla community con l’obiettivo di consentire all'utente di accedere a tutti gli articoli della Knowledge Base nella propria lingua. Tuttavia, un articolo tradotto automaticamente, anche se rivisto dalla community, non sempre è perfetto. Potrebbe contenere errori di vocabolario, di sintassi o di grammatica. Microsoft declina ogni responsabilità per imprecisioni, errori o danni causati da una traduzione sbagliata o dal relativo utilizzo da parte dei clienti. Microsoft aggiorna frequentemente il software e gli strumenti di traduzione automatica per continuare a migliorare la qualità della traduzione.

Clicca qui per visualizzare la versione originale in inglese dell’articolo: 976832
Sintomi
Quando si inserisce una smart card in un lettore di smart card, Windows tenta di scaricare e installare il minidrivers delle smart card per la scheda tramite servizi Plug and Play. Se il driver per la smart card non è disponibile in una delle posizioni preconfigurate, quali Windows Update, WSUS o percorsi di intranet, e un provider di servizi di crittografia personalizzato non è già installato nel sistema, nell'area di notifica viene visualizzato il seguente messaggio di errore:
Il driver di periferica non installato correttamente
Fare clic qui per informazioni dettagliate.
Questo messaggio di errore scomparirà dopo alcuni secondi.

Inoltre, in Gestione periferiche, in altri dispositivi, il dispositivo Smart Card lo stato di "DNF" (Driver non trovato).

Ciò spesso richiede all'utente di ottenere uno dei seguenti elementi dall'emittente della smart card per risolvere questo errore:
  1. Un minidriver logoed smart card di Windows
  2. Un provider personalizzato servizio di crittografia (CSP) per Smart card.
  3. Un minidriver smartcard non logoed di Windows
  4. Altri middleware, ad esempio un controllo ActiveX, PKCS #11 software o altro software personalizzato.
Tuttavia, se l'utente viene fornito con l'unico elemento 3 o 4 da questo elenco, la smart card continua a funzionare sul sistema. Tuttavia, l'utente riceverà il messaggio di errore menzionato in questa sezione ogni volta che si inserisce la smart card.

Questo problema riguarda tutte le versioni di Windows 7, Windows Server 2008 R2 e versioni successive di entrambi i sistemi operativi.
Cause
Tutte le smart card richiedono software aggiuntivo per funzionare in Windows se non è presente un driver che consente all'utente di utilizzare la scheda senza installare software aggiuntivo. Il Framework di Smart Card Windows è stato migliorato in Windows 7 per attivare il download automatico delle smart card minidrivers da Windows Update o da altre posizioni simili, ad esempio un server WSUS quando la smart card è inserita nel lettore. Tutte le smart card che consentono di superare i requisiti del logo, pubblicato da Windows Logo Program, traggono vantaggio da questa funzionalità.

Tuttavia, se il software necessario per utilizzare una smart card in Windows non logoed o di un tipo diverso da un minidriver, ad esempio un driver PKCS #11 un CSP personalizzato, middleware o un controllo ActiveX, il download automatico ha esito negativo di opzione in quanto Microsoft certifica solo smart card minidrivers. Pertanto, se l'utente inserisce una scheda per il quale un CSP personalizzato non è già registrato, l'utente riceve un messaggio di errore indicante che il software del driver non è presente per il dispositivo smart card, anche se l'utente può utilizzare la smart card tramite ulteriori software installati nel computer dell'utente da un'installazione personalizzata.
Risoluzione
Sebbene le smart card continuare a lavorare nonostante il messaggio di errore visualizzato all'utente, un emittente di smart card, fornitore o produttore possibile utilizzare uno dei seguenti metodi per risolvere questo errore.

Implementare un minidriver smart card

È consigliabile che gli emittenti di carta, fornitori e produttori di implementano smart card minidrivers e partecipano al programma Windows Logo per trarre vantaggio dai miglioramenti introdotti nella piattaforma, quali Smart Card Plug and Play, Device Stage per le Smart card, e così via.

Per ulteriori informazioni sulle specifiche di smart card minidriver per Windows, visitare il seguente sito Web Microsoft: Per ulteriori informazioni su come iniziare a utilizzare il processo di ottenimento di un logo per il minidrivers delle smart card, visitare il seguente sito Web Windows Logo Program:

Implementare un driver NULL per la smart card

Software personalizzato alcuni altri middleware, un controllo ActiveX o un driver PKCS #11 di questo è necessario per consentire l'utilizzo di smart card in Windows, se l'implementazione di un minidriver smart card o un CSP personalizzato non è un'opzione pratica, consigliabile fabbricanti, fornitori o che emettono carte invio driver NULL a Windows Update. Il processo tipico per assicurare che un driver NULL è disponibile in Windows Update richiede un inoltro di dispositivo riuscita a Winqual. Se, in futuro, esiste un minidriver disponibili per queste schede, è possibile caricare il nuovo driver a Windows Update partecipando al programma Windows Logo Program. I driver NULL possono quindi essere scaricati manualmente per gli utenti finali o possono resi disponibili tramite gli aggiornamenti facoltativi.

Di seguito è un modello di esempio per un driver NULL per una smart card.
;; Null Driver for Fabrikam Smartcard installation x86 and x64 package.;[Version]Signature="$Windows NT$"Class=SmartCardClassGuid={990A2BD7-E738-46c7-B26F-1CF8FB9F1391}Provider=%ProviderName%CatalogFile=delta.catDriverVer=4/21/2006,1.0.0.0[Manufacturer]%ProviderName%=Minidriver,NTamd64,NTamd64.6.1,NTx86,NTx86.6.1[Minidriver.NTamd64];This driver has no applicability on OS versions earlier than Windows 7[Minidriver.NTx86];This driver has no applicability on OS versions earlier than Windows 7[Minidriver.NTamd64.6.1]%CardDeviceName%=Minidriver64_Install,<DEVICE_ID>;%CardDeviceName%=Minidriver64_Install,<DEVICE_ID2>;%CardDeviceName%=Minidriver64_Install,<DEVICE_ID3>;...[Minidriver.NTx86.6.1]%CardDeviceName%=Minidriver32_Install,<DEVICE_ID>;%CardDeviceName%=Minidriver32_Install,<DEVICE_ID2>;%CardDeviceName%=Minidriver32_Install,<DEVICE_ID3>;...;Leave the following sections blank[DefaultInstall][DefaultInstall.ntamd64][DefaultInstall.NTx86][DefaultInstall.ntamd64.6.1][DefaultInstall.NTx86.6.1][Minidriver64_Install.NT][Minidriver64_61_Install.NT][Minidriver32_Install.NT][Minidriver32_61_Install.NT][Minidriver64_61_Install.NT.Services]AddService = ,2[Minidriver32_61_Install.NT.Services]AddService = ,2; =================== Generic ==================================[Strings]ProviderName ="Microsoft"CardDeviceName="Fabrikam Generic Smart card"
Per generare l'ID del dispositivo hardware che fa riferimento la stringa DEVICE_ID nel campione, seguire le istruzioni nella specifica del minidriver della smart card. A tale scopo, visitare il seguente sito Web Microsoft:

Per informazioni dettagliate sulle modalità di invio di un driver NULL a Microsoft, contattare il servizio supporto tecnico clienti Microsoft.

Disattivazione di Smart Card Plug and Play tramite criteri di gruppo per i computer gestiti

Questa opzione è consigliata solo per le distribuzioni di enterprise in cui i computer vengono gestiti da amministratori e tutto il software necessario per lavorare con le smart card in uso nell'organizzazione viene installato utilizzando strumenti di gestione software come SMS.

Questa procedura è fortemente sconsigliata nei seguenti ambienti perché influenzerà tutte le smart card nel proprio ambiente:
  • Distribuzioni commerciali destinate a utenti finali, quali servizi bancari in linea
  • Ambienti che includono sia Plug and Play smart card e le smart card non Plug and Play che utilizzano criteri di gruppo per disattivare Plug and Play per smart card
Smart Card Plug and Play può essere completamente disattivata nelle aziende in cui i computer dell'utente finale viene gestito da meccanismi come criteri di gruppo.

Se la distribuzione utilizza solo le soluzioni non Plug and Play smart card, Smart Card Plug and Play può essere disattivato da un amministratore locale su un computer client. La disattivazione di Smart Card Plug and Play impedisce di scaricare driver di smart card, noto anche come minidrivers della smart card. Impedisce inoltre prompt di Smart Card Plug and Play.

Per disattivare Smart Card Plug and Play in Criteri di gruppo locali, procedere come segue:
  1. Fare clic su Start, tipo gpedit. msc Nella casella Cerca programmi e file e quindi premere INVIO.
  2. Nella struttura della console in Configurazione Computer, fare clic su Modelli amministrativi.
  3. Nel riquadro dei dettagli fare doppio clic su Componenti di Windowse quindi fare doppio clic su Smart Card.
  4. Destro attivare servizio Plug and Play della Smart Carde quindi fare clic su Modifica.
  5. Fare clic su disattivatoe quindi fare clic su OK.

Modificare il sistema dell'utente finale e disattivare Smart Card Plug and Play per specifiche schede

Si tratta dell'opzione minimi consigliati. Utilizzare questa opzione solo se le schede sono schede legacy e non sono previste per l'implementazione delle smart card minidrivers in futuro. Questa opzione richiede che il software esistente che è già installato nel sistema di notifica di Windows che vi sia un CSP personalizzato installato nel sistema, anche se tali CSP non è presente nel sistema dell'utente finale. Non appena Windows determina che esiste un CSP personalizzato già installato nel sistema, Windows non tenta di scaricare e installare un driver tramite Smart Card Plug and Play. Nessun nodo di periferica della periferica smart card viene creato che è visibile in Gestione periferiche. Questa opzione comporta le seguenti modifiche al Registro di sistema:

Sottochiave:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\Calais\SmartCards\<Smart card name>
Voci della sottochiave del Registro di sistema:
  • ATR = DWORD esadecimale: delimitato da virgole ATR della smart card.
  • ATRMask = DWORD esadecimale: maschera da applicare per l'ATR per mascherare le byte insignificanti il ATR delimitato da virgole.
  • Provider di crittografia = valore di stringa: alcune stringhe rilevanti per la smart card.
Ad esempio:
Sottochiave:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\Calais\SmartCards\Fabrikam ATM card
Voci della sottochiave del Registro di sistema:
  • ATR = DWORD esadecimale: 3b, dc, 13, 00, 40, 3a, 49, 54, 47, 5f, 4D, 53, 43, 53, 50, 5f, 56, 32
  • ATRMask = DWORD esadecimale: ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff, ff
  • Provider di crittografia = valore di stringa: "Fabrikam ATM manichino Provider"
Per i sistemi x64, è necessario apportare modifiche identiche nella seguente sottochiave:
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Cryptography\Calais\SmartCards


Si consiglia, anziché modificare direttamente il Registro di sistema, utilizzare WinSCard APIs per introdurre le modifiche al sistema. Di seguito è riportato codice di esempio che rileva l'inserimento della smart card e Smart Card Plug and Play per la particolare scheda Disattiva creando una voce di registro che associa la scheda con un provider non esistente.

Microsoft fornisce esempi di programmazione a scopo puramente illustrativo, senza alcuna garanzia espressa o implicita. Ciò include, ma non limitato a, le garanzie implicite di commerciabilità o idoneità per uno scopo particolare. In questo articolo si presuppone che si abbia familiarità con il linguaggio di programmazione in questione e gli strumenti utilizzati per creare ed eseguire la procedura di debug. Tecnici del supporto Microsoft consentono di spiegare la funzionalità di una particolare procedura. Tuttavia, essi non modificherà questi esempi per fornire funzionalità aggiuntive o creare procedure atte a soddisfare specifiche esigenze.
//==============================================================;////  Disable Smart card Plug and Play for specific cards////  Abstract://      This is an example of how to create a new//      Smart Card Database entry when a smart card is inserted//      into the computer.////  This source code is only intended as a supplement to existing Microsoft//  documentation.////  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY//  KIND, EITHER EXPRESSED OR IMPLIED. THIS INCLUDES BUT NOT LIMITED TO THE//  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR//  PURPOSE.////  Copyright (C) Microsoft Corporation.  All Rights Reserved.////==============================================================;// This code must be compiled with UNICODE support to work correctly#ifndef UNICODE#define UNICODE#endif#include <windows.h>#include <winscard.h>#include <stdio.h>#include <strsafe.h>#include <rpc.h>// Change this prefix to specify what the beginning of the// introduced card name in the registry will be. This is// be prepended to a GUID value.#define CARD_NAME_PREFIX    L"MyCustomCard"// This is the name that will be provided as the CSP for // the card when introduced to the system. This is provided// in order to disable Smart Card Plug and Play for this// card.#define CARD_CSP            L"$DisableSCPnP$"// This special reader name is used to be notified when// a reader is added to or removed from the system through// SCardGetStatusChange.#define PNP_READER_NAME     L"\\\\?PnP?\\Notification"// Maximum ATR length plus alignment bytes. This value is// used in the SCARD_READERSTATE structure#define MAX_ATR_LEN         36LONG GenerateCardName(    __deref_out LPWSTR  *ppwszCardName){    LONG        lReturn = NO_ERROR;    HRESULT     hr = S_OK;    DWORD       cchFinalString = 0;    WCHAR       wszCardNamePrefix[] = CARD_NAME_PREFIX;    LPWSTR      pwszFinalString = NULL;    UUID        uuidCardGuid = {0};    RPC_WSTR    pwszCardGuid = NULL;    RPC_STATUS  rpcStatus = RPC_S_OK;    // Parameter check    if (NULL == ppwszCardName)    {        wprintf(L"Invalid parameter in GenerateCardName.\n");        return ERROR_INVALID_PARAMETER;    }    // Generate GUID    rpcStatus = UuidCreate(&uuidCardGuid);    if (RPC_S_OK != rpcStatus)    {        wprintf(L"Failed to create new GUID with error 0x%x.\n");        lReturn = (DWORD)rpcStatus;    }    else    {        // Convert GUID to string        rpcStatus = UuidToString(&uuidCardGuid, &pwszCardGuid);        if (RPC_S_OK != rpcStatus)        {            wprintf(L"Failed to convert new GUID to string with error 0x%x.\n", rpcStatus);            lReturn = (DWORD)rpcStatus;        }        else        {            // Allocate memory for final string            // Template is <prefix>-<guid>            cchFinalString = (DWORD)(wcslen(wszCardNamePrefix) + 1 + wcslen((LPWSTR)pwszCardGuid) + 1);            pwszFinalString = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, cchFinalString * sizeof(WCHAR));            if (NULL == pwszFinalString)            {                wprintf(L"Out of memory.\n");                lReturn = ERROR_OUTOFMEMORY;            }            else            {                // Create final string                hr = StringCchPrintf(                            pwszFinalString,                            cchFinalString,                            L"%s-%s",                            wszCardNamePrefix,                            pwszCardGuid);                if (FAILED(hr))                {                    wprintf(L"Failed to create card name with error 0x%x.\n", hr);                    lReturn = (DWORD)hr;                }                else                {                    // Set output params                    *ppwszCardName = pwszFinalString;                    pwszFinalString = NULL;                }            }        }    }    if (NULL != pwszCardGuid)    {        RpcStringFree(&pwszCardGuid);    }    if (NULL != pwszFinalString)    {        HeapFree(GetProcessHeap(), 0, pwszFinalString);    }    return lReturn;}LONG IntroduceCardATR(    __in SCARDCONTEXT   hSC,    __in LPBYTE         pbAtr,    __in DWORD          cbAtr){    LONG    lReturn = NO_ERROR;    LPWSTR  pwszCardName = NULL;        // Parameter checks    if (NULL == hSC || NULL == pbAtr || 0 == cbAtr)    {        wprintf(L"Invalid parameter in IntroduceCardATR.\n");        return ERROR_INVALID_PARAMETER;    }    // Generate a name for the card    lReturn = GenerateCardName(&pwszCardName);    if (NO_ERROR != lReturn)    {        wprintf(L"Failed to generate card name with error 0x%x.\n", lReturn);    }    else    {        // Introduce the card to the system        lReturn = SCardIntroduceCardType(                                hSC,                                pwszCardName,                                NULL,                                NULL,                                0,                                pbAtr,                                NULL,                                cbAtr);        if (SCARD_S_SUCCESS != lReturn)        {            wprintf(L"Failed to introduce card '%s' to system with error 0x%x.\n", pwszCardName, lReturn);        }        else        {            // Set the provider name            lReturn = SCardSetCardTypeProviderName(                                        hSC,                                        pwszCardName,                                        SCARD_PROVIDER_CSP,                                        CARD_CSP);            if (SCARD_S_SUCCESS != lReturn)            {                wprintf(L"Failed to set CSP for card '%s' with error 0x%x.\n", pwszCardName, lReturn);            }            else            {                wprintf(L"Card '%s' has been successfully introduced to the system and has had Plug and Play disabled.\n", pwszCardName);            }        }    }    if (NULL != pwszCardName)    {        HeapFree(GetProcessHeap(), 0, pwszCardName);    }    return lReturn;}LONG ProcessCard(    __in SCARDCONTEXT           hSC,    __in LPSCARD_READERSTATE    pRdr){    LONG        lReturn = NO_ERROR;    DWORD       dwActiveProtocol = 0;    DWORD       cbAtr = MAX_ATR_LEN;    DWORD       dwIndex = 0;    DWORD       cchCards = SCARD_AUTOALLOCATE;    LPWSTR      pmszCards = NULL;    BYTE        rgbAtr[MAX_ATR_LEN] = {0};    SCARDHANDLE hSCard = NULL;    // Parameter checks    if (NULL == hSC || NULL == pRdr)    {        wprintf(L"Invalid parameter in ProcessCard.\n");        return ERROR_INVALID_PARAMETER;    }    // Connect to the card in the provided reader in shared mode    lReturn = SCardConnect(                    hSC,                    pRdr->szReader,                    SCARD_SHARE_SHARED,                    SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,                    &hSCard,                    &dwActiveProtocol);    if (SCARD_S_SUCCESS != lReturn)    {        wprintf(L"Failed to connect to card in reader '%s' with error 0x%x.\n", pRdr->szReader, lReturn);    }    else    {        wprintf(L"Connected to card in reader '%s'.\n", pRdr->szReader);        /*         * In this spot, put any necessary calls needed to identify that this         * is the type of card you are looking for. Usually this is done via         * SCardTransmit calls. For this example, we will grab the ATR of every         * inserted card.         */        // Obtain the ATR of the inserted card        lReturn = SCardGetAttrib(                            hSCard,                            SCARD_ATTR_ATR_STRING,                            rgbAtr,                            &cbAtr);        if (SCARD_S_SUCCESS != lReturn)        {            wprintf(L"Failed to obtain ATR of card in reader '%s' with error 0x%x.\n", pRdr->szReader, lReturn);        }        else        {            // Output the ATR            wprintf(L"ATR of card in reader '%s':", pRdr->szReader);            for (dwIndex = 0; dwIndex < cbAtr; dwIndex++)            {                wprintf(L" %02x", rgbAtr[dwIndex]);            }            wprintf(L"\n");            // Determine if the ATR is already in the Smart Card Database            lReturn = SCardListCards(                                hSC,                                rgbAtr,                                NULL,                                0,                                (LPWSTR)&pmszCards,                                &cchCards);            if (SCARD_S_SUCCESS != lReturn)            {                wprintf(L"Failed to determine if card in reader '%s' is currently recognized by the system with error 0x%x. Skipping.\n", pRdr->szReader, lReturn);            }            else if (NULL == pmszCards || 0 == *pmszCards)            {                // Card not found. We need to add it.                wprintf(L"Card in reader '%s' is not currently recognized by the system. Adding ATR.\n", pRdr->szReader);                lReturn = IntroduceCardATR(                                    hSC,                                     rgbAtr,                                     cbAtr);                // If an error occurs here, we will continue so we can try the next time                // the card is inserted as well as examine other readers.            }            else            {                wprintf(L"Card in reader '%s' is already known by the system. Not adding ATR.\n", pRdr->szReader);            }        }    }    // Disconnect from the card. We do not need to reset it.    if (NULL != hSCard)    {        SCardDisconnect(hSCard, SCARD_LEAVE_CARD);    }    // Free resources    if (NULL != pmszCards)    {        SCardFreeMemory(hSC, pmszCards);    }    return lReturn;}LONG MonitorReaders(        __in SCARDCONTEXT hSC){    LPWSTR              pwszReaders = NULL;    LPWSTR              pwszOldReaders = NULL;    LPWSTR              pwszRdr = NULL;    DWORD               dwRet = ERROR_SUCCESS;    DWORD               cchReaders = SCARD_AUTOALLOCATE;    DWORD               dwRdrCount = 0;    DWORD               dwOldRdrCount = 0;    DWORD               dwIndex = 0;    LONG                lReturn = NO_ERROR;    BOOL                fDone = FALSE;    SCARD_READERSTATE   rgscState[MAXIMUM_SMARTCARD_READERS+1] = {0};    SCARD_READERSTATE   rgscOldState[MAXIMUM_SMARTCARD_READERS+1] = {0};    LPSCARD_READERSTATE pRdr = NULL;    // Parameter check    if (NULL == hSC)    {        wprintf(L"Invalid parameter in MonitorReaders.\n");        return ERROR_INVALID_PARAMETER;    }    // One of the entries for monitoring will be to detect new readers    // The first time through the loop will be to detect whether    // the system has any readers.    rgscState[0].szReader = PNP_READER_NAME;    rgscState[0].dwCurrentState = SCARD_STATE_UNAWARE;    dwRdrCount = 1;    while (!fDone)    {        while (!fDone)        {            // Wait for status changes to occur            wprintf(L"Monitoring for changes.\n");            lReturn = SCardGetStatusChange(                                    hSC,                                    INFINITE,                                    rgscState,                                    dwRdrCount);            switch (lReturn)            {                case SCARD_S_SUCCESS:                    // Success                    break;                case SCARD_E_CANCELLED:                    // Monitoring is being cancelled                    wprintf(L"Monitoring cancelled. Exiting.\n");                    fDone = TRUE;                    break;                default:                    // Error occurred                    wprintf(L"Error 0x%x occurred while monitoring reader states.\n", lReturn);                    fDone = TRUE;                    break;            }            if (!fDone)            {                // Examine the status change for each reader, skipping the PnP notification reader                for (dwIndex = 1; dwIndex < dwRdrCount; dwIndex++)                {                    pRdr = &rgscState[dwIndex];                    // Determine if a card is now present in the reader and                    // it can be communicated with.                    if ((pRdr->dwCurrentState & SCARD_STATE_EMPTY ||                         SCARD_STATE_UNAWARE == pRdr->dwCurrentState) &&                        pRdr->dwEventState & SCARD_STATE_PRESENT &&                        !(pRdr->dwEventState & SCARD_STATE_MUTE))                    {                        // A card has been inserted and is available.                        // Grab its ATR for addition to the database.                        wprintf(L"A card has been inserted into reader '%s'. Grabbing its ATR.\n", pRdr->szReader);                        lReturn = ProcessCard(hSC, pRdr);                        // If an error occurs here, we will continue so we can try the next time                        // the card is inserted as well as examine other readers.                    }                    // Save off the new state of the reader                    pRdr->dwCurrentState = pRdr->dwEventState;                }                // Now see if the number of readers in the system has changed.                // Save its new state as the current state for the next loop.                pRdr = &rgscState[0];                pRdr->dwCurrentState = pRdr->dwEventState;                if (pRdr->dwEventState & SCARD_STATE_CHANGED)                {                    wprintf(L"Reader change detected.\n");                    break;                }            }           }        if (!fDone)        {            // Clean up previous loop            if (NULL != pwszOldReaders)            {                SCardFreeMemory(hSC, pwszOldReaders);                pwszOldReaders = NULL;            }            pwszReaders = NULL;            cchReaders = SCARD_AUTOALLOCATE;                        // Save off PnP notification reader state and and list of readers previously found in the system            memcpy_s(&rgscOldState[0], sizeof(SCARD_READERSTATE), &rgscState[0], sizeof(SCARD_READERSTATE));            memset(rgscState, 0, sizeof(rgscState));            dwOldRdrCount = dwRdrCount;            pwszOldReaders = pwszReaders;                        // Obtain a list of all readers in the system            wprintf(L"Building reader list.\n");            lReturn = SCardListReaders(                                hSC,                                NULL,                                (LPWSTR)&pwszReaders,                                &cchReaders);            switch (lReturn)            {                case SCARD_S_SUCCESS:                    // Success                    break;                case SCARD_E_NO_READERS_AVAILABLE:                    // No readers in the system. This is OK.                    lReturn = SCARD_S_SUCCESS;                    break;                default:                    // Error occurred                    wprintf(L"Failed to obtain list of readers with error 0x%x.\n", lReturn);                    fDone = TRUE;                    break;            }            // Build the reader list for monitoring - NULL indicates end-of-list            // First entry is the PnP Notification entry.            pRdr = rgscState;            memcpy_s(&rgscState[0], sizeof(SCARD_READERSTATE), &rgscOldState[0], sizeof(SCARD_READERSTATE));            pRdr++;            pwszRdr = pwszReaders;            while ((NULL != pwszRdr) && (0 != *pwszRdr))            {                BOOL fFound = FALSE;                dwRdrCount++;                // Look for an existing reader state from a previous loop                for (dwIndex = 1; dwIndex < dwOldRdrCount; dwIndex++)                {                    if ((lstrlen(pwszRdr) == lstrlen(rgscOldState[dwIndex].szReader)) &&                        (0 == lstrcmpi(pwszRdr, rgscOldState[dwIndex].szReader)))                    {                        // Found a match. Copy it.                        memcpy_s(pRdr, sizeof(SCARD_READERSTATE), &rgscOldState[dwIndex], sizeof(SCARD_READERSTATE));                        fFound = TRUE;                        break;                    }                }                if (!fFound)                {                    // New reader                    pRdr->szReader = pwszRdr;                    pRdr->dwCurrentState = SCARD_STATE_UNAWARE;                }                // Increment reader indices                pRdr++;                pwszRdr += lstrlen(pwszRdr)+1;            }        }    }    // Clean up resources    if (NULL != pwszReaders)    {        SCardFreeMemory(hSC, pwszReaders);    }    if (NULL != pwszOldReaders)    {        SCardFreeMemory(hSC, pwszOldReaders);    }    return lReturn;}LONG __cdecl main(        VOID){    DWORD               dwRet = ERROR_SUCCESS;    SCARDCONTEXT        hSC = NULL;    LONG                lReturn = NO_ERROR;    HANDLE              hStartedEvent = NULL;    // Get handle to event that will be signaled when the Smart Card Service is available    hStartedEvent = SCardAccessStartedEvent();    // Wait for the Smart Card Service to become available    dwRet = WaitForSingleObject(hStartedEvent, INFINITE);    if (WAIT_OBJECT_0 != dwRet)    {        wprintf(L"Wait for Smart Card Service failed with error 0x%x.\n", dwRet);        lReturn = dwRet;    }    else    {        // Establish a system-level context with the Smart Card Service        lReturn = SCardEstablishContext(                                SCARD_SCOPE_SYSTEM,                                NULL,                                NULL,                                &hSC);        if (SCARD_S_SUCCESS != lReturn)        {            wprintf(L"Failed to establish context with the Smart Card Service with error 0x%x.\n", lReturn);        }        else        {            // Begin monitoring the readers in the system            // This routine could be done in a separate thread so it can be cancelled via SCardCancel().            lReturn = MonitorReaders(hSC);        }    }       // Cleanup resources    if (NULL != hSC)    {        SCardReleaseContext(hSC);    }    if (NULL != hStartedEvent)    {        SCardReleaseStartedEvent();    }    wprintf(L"Done.\n");    return lReturn;}
Riferimenti
Per ulteriori informazioni sulla risoluzione dei problemi di smart card Plug and Play, vedere il seguente articolo di TechNet:
Smart Card Plug and Play Troubleshooting Guide
http://technet.microsoft.com/en-us/library/dd979536 (WS.10).aspx
Smart card win2008R2 di plugnplay PnP win7

Avviso: questo articolo è stato tradotto automaticamente

Proprietà

ID articolo: 976832 - Ultima revisione: 01/02/2016 08:16:00 - Revisione: 6.0

Windows Server 2008 R2 Datacenter, Windows Server 2008 R2 Enterprise, Windows Server 2008 R2 Standard, Windows 7 Enterprise, Windows 7 Home Basic, Windows 7 Home Premium, Windows 7 Professional, Windows 7 Starter, Windows 7 Ultimate

  • kbsmartcard kbcodesnippet kbtshoot kbexpertiseinter kbsurveynew kbprb kbmt KB976832 KbMtit
Feedback
{{header}} {{ cancelText }}
{{header}} {{ cancelText }}
: none; " src="https://c1.microsoft.com/c.gif?DI=4050&did=1&t=">