Você está offline; aguardando reconexão

A mensagem de erro: "O software de driver de dispositivo não foi instalado com êxito" é exibida quando você insere um smart card no leitor de um computador com o Windows 7 ou com o Windows Server 2008 R2

IMPORTANTE: Este artigo foi traduzido pelo software de tradução automática da Microsoft e eventualmente pode ter sido editado pela Microsoft Community através da tecnologia Community Translation Framework (CTF) ou por um tradutor profissional. A Microsoft oferece artigos traduzidos automaticamente por software, por tradutores profissionais e editados pela comunidade para que você tenha acesso a todos os artigos de nossa Base de Conhecimento em diversos idiomas. No entanto, um artigo traduzido pode conter erros de vocabulário, sintaxe e/ou gramática. A Microsoft não é responsável por qualquer inexatidão, erro ou dano causado por qualquer tradução imprecisa do conteúdo ou por seu uso pelos nossos clientes.

Clique aqui para ver a versão em Inglês deste artigo: 976832
Sintomas
Quando você insere um smart card em um leitor de smart card, o Windows tenta baixar e instalar os minidrivers de smart card para o cartão por meio de serviços Plug and Play. Se o driver para o smart card não estiver disponível em nenhum dos locais pré-configurados, como no Windows Update, WSUS ou caminhos de intranet e um provedor de serviços de Criptografia personalizado ainda não está instalado no sistema, você recebe a seguinte mensagem de erro na área de notificação:
O software de driver de dispositivo não foi instalado com êxito
Clique aqui para obter detalhes.
Essa mensagem de erro desaparecerá depois de alguns segundos.

Além disso, no Gerenciador de Dispositivos, em Outros dispositivos, o dispositivo de Smart Card tem um status de "DNF" (Driver não encontrado).

Isso frequentemente exige que o usuário obtenha um dos itens a seguir do emissor do smart card para resolver esse erro:
  1. Um minidriver de smart card logoed do Windows
  2. Um provedor personalizado de serviços de criptografia (CSP) para o Smart Card.
  3. Um minidriver de Smart Card não-logoed do Windows
  4. Outro middleware como um controle ActiveX, para o software PKCS n º 11 ou outro software personalizado.
No entanto, se for fornecido ao usuário apenas o item 3 ou 4 desta lista, o Smart Card continua a trabalhar com o sistema. No entanto, o usuário receberá a mensagem de erro que é mencionada nesta seção toda vez que inserir o Smart Card.

Esse problema afeta todas as versões do Windows 7, Windows Server 2008 R2, assim como todas as versões posteriores de ambos os sistemas operacionais.
Causa
Todos os smart cards requerem software adicional para funcionar no Windows, a menos que haja um driver de caixa de entrada que permita que o usuário use o cartão sem instalar software adicional. O Framework do Smart Card do Windows foi aprimorado no Windows 7 para ativar o download automático de minidrivers de smart cards do Windows Update ou de outros locais semelhantes, como um servidor WSUS quando o smart card for inserido no leitor. Todos os smart cards que passam com êxito pelos requisitos de logotipo, conforme publicado pelo Programa de Logotipo do Windows, se beneficiam deste recurso.

No entanto, se o software necessário para usar um smart card no Windows não for logoed ou for de um tipo diferente de minidriver, como um driver PKCS n º 11, um CSP personalizado, middleware ou um controle ActiveX, a opção de download automático falha porque a Microsoft certifica apenas minidrivers de smart cards. Portanto, se o usuário insere um cartão para o qual um CSP personalizado não estiver registrado, o usuário receberá uma mensagem de erro afirmando que o software de driver está ausente para o dispositivo de smart card, mesmo que o usuário use o smart card por meio de software adicional instalado no computador do usuário a partir de uma instalação personalizada.
Resolução
Embora os smart cards continuem a funcionar apesar da mensagem de erro que o usuário visualiza, um emissor do smart card, fornecedor ou fabricante podem usar um dos seguintes métodos para resolver esse erro.

Implementar um minidriver de smart card

Recomendamos que os emissores de cartão, fornecedores e fabricantes implementem minidrivers de smart card e participem do programa de logotipo do Windows para que possam se beneficiar dos aprimoramentos que sejam introduzidos na plataforma, como Smart Card Plug and Play, Device Stage para Smart Cards, e assim por diante.

Para obter mais informações sobre especificações de minidriver de smart card do Windows, visite o seguinte site da Microsoft: Para obter mais informações sobre como começar o processo de obtenção de um logotipo para seus minidrivers de smart card, visite o seguinte site do Logo Program do Windows:

Implementar um driver NULL para o smart card

Se um software personalizado como um driver PKCS#11, um controle ActiveX, ou alguns outros middlewares forem necessários para ativar o uso de smart cards no Windows e implementar o minidriver de um smart card ou no caso de um CSP personalizado não for uma opção prática, recomendamos que os emissores de cartão, fornecedores ou fabricantes considerem enviar drivers NULL ao Windows Update. O processo típico para certificar-se de que um driver NULL esteja disponível no Windows Update requer o envio de um dispositivo não classificado com êxito por meio do Winqual. Se, no futuro, houver um minidriver disponível para esses cartões, o novo driver poderá ser carregado para o Windows Update participando do programa de logotipo do Windows. Os drivers NULL, em seguida, podem ser baixados manualmente pelos usuários finais ou podem ser disponibilizados por meio de atualizações opcionais.

A seguir pode-se ver uma amostra de modelo para um driver NULL para um 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"
Para gerar a identificação de dispositivo de hardware que é referenciada pela seqüência DEVICE_ID na amostra, siga as instruções na especificação do minidriver de smart card. Para fazer isso, visite o seguinte site da Microsoft:

