windows-xp/Source/XPSP1/NT/ds/security/services/smartcrd/common/querydb.cpp

/*++

Copyright (C) Microsoft Corporation, 1996 - 1999

Module Name:

    QueryDB

Abstract:

    This module provides simple access to the Calais Registry Database.

Author:

    Doug Barlow (dbarlow) 11/25/1996

Environment:

    Win32, C++ w/ Exceptions

Notes:

    ?Notes?

--*/

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#include <stdlib.h>
#include <tchar.h>
#include <winscard.h>
#include <CalaisLb.h>

// Keep this in sync with ChangeDB.cpp
typedef struct {
    DWORD dwScope;
    HKEY hKey;
} RegMap;

#if SCARD_SCOPE_SYSTEM < SCARD_SCOPE_USER
#error Invalid ordering to SCARD_SCOPE definitions
#endif

static const RegMap l_rgRegMap[]
    = {
        { SCARD_SCOPE_USER,     HKEY_CURRENT_USER },
     // { SCARD_SCOPE_TERMINAL, Not implemented yet },  // ?Hydra?
        { SCARD_SCOPE_SYSTEM,   HKEY_LOCAL_MACHINE }
      };
static const DWORD l_dwRegMapMax = sizeof(l_rgRegMap) / sizeof(RegMap);

static const LPCTSTR l_szrgProvMap[]
    = {
        NULL,   // Zero value
        SCARD_REG_PPV,
        SCARD_REG_CSP
      };
static const DWORD l_dwProvMapMax = sizeof(l_szrgProvMap) / sizeof(LPCTSTR);

static BOOL
ListKnownKeys(
    IN  DWORD dwScope,
    OUT CBuffer &bfKeys,
    IN  LPCTSTR szUserList,
    IN  LPCTSTR szSystemList = NULL);
static void
FindKey(
    IN  DWORD dwScope,
    IN LPCTSTR szKey,
    OUT CRegistry &regKey,
    IN  LPCTSTR szUserList,
    IN  LPCTSTR szSystemList = NULL);


//
////////////////////////////////////////////////////////////////////////////////
//
//  Calais Database Query Services
//
//      These services all are oriented towards reading the Calais database.
//

/*++

ListReaderGroups:

    This service provides the list of named card reader groups that have
    previously been defined to the system.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

        For V1, this value is ignored, and assumed to be SCARD_SCOPE_SYSTEM.

    bfGroups receives a multi-string listing the reader groups defined within
        the supplied scope.

Return Value:

    None.

Author:

    Doug Barlow (dbarlow) 10/23/1996

--*/

void
ListReaderGroups(
    IN DWORD dwScope,
    OUT CBuffer &bfGroups)
{
    CBuffer bfReaders;
    CRegistry regReader;
    LPCTSTR szReader, mszGroups;
    CBuffer bfTmp;
    DWORD cchGroups;

    ListKnownKeys(dwScope, bfReaders, SCARD_REG_READERS);
    for (szReader = FirstString(bfReaders);
         NULL != szReader;
         szReader = NextString(szReader))
    {
        try
        {
            FindKey(dwScope, szReader, regReader, SCARD_REG_READERS);
            mszGroups = regReader.GetMultiStringValue(SCARD_REG_GROUPS);
            cchGroups = regReader.GetValueLength() / sizeof(TCHAR);
            while (0 == mszGroups[cchGroups - 1])
                cchGroups -= 1;
            bfTmp.Append(
                (LPBYTE)mszGroups,
                cchGroups * sizeof(TCHAR));
            bfTmp.Append((LPBYTE)TEXT("\000"), sizeof(TCHAR));
        }
        catch (...) {}
    }


    //
    // Sort the list, and remove duplicates.
    //

    bfTmp.Append((LPCBYTE)TEXT("\000"), 2 * sizeof(TCHAR));
    MStringSort(bfTmp, bfGroups);
}


/*++

ListReaders:

    This service provides the list of readers within a set of named reader
    groups, eliminating duplicates.  The caller supplies a multistring listing
    the name of a set of pre-defined group of readers, and receives the list of
    smartcard readers within the named groups.  Unrecognized group names are
    ignored.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    mszGroups supplies the names of the reader groups defined to the system, as
        a multi-string.  If this parameter is null, all readers are returned.

    bfReaders receives a multi-string listing the card readers within the
        supplied reader groups.

Return Value:

    None.

Author:

    Doug Barlow (dbarlow) 10/23/1996

--*/

