windows-xp/Source/XPSP1/NT/net/config/common/ncbase/naming.cpp

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 2001.
//
//  File:       N A M I N G . C P P
//
//  Contents:   Generates Connection Names Automatically
//
//  Notes:
//
//  Author:     deonb    27 Feb 2001
//
//----------------------------------------------------------------------------

#include "pch.h"
#pragma hdrstop
#include "ncnetcfg.h"
#include "netcon.h"
#include "netconp.h"
#include <ntddndis.h>
#include <ndisprv.h>
#include <devioctl.h>
#include <ndispnp.h>
#include "naming.h"


extern const WCHAR c_szBiNdisAtm[];
extern const WCHAR c_szInfId_MS_AtmElan[];
const WCHAR        c_szDevice[] = L"\\DEVICE\\";

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::CIntelliName
//
//  Purpose:    Constructor
//
//  Arguments:
//      hInstance [in]  Resource instance of binary with naming.rc included
//
//      pFNDuplicateNameCheck [in]   Callback function of duplicate check. Can be NULL \
//                                   or otherwise of the following callback type:
//         + typedef BOOL FNDuplicateNameCheck
//         +              pIntelliName  [in]  CIntelliName this pointer (for HrGetPseudoMediaTypes callback)
//         +              szName        [in]  Name to check for
//         +              pncm          [out] NetCon Media Type of conflicting connection
//         +              pncms         [out] NetCon SubMedia Type of conflicting connection
//         +        return TRUE - if conflicting found or FALSE if no conflicting connection found
//
//  Returns: None        
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:      
//
CIntelliName::CIntelliName(HINSTANCE hInstance, FNDuplicateNameCheck *pFNDuplicateNameCheck)
{
    m_pFNDuplicateNameCheck = pFNDuplicateNameCheck;
    m_hInstance = hInstance;
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::NameExists
//
//  Purpose:    Check if a name already exists
//
//  Arguments:
//      szName [in]  Name to check for
//      pncm   [out] NetCon Media Type of conflicting connection
//      pncms  [out] NetCon SubMedia Type of conflicting connection
//
//  Returns: TRUE if exists, FALSE if not        
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:      
//
BOOL CIntelliName::NameExists(IN LPCWSTR szName, IN OUT NETCON_MEDIATYPE *pncm, IN NETCON_SUBMEDIATYPE *pncms)
{
    if (m_pFNDuplicateNameCheck)
    {
        Assert(pncm);
        Assert(pncms);

        if (IsReservedName(szName))
        {
            return TRUE;
        }

        return (*m_pFNDuplicateNameCheck)(this, szName, pncm, pncms);
    }

    return FALSE;
}


//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::IsReservedName
//
//  Purpose:    Check if a name is a reserved name
//
//  Arguments:
//      szName [in]  Name to check for
//
//  Returns: TRUE if reserved, FALSE if not
//
//  Author:     deonb   12 Mar 2001
//
//  Notes:      
//
BOOL CIntelliName::IsReservedName(LPCWSTR szName)
{
    UINT  uiReservedNames[] = {IDS_RESERVED_INCOMING, 
                               IDS_RESERVED_NCW, 
                               IDS_RESERVED_HNW};

    for (int x = 0; x < celems(uiReservedNames); x++)
    {
        WCHAR szReservedName[MAX_PATH];
        int nSiz = LoadString (m_hInstance, uiReservedNames[x], szReservedName, MAX_PATH);
        if (nSiz)
        {
            if (0 == lstrcmpi(szName, szReservedName))
            {
                return TRUE;
            }
        }
    }

    return FALSE;
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::GenerateNameRenameOnConflict
//
//  Purpose:    Generate a name, rename if it conflicts with an existing name
//
//  Arguments:
//      guid              [in]  GUID of connection
//      ncm               [in]  NetCon Media Type of Connection 
//      dwCharacteristics [in]  NCCF_ Characteristics of Connection (Pass 0 if you don't know)
//      szHintName        [in]  Hint of name (will use as is if not conflicting)
//      szHintType        [in]  String of NetCon Media Type
//      szName            [out] Resulting connection name - free with CoTaskMemFree
//
//  Returns: HRESULT
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:   
//
HRESULT CIntelliName::GenerateNameRenameOnConflict(IN REFGUID guid, IN NETCON_MEDIATYPE ncm, IN DWORD dwCharacteristics, IN LPCWSTR szHintName, IN LPCWSTR szHintType, OUT LPWSTR *szName)
{
    WCHAR szTemp[MAX_PATH+1];
    WCHAR szBaseName[MAX_PATH +1];

    Assert(szName)
    *szName = NULL;

    wcsncpy(szTemp, szHintName, MAX_PATH-45); // reserve last 45 bytes to include specialized info.

    BOOL fHasName = FALSE;

    DWORD dwInstance = 2;
    wcsncpy(szBaseName, szTemp, MAX_PATH);

    NETCON_MEDIATYPE ncmdup; 
    NETCON_SUBMEDIATYPE ncmsdup;
    if (NameExists(szTemp, &ncmdup, &ncmsdup))
    {
        fHasName = TRUE;

        BOOL fHasTypeAlready = FALSE;
        if ( (ncmdup == ncm) || (NCM_LAN == ncm) )
        {
            fHasTypeAlready = TRUE;
        }

        if (!fHasTypeAlready)
        {
            wsprintf(szTemp, L"%s (%s)", szBaseName, szHintType);
            Assert(wcslen(szTemp) <= MAX_PATH);
            wcsncpy(szBaseName, szTemp, MAX_PATH);
        }
        else
        {
            wsprintf(szTemp, L"%s %d", szBaseName, dwInstance);
            Assert(wcslen(szTemp) <= MAX_PATH);
            dwInstance++;
        }

        while (NameExists(szTemp, &ncmdup, &ncmsdup) && (dwInstance < 65535) )
        {
            wsprintf(szTemp, L"%s %d", szBaseName, dwInstance);
            Assert(wcslen(szTemp) <= MAX_PATH);
            dwInstance++;
        }

        if ( (dwInstance >= 65535) && NameExists(szTemp, &ncmdup, &ncmsdup) )
        {
            fHasName = FALSE;
        }
    }
    else
    {
        fHasName = TRUE;
    }

    if (fHasName)
    {
        HRESULT hr = HrCoTaskMemAllocAndDupSz(szTemp, szName);
        return hr;
    }
    else
    {
        return E_FAIL;
    }
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::GenerateNameFromResource
//
//  Purpose:    Generate a name, rename if it conflicts with an existing name
//
//  Arguments:
//      guid              [in]  GUID of connection
//      ncm               [in]  NetCon Media Type of Connection 
//      dwCharacteristics [in]  NCCF_ Characteristics of Connection (Pass 0 if you don't know)
//      szHintName        [in]  Hint of name (will use as is if not conflicting)
//      uiNameID          [in]  Resource id of default name
//      uiTypeId          [in]  Resource id of default type
//      szName            [out] Resulting connection name - free with CoTaskMemFree
//
//  Returns: HRESULT
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:   
//
HRESULT CIntelliName::GenerateNameFromResource(IN REFGUID guid, IN NETCON_MEDIATYPE ncm, IN DWORD dwCharacteristics, IN LPCWSTR szHint, IN UINT uiNameID, IN UINT uiTypeId, OUT LPWSTR *szName)
{
    Assert(szName);
    *szName = NULL;

    WCHAR szHintName[MAX_PATH+1];
    WCHAR szTypeName[MAX_PATH+1];

    if (!szHint || *szHint == L'\0')
    {
        int nSiz = LoadString (m_hInstance, uiNameID, szHintName, MAX_PATH);
        AssertSz(nSiz, "Resource string not found");
    }
    else
    {
        wcsncpy(szHintName, szHint, MAX_PATH);
    }

    int nSiz = LoadString (m_hInstance, uiTypeId, szTypeName, MAX_PATH);
    AssertSz(nSiz, "Resource string not found");
    
    return GenerateNameRenameOnConflict(guid, ncm, dwCharacteristics, szHintName, szTypeName, szName);
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::HrGetPseudoMediaTypes
//
//  Purpose:    Generate a name, rename if it conflicts with an existing name
//
//  Arguments:
//      guid     [in]  GUID of connection
//      pncm     [out] Pseudo-NetCon Media Type of Connection (Only NCM_PHONE or NCM_LAN)
//      pncms    [out] SubMedia Type for LAN connections
//
//  Returns: HRESULT
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:   
//
HRESULT CIntelliName::HrGetPseudoMediaTypes(IN REFGUID guid, OUT NETCON_MEDIATYPE *pncm, OUT NETCON_SUBMEDIATYPE* pncms)
{
    Assert(pncms);
    Assert(pncm);
    Assert(guid != GUID_NULL);

    HRESULT hr;

    *pncms = NCSM_NONE;

    INetCfg* pNetCfg;
    hr = CoCreateInstance(
            CLSID_CNetCfg,
            NULL,
            CLSCTX_INPROC_SERVER | CLSCTX_NO_CODE_DOWNLOAD,
            IID_INetCfg,
            reinterpret_cast<LPVOID *>(&pNetCfg));
    if (SUCCEEDED(hr))
    {
        hr = pNetCfg->Initialize(NULL);
        if (SUCCEEDED(hr))
        {
            CIterNetCfgComponent nccIter(pNetCfg, &GUID_DEVCLASS_NET);
            INetCfgComponent* pnccAdapter = NULL;
            BOOL fFound = FALSE;

            while (!fFound && SUCCEEDED(hr) &&
                   (S_OK == (hr = nccIter.HrNext(&pnccAdapter))))
            {
                GUID guidDev;
                hr = pnccAdapter->GetInstanceGuid(&guidDev);

                if (S_OK == hr)
                {
                    if (guid == guidDev)
                    {
                        hr = HrIsLanCapableAdapter(pnccAdapter);
                        Assert(SUCCEEDED(hr));
                        if (SUCCEEDED(hr))
                        {
                            fFound = TRUE;
                            if (S_FALSE == hr)
                            {
                                *pncm = NCM_PHONE;
                            } 
                            else if (S_OK == hr)
                            {
                                *pncm = NCM_LAN;

                                BOOL            bRet;

                                DWORD dwMediaType;
                                DWORD dwMediaTypeSize = sizeof(DWORD);
                                hr = HrQueryNDISAdapterOID(guid, 
                                                          OID_GEN_PHYSICAL_MEDIUM, 
                                                          &dwMediaTypeSize,
                                                          &dwMediaType);
                                if (S_OK == hr)
                                {
                                    switch (dwMediaType)
                                    {
                                        case NdisPhysicalMedium1394:
                                            *pncms = NCSM_1394;
                                            break;
                                        case NdisPhysicalMediumWirelessLan:
                                        case NdisPhysicalMediumWirelessWan:
                                            *pncms = NCSM_WIRELESS;
                                            break;
                                        default:
                                            hr = S_FALSE;
                                            break;
                                    }
                                }
                                
                                if (S_OK != hr) // Couldn't determine the Physical Media type. Try bindings next.
                                {
                                    HRESULT hrPhysicalMedia = hr;

                                    *pncms = NCSM_LAN;

                                    INetCfgComponentBindings* pnccb;
                                    hr = pnccAdapter->QueryInterface(IID_INetCfgComponentBindings,
                                                                       reinterpret_cast<LPVOID *>(&pnccb));
                                    if (SUCCEEDED(hr))
                                    {
                                        hr = pnccb->SupportsBindingInterface(NCF_UPPER, c_szBiNdisAtm);
                                        if (S_OK == hr)
                                        {
                                            *pncms = NCSM_ATM;
                                        }
                                        pnccb->Release();
                                    }

                                    if (NCSM_ATM != *pncms)
                                    {
                                        // Not ATM
                                        PWSTR pszwCompId;
                                        hr = pnccAdapter->GetId(&pszwCompId);
                                        if (SUCCEEDED(hr) && (0 == lstrcmpiW(c_szInfId_MS_AtmElan, pszwCompId)))
                                        {
                                            // ATM Elan
                                            *pncms = NCSM_ELAN;

                                            CoTaskMemFree(pszwCompId);
                                        }
                                    }

                                    if ( (FAILED(hrPhysicalMedia)) && 
                                         (NCSM_LAN == *pncms) )
                                    {
                                        // Couldn't determine anything specific from the bindings.
                                        // Return the hr from the Physical Media call if it was an error
                                        hr = hrPhysicalMedia;
                                    }
                                }
                            } 
                        } // HrIsLanCapableAdapter SUCCEEDED
                    } // guid == guidDev
                } // SUCCEEDED(pnccAdapter->GetInstanceGuid(&guidDev)
                else
                {
                    AssertSz(FALSE, "Could not get instance GUID for Adapter");
                }
                pnccAdapter->Release();
            } // while loop

            HRESULT hrT = pNetCfg->Uninitialize();
            TraceError("INetCfg failed to uninitialize", hrT);
        } // SUCCEEDED(pNetConfig->Initialize(NULL))
        pNetCfg->Release();
    } // SUCCEEDED(CoCreateInstance(pNetCfg))
    else
    {
        AssertSz(FALSE, "Could not create INetCfg");
    }

    TraceErrorOptional("HrGetPseudoMediaTypes", hr, (S_FALSE == hr));

    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::GenerateName
//
//  Purpose:    Generate a name based on a hint
//
//  Arguments:
//      guid              [in] GUID of connection
//      ncm               [in] NetCon Media Type of Connection
//      dwCharacteristics [in]  NCCF_ Characteristics of Connection (Pass 0 if you don't know)
//      szHintName        [in]  Hint of name (will use as is if not conflicting)
//      szName            [out] Resulting connection name - free with CoTaskMemFree
//
//  Returns: HRESULT
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:   
//
HRESULT CIntelliName::GenerateName(IN REFGUID guid, IN NETCON_MEDIATYPE ncm, IN DWORD dwCharacteristics, IN LPCWSTR szHint, OUT LPWSTR * szName)
{
    Assert(szName);
    *szName = NULL;
    
    HRESULT hr = S_OK;

    if (dwCharacteristics & NCCF_INCOMING_ONLY)
    {
        WCHAR szIncomingName[MAX_PATH];
        int nSiz = LoadString(m_hInstance, IDS_DEFAULT_IncomingName, szIncomingName, MAX_PATH);
        AssertSz(nSiz, "Resource string IDS_TO_THE_INTERNET not found");
        if (nSiz)
        {
            hr = HrCoTaskMemAllocAndDupSz(szIncomingName, szName);
        }
        else
        {
            hr = E_FAIL;
        }
    }
    else
    {
        switch (ncm)
        { 
            case NCM_NONE:
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_IncomingName, IDS_DEFAULT_IncomingName_Type, szName);
                break;
            case NCM_ISDN:
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_ISDNName, IDS_DEFAULT_ISDNName_Type, szName);
                break;
            case NCM_DIRECT: 
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_DIRECTName, IDS_DEFAULT_DIRECTName_Type, szName);
                break;
            case NCM_PHONE: 
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_PHONEName, IDS_DEFAULT_PHONEName_Type, szName);
                break;
            case NCM_TUNNEL: 
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_VPNName, IDS_DEFAULT_VPNName_Type, szName);
                break;
            case NCM_PPPOE: 
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_PPPOEName, IDS_DEFAULT_PPPOEName_Type, szName);
                break;
            case NCM_BRIDGE: 
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_BRIDGEName, IDS_DEFAULT_BRIDGEName_Type, szName);
                break;
            case NCM_SHAREDACCESSHOST_LAN:
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_SAHLANName, IDS_DEFAULT_SAHLANName_Type, szName);
                break;
            case NCM_SHAREDACCESSHOST_RAS: 
                hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_SAHRASName, IDS_DEFAULT_SAHRASName_Type, szName);
                break;
            case NCM_LAN: 
                NETCON_MEDIATYPE ncmCheck;
                NETCON_SUBMEDIATYPE pncms;
                {
                    DWORD dwRetries = 15;
                    HRESULT hrT;
                    do
                    {
                        hrT = HrGetPseudoMediaTypes(guid, &ncmCheck, &pncms);
                        if (FAILED(hrT))
                        {
                            Sleep(500); // This is probably being called during device install, so give the adapter some
                                        // time to get itself enabled first.

                            if (dwRetries > 1)
                            {
                                TraceTag(ttidError, "HrGetPseudoMediaTypes failed during device name initialization. Retrying...");
                            }
                            else
                            {
                                TraceTag(ttidError, "HrGetPseudoMediaTypes failed during device name initialization. Giving up.");
                            }
                                
                        }
                    } while (FAILED(hrT) && --dwRetries);

                    if (SUCCEEDED(hrT))
                    {
                        AssertSz(ncmCheck == NCM_LAN, "This LAN adapter thinks it's something else");
                    }
                    else
                    {
                        pncms = NCSM_LAN; // If we run out of time, just give up and assume LAN.
                        TraceTag(ttidError, "Could not determine the exact Media SubType for this adapter. Assuming LAN (and naming it such).");
                    }

                    switch (pncms)
                    {
                        case NCSM_NONE:
                            AssertSz(FALSE, "LAN Connections should not be NCSM_NONE");
                            hr = E_FAIL;
                            break;
                        case NCSM_LAN:
                            hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_LANName, IDS_DEFAULT_LANName_Type, szName);
                            break;
                        case NCSM_ATM:
                            hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_ATMName, IDS_DEFAULT_ATMName_Type, szName);
                            break;
                        case NCSM_ELAN:
                            hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_ELANName, IDS_DEFAULT_ELANName_Type, szName);
                            break;
                        case NCSM_WIRELESS:
                            hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_WirelessName, IDS_DEFAULT_WirelessName_Type, szName);
                            break;
                        case NCSM_1394:
                            hr = GenerateNameFromResource(guid, ncm, dwCharacteristics, szHint, IDS_DEFAULT_1394Name, IDS_DEFAULT_1394Name_Type, szName);
                            break;
                        default:
                            AssertSz(FALSE, "Unknown submedia type");
                            hr = E_FAIL;
                            break;
                    }
                }
                break;
            default:
                AssertSz(FALSE, "Unknown media type");
                hr= E_FAIL;
        }
    }

    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::GenerateInternetName