Para obter informações detalhadas sobre como enviar um driver NULL para a Microsoft, entre em contato com o Suporte Técnico da Microsoft.

Desabilitar Smart Card Plug and Play através da Política de Grupo para computadores gerenciados

Essa opção é recomendada somente para implantações empresariais onde os computadores são gerenciados por administradores e todo o software necessário para trabalhar com os smart cards que estão sendo usados na empresa são instalados usando as ferramentas de gerenciamento de software, como o SMS.

Esse procedimento não é recomendado nos seguintes ambientes porque ele afetará todos os smart cards em seu ambiente:
  • Implantações comerciais que têm como alvo os usuários finais, como serviços bancários on-line
  • Ambientes que incluam tanto smart cards Plug and Play e smart cards que não possuam o recurso Plug and Play, e que usem a Diretiva de Grupo para desabilitar o Plug and Play para smart cards
Smart Card Plug and Play pode ser completamente desabilitado em empresas onde o computador do usuário final é gerenciado por mecanismos como Diretiva de Grupo.

Se a implantação usar apenas soluções para smart card sem Plug and Play ou Smart Card Plug and Play, esta só pode ser desabilitada por um administrador local no computador cliente. A desativação de Smart Card Plug and Play impede que drivers de smart cards, também conhecidos como minidrivers de smart card, sejam baixados. Ela também impede que avisos de Smart Card Plug and Play.

Para desativar o Smart Card Plug and Play na Diretiva de Grupo local, execute estas etapas:
  1. Clique em Iniciar, tipo gpedit. msc Na caixa Pesquisar programas e arquivos e então pressione ENTER.
  2. Na árvore do console, em Configuração do Computador, clique em Modelos Administrativos.
  3. No painel de detalhes, clique duas vezes em Componentes do Windows e, em seguida, clique duas vezes em Smart Card.
  4. Clique com o botão direito em Ativar serviço Plug and Play no Smart Card e, em seguida, clique em Editar.
  5. Clique em Desativado e, em seguida, clique em OK.

Alterar o sistema do usuário final e desabilitar o Smart Card Plug and Play para placas específicas

Essa é a opção menos recomendada. Você deverá usar essa opção somente se as placas forem herdadas e não houver planos para implementar minidrivers de smart card no futuro. Esta opção requer que o software existente que já esteja instalado no sistema, notifique o Windows que existe um CSP personalizado instalado no sistema, mesmo que tal CSP não exista no sistema do usuário final. Assim que o Windows determinar que há um CSP personalizado já instalado no sistema, o Windows não tenta baixar e instalar um driver por meio do Smart Card Plug and Play. Nenhum nó de dispositivo para o dispositivo de smart card é criado ou está visível no Gerenciador de Dispositivos. Essa opção resultará nas seguintes alterações no registro do sistema:

Subchave:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\Calais\SmartCards\<Smart card name>
Entradas da subchave do registro:
  • ATR = Hexadecimal DWORD: ATR do smart card delimitado por vírgulas.
  • ATRMask = Hexadecimal DWORD: Máscara delimitadora de vírgula para aplicar a ATR para mascarar bytes insignificantes na ATR.
  • Provedor de Criptografia=Valor de seqüência de caracteres: Alguma cadeia de caracteres relevante para o smart card.
Por exemplo:
Subchave:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\Calais\SmartCards\Fabrikam ATM card
Entradas da subchave do registro:
  • ATR = Hexadecimal DWORD: 3b, dc, 13, 00, 40, 3a, 49, 54, 47, 5f, 4d, 53, 43, 53, 50, 5f, 56, 32
  • ATRMask = Hexadecimal DWORD: ff, ff, ff, ff, ff, ff, ff, ff, ff, TT, TT, TT, ff, ff, ff, ff, ff, ff
  • Provedor de criptografia = valor de seqüência: "Fabrikam ATM Dummy Provider"
Para sistemas x64 bits, alterações idênticas devem ser feitas na seguinte subchave:
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Cryptography\Calais\SmartCards


É recomendável que, em vez de alterar diretamente o registro do sistema, você use APIs de WinSCard para introduzir essas alterações no sistema. Aqui está a amostra de código de exemplo que detecta a inserção do smart card e, em seguida, desativa o Smart Card Plug and Play para a placa específica, criando uma entrada do registro que associa o cartão com um provedor não existente.

A Microsoft fornece exemplos de programação somente para ilustração, sem garantia expressa ou implícita. Isso inclui, mas não está limitado a, garantias implícitas de comercialização ou adequação a um propósito específico. Este artigo presume que você esteja familiarizado com a linguagem de programação que está sendo demonstrada e com as ferramentas usadas para criar e depurar procedimentos. Os engenheiros de suporte da Microsoft podem ajudar a explicar a funcionalidade de um determinado procedimento. No entanto, eles não modificarão esses exemplos para fornecer funcionalidades adicionais ou construir procedimentos para atender às suas necessidades específicas.
//==============================================================;////  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;}
Referências
Para obter mais informações sobre como solucionar problemas do smart card Plug and Play, consulte o seguinte artigo do TechNet:
Guia de Solução de Problemas do Smart Card Plug and Play
http://technet.microsoft.com/en-us/library/dd979536 (WS.10).aspx
Plugnplay PnP win7 win2008R2 smartcard

Aviso: este artigo foi traduzido automaticamente

Propriedades

ID do Artigo: 976832 - Última Revisão: 06/02/2015 05:11:00 - Revisão: 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 KbMtpt
Comentários