void
ListReaders(
    IN DWORD dwScope,
    IN LPCTSTR mszGroups,
    OUT CBuffer &bfReaders)
{
    CRegistry regReader;
    LPCTSTR szReader, mszRdrGroups;
    CBuffer bfRdrs, bfCmn;
    DWORD dwCmnCount;

    dwCmnCount = MStringCommon(mszGroups, SCARD_ALL_READERS, bfCmn);
    if (0 == dwCmnCount)
    {
        if ((NULL == mszGroups) || (0 == *mszGroups))
            mszGroups = SCARD_DEFAULT_READERS;
        bfReaders.Reset();
        ListKnownKeys(dwScope, bfRdrs, SCARD_REG_READERS);
        for (szReader = FirstString(bfRdrs);
        NULL != szReader;
        szReader = NextString(szReader))
        {
            try
            {
                FindKey(dwScope, szReader, regReader, SCARD_REG_READERS);
                mszRdrGroups = regReader.GetMultiStringValue(SCARD_REG_GROUPS);
                dwCmnCount = MStringCommon(mszGroups, mszRdrGroups, bfCmn);
                if (0 < dwCmnCount)
                    bfReaders.Append(
                    (LPCBYTE)szReader,
                    (lstrlen(szReader) + 1) * sizeof(TCHAR));
            }
            catch (...) {}
        }
        bfReaders.Append((LPBYTE)TEXT("\000"), 2 * sizeof(TCHAR));
        bfReaders.Resize(MStrLen((LPCTSTR)bfReaders.Access()), TRUE);
    }
    else
        ListKnownKeys(dwScope, bfReaders, SCARD_REG_READERS);
}


/*++

ListReaderNames:

    This routine returns the list of names corresponding to a given reader
    device.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

        For V1, this value is ignored, and assumed to be SCARD_SCOPE_SYSTEM.

    szDevice supplies the reader device name.

    bfNames receives a multistring of the names given to that device, if any.

Return Value:

    None

Throws:

    Errors as DWORD status codes

Author:

    Doug Barlow (dbarlow) 2/13/1997

--*/

void
ListReaderNames(
    IN DWORD dwScope,
    IN LPCTSTR szDevice,
    OUT CBuffer &bfNames)
{
    CRegistry regReader;
    LPCTSTR szReader, szDev;
    CBuffer bfRdrs;

    bfNames.Reset();
    ListKnownKeys(dwScope, bfRdrs, SCARD_REG_READERS);
    for (szReader = FirstString(bfRdrs);
    NULL != szReader;
    szReader = NextString(szReader))
    {
        try
        {
            FindKey(dwScope, szReader, regReader, SCARD_REG_READERS);
            szDev = regReader.GetStringValue(SCARD_REG_DEVICE);
            if (0 == lstrcmpi(szDev, szDevice))
                MStrAdd(bfNames, szReader);
        }
        catch (...) {}
    }
}



/*++

ListCards:

    This service provides a list of named cards previously introduced to the
    system by this user which match an optionally supplied ATR string and/or
    supply a set of given interfaces.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    pbAtr supplies the address of an ATR string to compare to known cards, or
        NULL if all card names are to be returned.

    rgguidInterfaces supplies an array of GUIDs, or the value NULL.  When an
        array is supplied, a card name will be returned only if this set of
        GUIDs is a (possibly improper) subset of the set of GUIDs supported by
        the card.

    cguidInterfaceCount supplies the number of entries in the rgguidInterfaces
        array.  If rgguidInterfaces is NULL, then this value is ignored.

  bfCards receives a multi-string listing the smartcards introduced to the
        system by this user which match the supplied ATR string.

Return Value:

    None

Author:

    Doug Barlow (dbarlow) 10/23/1996

--*/