//
//  Purpose:    Generate a name with " to the Internet" appened to it
//
//  Arguments:
//      guid              [in] GUID of connection
//      ncm               [in] NetCon Media Type of Connection
//      dwCharacteristics [in]  NCCF_ Characteristics of Connection (Pass 0 if you don't know)
//      szName            [out] Resulting connection name - free with CoTaskMemFree
//
//  Returns: HRESULT
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:   Will append " to the Internet" to a name
//
HRESULT CIntelliName::GenerateInternetName(REFGUID guid, NETCON_MEDIATYPE ncm, DWORD dwCharacteristics, OUT LPWSTR * szName)
{
    LPWSTR szTmpName;
    WCHAR szBuffer[MAX_PATH];
    WCHAR szHint[MAX_PATH];
    HRESULT hr = E_FAIL;

    CIntelliName IntelliNameNoDupCheck(m_hInstance, NULL); // Generate the original name 
    hr = IntelliNameNoDupCheck.GenerateName(guid, ncm, dwCharacteristics, szHint, &szTmpName);
    if (SUCCEEDED(hr))
    {
        int nSiz = LoadString(m_hInstance, IDS_TO_THE_INTERNET, szBuffer, MAX_PATH);
        AssertSz(nSiz, "Resource string IDS_TO_THE_INTERNET not found");
        if (nSiz)
        {
            wcsncpy(szHint, szTmpName, MAX_PATH - nSiz);
            wcsncat(szHint, szBuffer, MAX_PATH);
            CoTaskMemFree(szTmpName);

            return GenerateName(guid, ncm, dwCharacteristics, szHint, szName);
        }
    }
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::GenerateHomeNetName
//
//  Purpose:    Generate a name with " on my Home Network" appened to it
//
//  Arguments:
//      guid              [in] GUID of connection
//      ncm               [in] NetCon Media Type of Connection
//      dwCharacteristics [in]  NCCF_ Characteristics of Connection (Pass 0 if you don't know)
//      szName            [out] Resulting connection name - free with CoTaskMemFree
//
//  Returns: HRESULT
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:   Will append " on my Home Network" to a name
//
HRESULT CIntelliName::GenerateHomeNetName(REFGUID guid, NETCON_MEDIATYPE ncm, DWORD dwCharacteristics, OUT LPWSTR * szName)
{
    LPWSTR szTmpName;
    WCHAR szBuffer[MAX_PATH];
    WCHAR szHint[MAX_PATH];
    HRESULT hr = E_FAIL;

    CIntelliName IntelliNameNoDupCheck(m_hInstance, NULL); // Generate the original name 
    hr = IntelliNameNoDupCheck.GenerateName(guid, ncm, dwCharacteristics, szHint, &szTmpName);
    if (SUCCEEDED(hr))
    {
        int nSiz = LoadString(m_hInstance, IDS_ON_THE_HOMENET, szBuffer, MAX_PATH);
        AssertSz(nSiz, "Resource string IDS_ON_THE_HOMENET not found");
        if (nSiz)
        {
            wcsncpy(szHint, szTmpName, MAX_PATH - nSiz);
            wcsncat(szHint, szBuffer, MAX_PATH);
            CoTaskMemFree(szTmpName);

            return GenerateName(guid, ncm, dwCharacteristics, szHint, szName);
        }
    }
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   OpenDevice
//
//  Purpose:    Open a Driver
//
//  Arguments:
//      DeviceName [in]   Name of device
//
//  Returns: HANDLE of Device or NULL 
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:  Use GetLastError() for error info
//
HANDLE  OpenDevice(IN	PUNICODE_STRING	DeviceName)
{
	OBJECT_ATTRIBUTES	ObjAttr;
	NTSTATUS			Status;
	IO_STATUS_BLOCK		IoStsBlk;
	HANDLE				Handle;

	InitializeObjectAttributes(&ObjAttr,
							   DeviceName,
							   OBJ_CASE_INSENSITIVE,
							   NULL,
							   NULL);

	Status = NtOpenFile(&Handle,
						FILE_GENERIC_READ | FILE_GENERIC_WRITE,
						&ObjAttr,
						&IoStsBlk,
						FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
						FILE_SYNCHRONOUS_IO_NONALERT);
	if (Status != STATUS_SUCCESS)
	{
		SetLastError(RtlNtStatusToDosError(Status));
	}
	return(Handle);
}

//+---------------------------------------------------------------------------
//
//  Function:   HrQueryDeviceOIDByName
//
//  Purpose:    Query an driver for an IOCTL & OID
//
//  Arguments:
//      Device      [in]     Name of device
//      NDIS_OID    [in]     OID to query for
//      pnSize      [in out] pnSize - size of buffer
//      pBuffer     [out]    Buffer
//
//  Returns: HRESULT
//
//  Author:     deonb   4 April 2001
//
//  Notes: 
//
HRESULT HrQueryDeviceOIDByName(IN     LPCWSTR         szDeviceName,
                               IN     DWORD           dwIoControlCode,
                               IN     ULONG           Oid,
                               IN OUT LPDWORD         pnSize,
                               OUT    LPVOID          pbValue)
{
    HRESULT hr = S_OK;
    NDIS_STATISTICS_VALUE StatsBuf;
    HANDLE  hDevice;
    BOOL    fResult = FALSE;

    UNICODE_STRING  ustrDevice;
    ::RtlInitUnicodeString(&ustrDevice, szDeviceName);

    Assert(pbValue);
    ZeroMemory(pbValue, *pnSize);
    
    hDevice = OpenDevice(&ustrDevice);

    if (hDevice != NULL)
    {
        ULONG  cb;

        DWORD dwStatsBufLen = sizeof(NDIS_STATISTICS_VALUE) - sizeof(UCHAR) + *pnSize;
        PNDIS_STATISTICS_VALUE pStatsBuf = reinterpret_cast<PNDIS_STATISTICS_VALUE>(new BYTE[dwStatsBufLen]);
        if (pStatsBuf)
        {
            fResult = DeviceIoControl(hDevice,
                                      dwIoControlCode,                  // IOCTL code
                                      &Oid,                             // input buffer
                                      sizeof(ULONG),                    // input buffer size
                                      pStatsBuf,                        // output buffer
                                      dwStatsBufLen,                    // output buffer size
                                      &cb,                              // bytes returned
                                      NULL);                            // OVERLAPPED structure

            if (fResult)
            {
                *pnSize = cb;
                if (0 == cb)
                {
                    hr = S_FALSE;
                }
                else
                {
                    if (pStatsBuf->DataLength > *pnSize)
                    {
                        AssertSz(FALSE, "Pass a larger buffer for this OID");
                        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
                        *pnSize = 0;
                    }
                    else
                    {
                        memcpy(pbValue, &(pStatsBuf->Data), pStatsBuf->DataLength);
                    }
                }
            }
            else
            {
                hr = HrFromLastWin32Error();
            }
            delete pStatsBuf;
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
        
        CloseHandle(hDevice);
    }
    else
    {
        hr = HrFromLastWin32Error();
    }

    TraceHr(ttidError, FAL, hr, S_FALSE == hr, "HrQueryDeviceOIDByName could not read the device properties for device %S", szDeviceName);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   HrQueryNDISAdapterOID
//
//  Purpose:    Query an NDIS Driver for an OID
//
//  Arguments:
//      Device      [in]     Name of device
//      NDIS_OID    [in]     OID to query for
//      pnSize      [in out] pnSize - size of buffer
//      pBuffer     [out]    Buffer
//
//  Returns: HRESULT
//
//  Author:     deonb   4 April 2001
//
//  Notes: 
//

HRESULT HrQueryNDISAdapterOID(IN     REFGUID         guidId,
                              IN     NDIS_OID        Oid,
                              IN OUT LPDWORD         pnSize,
                              OUT    LPVOID          pbValue)
{
    WCHAR  szDeviceName[c_cchGuidWithTerm + celems(c_szDevice)];

    wcscpy(szDeviceName, c_szDevice);
    ::StringFromGUID2(guidId, szDeviceName + (celems(c_szDevice)-1), c_cchGuidWithTerm);
    
    Assert(wcslen(szDeviceName) < c_cchGuidWithTerm + celems(c_szDevice));
    
    return HrQueryDeviceOIDByName(szDeviceName, IOCTL_NDIS_QUERY_SELECTED_STATS, Oid, pnSize, pbValue);
}
                         
//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::IsMediaWireless
//
//  Purpose:    Queries a LAN Card to see if it's 802.1x
//
//  Arguments:
//      gdDevice [in] GUID of Network Card
//  
//  Returns:    TRUE if WireLess, FALSE if not
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:
//
BOOL IsMediaWireless(NETCON_MEDIATYPE ncm, const GUID &gdDevice)
{
    BOOL            bRet;

    Assert(gdDevice != GUID_NULL);

    bRet = FALSE;
    // Prime the structure
    
    switch( ncm ) 
    {
        case NCM_LAN:
            // Retrieve the statistics
   
            DWORD dwMediaType;
            DWORD dwMediaTypeSize = sizeof(dwMediaType);
            HRESULT hr = HrQueryNDISAdapterOID(gdDevice, 
                                      OID_GEN_PHYSICAL_MEDIUM, 
                                      &dwMediaTypeSize,
                                      &dwMediaType);
            if (SUCCEEDED(hr))
            {
               bRet = (dwMediaType == NdisPhysicalMediumWirelessLan) ||
                      (dwMediaType == NdisPhysicalMediumWirelessWan);
            }
    }

    return bRet;
}

//+---------------------------------------------------------------------------
//
//  Function:   CIntelliName::IsMedia1394
//
//  Purpose:    Queries a LAN Card to see if it's 1394 (FireWire / iLink)
//
//  Arguments:
//      gdDevice [in] GUID of Network Card
//
//  Returns:    TRUE if WireLess, FALSE if not
//
//  Author:     deonb   27 Feb 2001
//
//  Notes:
//
BOOL IsMedia1394(NETCON_MEDIATYPE ncm, const GUID &gdDevice)
{
    BOOL            bRet;

    Assert(gdDevice != GUID_NULL);

    bRet = FALSE;
    // Prime the structure
    
    switch( ncm ) 
    {
        case NCM_LAN:
            // Retrieve the statistics
            DWORD dwMediaType;
            DWORD dwMediaTypeSize = sizeof(DWORD);
            HRESULT hr = HrQueryNDISAdapterOID(gdDevice, 
                                      OID_GEN_PHYSICAL_MEDIUM, 
                                      &dwMediaTypeSize,
                                      &dwMediaType);
            if (SUCCEEDED(hr))
            {
               bRet = (dwMediaType == NdisPhysicalMedium1394);
            }
    }

    return bRet;
}