void
ListCards(
    DWORD dwScope,
    IN LPCBYTE pbAtr,
    IN LPCGUID rgquidInterfaces,
    IN DWORD cguidInterfaceCount,
    OUT CBuffer &bfCards)
{
    CRegistry regCard;
    LPCTSTR szCard;
    CBuffer bfCardAtr;
    CBuffer bfCardList;

    bfCards.Reset();
    ListKnownKeys(dwScope, bfCardList, SCARD_REG_CARDS, SCARD_REG_TEMPLATES);
    for (szCard = FirstString(bfCardList);
         NULL != szCard;
         szCard = NextString(szCard))
    {
        try
        {
            FindKey(
                dwScope,
                szCard,
                regCard,
                SCARD_REG_CARDS,
                SCARD_REG_TEMPLATES);


            //
            // Does this card match the supplied ATR?
            //

            if ((NULL != pbAtr) && (0 != *pbAtr))
            {
                LPCBYTE pbCardAtr, pbCardMask;
                DWORD cbCardAtr, cbCardMask;

                pbCardAtr = regCard.GetBinaryValue(
                                        SCARD_REG_ATR,
                                        &cbCardAtr);
                bfCardAtr.Set(pbCardAtr, cbCardAtr);
                try
                {
                    pbCardMask = regCard.GetBinaryValue(
                                            SCARD_REG_ATRMASK,
                                            &cbCardMask);
                    if (cbCardAtr != cbCardMask)
                        continue;       // Invalid ATR/Mask combination.
                }
                catch (...)
                {
                    pbCardMask = NULL;  // No mask.
                }

                if (!AtrCompare(pbAtr, bfCardAtr, pbCardMask, cbCardAtr))
                    continue;           // ATRs invalid or don't match.
            }


            //
            // Does this card support the given interfaces?
            //

            if ((NULL != rgquidInterfaces) && (0 < cguidInterfaceCount))
            {
                DWORD cguidCrd;
                DWORD ix, jx;
                BOOL fAllInterfacesFound = TRUE;
                LPCGUID rgCrdInfs = (LPCGUID)regCard.GetBinaryValue(
                                            SCARD_REG_GUIDS,
                                            &cguidCrd);
                if ((0 != (cguidCrd % sizeof(GUID)))
                    || (0 == cguidCrd))
                    continue;           // Invalid GUID list.
                cguidCrd /= sizeof(GUID);
                for (ix = 0; ix < cguidInterfaceCount; ix += 1)
                {
                    for (jx = 0; jx < cguidCrd; jx += 1)
                    {
                        if (0 == MemCompare(
                                    (LPCBYTE)&rgCrdInfs[jx],
                                    (LPCBYTE)&rgquidInterfaces[ix],
                                    sizeof(GUID)))
                            break;
                    }
                    if (jx == cguidCrd)
                    {
                        fAllInterfacesFound = FALSE; // Unsupported interface
                        break;
                    }
                }
                if (!fAllInterfacesFound)
                    continue;
            }


            //
            // This card passes all the tests -- Include it.
            //

            MStrAdd(bfCards, szCard);
        }
        catch (...) {}
    }
    if (0 == bfCards.Length())
        bfCards.Set((LPCBYTE)TEXT("\000"), 2 * sizeof(TCHAR));
}


/*++

GetCardTypeProviderName:

    This routine returns the value of a given Provider Name, by Id number, for
    the identified card type.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    szCardName supplies the name of the card type with which this provider name
        is associated.

    dwProviderId supplies the identifier for the provider associated with this
        card type.  Possible values are:

        SCARD_PROVIDER_SSP - The SSP identifier, as a GUID string.
        SCARD_PROVIDER_CSP - The CSP name.

        Other values < 0x80000000 are reserved for use by Microsoft.  Values
            over 0x80000000 are available for use by the smart card vendors, and
            are card-specific.

    bfProvider receives the string identifying the provider.

Return Value:

    None

Throws:

    Errors as DWORD status codes

Author:

    Doug Barlow (dbarlow) 1/19/1998

--*/

void
GetCardTypeProviderName(
    IN DWORD dwScope,
    IN LPCTSTR szCardName,
    IN DWORD dwProviderId,
    OUT CBuffer &bfProvider)
{
    LPCTSTR szProvValue;
    TCHAR szNumeric[36];
    CRegistry regCard;


    //
    // Find the Card definition closest to the caller.
    //

    FindKey(
        dwScope,
        szCardName,
        regCard,
        SCARD_REG_CARDS,
        SCARD_REG_TEMPLATES);


    //
    // Derive the Provider Value Name.
    //

    if (dwProviderId < l_dwProvMapMax)
    {
        szProvValue = l_szrgProvMap[dwProviderId];
        if (NULL == szProvValue)
            throw (DWORD)SCARD_E_INVALID_PARAMETER;
    }
    else if (0x80000000 <= dwProviderId)
    {
        _ultot(dwProviderId, szNumeric, 16);
        szProvValue = szNumeric;
    }
    else
        throw (DWORD)SCARD_E_INVALID_PARAMETER;


    //
    // Read the provider value.
    //

    switch (dwProviderId)
    {
    case 1: // SCARD_PROVIDER_SSP
    {
        CBuffer bfGuid(sizeof(GUID));

        bfProvider.Presize(40 * sizeof(TCHAR));
        regCard.GetValue(szProvValue, bfGuid);
        StringFromGuid(
            (LPCGUID)bfGuid.Access(),
            (LPTSTR)bfProvider.Access());
        bfProvider.Resize(
            (lstrlen((LPCTSTR)bfProvider.Access()) + 1) * sizeof(TCHAR),
            TRUE);
        break;
    }
    default:
        regCard.GetValue(szProvValue, bfProvider);
    }
}


/*++

GetReaderInfo:

    This routine returns all stored information regarding a given reader.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    szReader supplies the name of the reader of which info is to be extracted.

    pbfGroups receives the list of groups as a multistring.

    pbfDevice receives the device name.

Return Value:

    TRUE - Reader found
    FALSE - Reader not found

Author:

    Doug Barlow (dbarlow) 12/2/1996

--*/

BOOL
GetReaderInfo(
    IN DWORD dwScope,
    IN LPCTSTR szReader,
    OUT CBuffer *pbfGroups,
    OUT CBuffer *pbfDevice)
{
    CRegistry regReader;


    //
    // Find the reader definition closest to the caller.
    //

    try
    {
        FindKey(dwScope, szReader, regReader, SCARD_REG_READERS);
    }
    catch (...)
    {
        return FALSE;
    }


    //
    // Look up all it's values.
    //

    if (NULL != pbfDevice)
    {
        // Device name
        try
        {
            regReader.GetValue(SCARD_REG_DEVICE, *pbfDevice);
        }
        catch (...)
        {
            pbfDevice->Reset();
        }
    }

    if (NULL != pbfGroups)
    {
        // Group list
        try
        {
            regReader.GetValue(SCARD_REG_GROUPS, *pbfGroups);
        }
        catch (...)
        {
            pbfGroups->Reset();
        }
    }

    return TRUE;
}


/*++

GetCardInfo:

    This routine finds the given card under the given scope, and returns all
    information associated with it.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    szCard supplies the name of the card for which info is to be extracted.

    pbfAtr receives the ATR string of the given card.  This parameter may be
        NULL if the ATR is not desired.

    pbfAtrMask receives the ATR mask of the given card, if any.  This parameter
        may be NULL if the value is not desired.

    pbfInterfaces receives the list of interfaces as an array of GUIDs for the
        given card, if any.  This parameter may be NULL if the value is not
        desired.

    pbfProvider receives the Primary Provider of the given card, if any.  This
        parameter may be NULL if the value is not desired.

Return Value:

    TRUE - The card was found, the returned data is valid.
    FALSE - The supplied card was not found.

Throws:

    None

Author:

    Doug Barlow (dbarlow) 12/3/1996

--*/

BOOL
GetCardInfo(
    IN DWORD dwScope,
    IN LPCTSTR szCard,
    OUT CBuffer *pbfAtr,
    OUT CBuffer *pbfAtrMask,
    OUT CBuffer *pbfInterfaces,
    OUT CBuffer *pbfProvider)
{
    CRegistry regCard;


    //
    // Find the Card definition closest to the caller.
    //

    try
    {
        FindKey(
            dwScope,
            szCard,
            regCard,
            SCARD_REG_CARDS,
            SCARD_REG_TEMPLATES);
    }
    catch (...)
    {
        return FALSE;
    }


    //
    // Look up all it's values.
    //

    if (NULL != pbfAtr)
    {
        // Card ATR String
        try
        {
            regCard.GetValue(SCARD_REG_ATR, *pbfAtr);
        }
        catch (...)
        {
            pbfAtr->Reset();
        }
    }

    if (NULL != pbfAtrMask)
    {
        // Card ATR Comparison Mask
        try
        {
            regCard.GetValue(SCARD_REG_ATRMASK, *pbfAtrMask);
        }
        catch (...)
        {
            pbfAtrMask->Reset();
        }
    }

    if (NULL != pbfInterfaces)
    {
        // Supported Interface List
        try
        {
            regCard.GetValue(SCARD_REG_GUIDS, *pbfInterfaces);
        }
        catch (...)
        {
            pbfInterfaces->Reset();
        }
    }

    if (NULL != pbfProvider)
    {
        // Card Primary Provider
        try
        {
            regCard.GetValue(SCARD_REG_PPV, *pbfProvider);
        }
        catch (...)
        {
            pbfProvider->Reset();
        }
    }

    return TRUE;
}


#ifdef ENABLE_SCARD_TEMPLATES
/*++

ListCardTypeTemplates:

    This routine searches the template database looking for previously defined
    smart card templates against which the given card ATR matches.  If the ATR
    parameter is NULL, it returns a list of all templates.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    pbAtr supplies the ATR of a card to be matched against the known templates.

    bfTemplates receives a list of matching template names, as a multistring.

Return Value:

    TRUE - At least one template was found.
    FALSE - No matching templates were found.

Throws:

    Errors

Author:

    Doug Barlow (dbarlow) 1/16/1998

--*/

BOOL
ListCardTypeTemplates(
    IN DWORD dwScope,
    IN LPCBYTE pbAtr,
    OUT CBuffer &bfTemplates)
{
    CRegistry regCard;
    LPCTSTR szCard;
    CBuffer bfCardAtr;
    CBuffer bfCardList;

    bfTemplates.Reset();
    ListKnownKeys(dwScope, bfCardList, SCARD_REG_TEMPLATES);
    for (szCard = FirstString(bfCardList);
         NULL != szCard;
         szCard = NextString(szCard))
    {
        try
        {
            FindKey(dwScope, szCard, regCard, SCARD_REG_TEMPLATES);


            //
            // Does this card match the supplied ATR?
            //

            if ((NULL != pbAtr) && (0 != *pbAtr))
            {
                LPCBYTE pbCardAtr, pbCardMask;
                DWORD cbCardAtr, cbCardMask;

                pbCardAtr = regCard.GetBinaryValue(
                                        SCARD_REG_ATR,
                                        &cbCardAtr);
                bfCardAtr.Set(pbCardAtr, cbCardAtr);
                try
                {
                    pbCardMask = regCard.GetBinaryValue(
                                            SCARD_REG_ATRMASK,
                                            &cbCardMask);
                    if (cbCardAtr != cbCardMask)
                        continue;       // Invalid ATR/Mask combination.
                }
                catch (...)
                {
                    pbCardMask = NULL;  // No mask.
                }

                if (!AtrCompare(pbAtr, bfCardAtr, pbCardMask, cbCardAtr))
                    continue;           // ATRs invalid or don't match.
            }


            //
            // This card passes all the tests -- Include it.
            //

            MStrAdd(bfTemplates, szCard);
        }
        catch (...) {}
    }
    if (0 == bfTemplates.Length())
    {
        bfTemplates.Set((LPCBYTE)TEXT("\000"), 2 * sizeof(TCHAR));
        return FALSE;
    }
    else
        return TRUE;
}
#endif  // ENABLE_SCARD_TEMPLATES


//
////////////////////////////////////////////////////////////////////////////////
//
// Support Routines
//

/*++

ListKnownKeys:

    This routine lists all known keys of a given type within the current
    caller's scope.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    bfKeys receives a multistring of existing key names, sorted and stripped
        of duplicates.

    szUserList supplies the primary registry path from which key names are to
        be returned.

    szSystemList supplies an optional secondary path from which key names can
        be returned if the caller is running at system scope.

Return Value:

    TRUE - At least one was found
    FALSE - None were found.

Throws:

    Errors are thrown as DWORD status codes.

Author:

    Doug Barlow (dbarlow) 1/22/1998

--*/

static BOOL
ListKnownKeys(
    IN  DWORD dwScope,
    OUT CBuffer &bfKeys,
    IN  LPCTSTR szUserList,
    IN  LPCTSTR szSystemList)
{
    DWORD dwSpace, dwIndex, dwCount;
    CRegistry regScopeKey;
    CBuffer bfMyList;
    LPCTSTR rgszLists[2];


    //
    // Loop through introduced space, then if appropriate, template space.
    //

    rgszLists[0] = szUserList;
    rgszLists[1] = szSystemList;
    for (dwSpace = 0; 2 > dwSpace; dwSpace += 1)
    {
        if (NULL == rgszLists[dwSpace])
            continue;


        //
        // Loop through all the possible scopes, from highest to lowest.
        //

        for (dwIndex = 0; l_dwRegMapMax > dwIndex; dwIndex += 1)
        {
            if (l_rgRegMap[dwIndex].dwScope >= dwScope)
            {

                //
                // If the caller is under this scope, then look for existing
                // Keys.
                //

                regScopeKey.Open(
                    l_rgRegMap[dwIndex].hKey,
                    rgszLists[dwSpace],
                    KEY_READ);
                if (SCARD_S_SUCCESS != regScopeKey.Status(TRUE))
                    continue;


                //
                // Pull out all it's subkey names.
                //

                for (dwCount = 0;; dwCount += 1)
                {
                    LPCTSTR szKey;

                    szKey = regScopeKey.Subkey(dwCount);
                    if (NULL == szKey)
                        break;

                    bfMyList.Append(
                        (LPBYTE)szKey,
                        (lstrlen(szKey) + 1) * sizeof(TCHAR));
                }
            }
        }


        //
        // Don't go on to the system list unless we're at system scope.
        //

        if (SCARD_SCOPE_SYSTEM != dwScope)
            break;
    }


    //
    // Sort the list, and remove duplicates.
    //

    bfMyList.Append((LPBYTE)TEXT("\000"), 2 * sizeof(TCHAR));
    MStringSort(bfMyList, bfKeys);
    return (2 * sizeof(TCHAR) < bfKeys.Length());
}



/*++

FindKey:

    This routine finds the named key closest in scope to the caller.

Arguments:

    dwScope supplies an indicator of the scope of the operation.  Possible
        values are:

        SCARD_SCOPE_USER - The current user's definitions are used.
        SCARD_SCOPE_TERMINAL - The terminal's definitions are used.
        SCARD_SCOPE_SYSTEM - The system's definitions are used.

    szKey supplies the name of the key to be found.

    regKey receives initialization to reference the named key.

    szUserList supplies the primary registry path from which key names are to
        be returned.

    szSystemList supplies an optional secondary path from which key names can
        be returned if the caller is running at system scope.

Return Value:

    TRUE - The key was found.
    FALSE - No such key was found.

Throws:

    Errors are thrown as DWORD status codes.

Author:

    Doug Barlow (dbarlow) 1/22/1998

--*/

static void
FindKey(
    IN  DWORD dwScope,
    IN LPCTSTR szKey,
    OUT CRegistry &regKey,
    IN  LPCTSTR szUserList,
    IN  LPCTSTR szSystemList)
{
    DWORD dwSpace, dwIndex;
    CRegistry regScopeKey;
    LPCTSTR rgszLists[2];


    //
    // Loop through introduced space, then if appropriate, template space.
    //

    rgszLists[0] = szUserList;
    rgszLists[1] = szSystemList;
    for (dwSpace = 0; 2 > dwSpace; dwSpace += 1)
    {
        if (NULL == rgszLists[dwSpace])
            continue;


        //
        // Loop through all the possible scopes, from highest to lowest.
        //

        for (dwIndex = 0; l_dwRegMapMax > dwIndex; dwIndex += 1)
        {
            if (l_rgRegMap[dwIndex].dwScope >= dwScope)
            {

                //
                // If the caller is under this scope, then look for an
                // existing Key.
                //

                regScopeKey.Open(
                    l_rgRegMap[dwIndex].hKey,
                    rgszLists[dwSpace],
                    KEY_READ);
                if (SCARD_S_SUCCESS != regScopeKey.Status(TRUE))
                    continue;

                regKey.Open(regScopeKey, szKey, KEY_READ);
                if (SCARD_S_SUCCESS != regKey.Status(TRUE))
                    continue;

                //
                // We've found such a key.  Return immediately.
                //

                return;
            }
        }


        //
        // Don't go on to the system list unless we're at system scope.
        //

        if (SCARD_SCOPE_SYSTEM != dwScope)
            break;
    }


    //
    // We didn't find any such key.
    //

    throw (DWORD)ERROR_FILE_NOT_FOUND;
}