//+--------------------------------------------------------------------------- // // 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 #include #include #include #include "naming.h" #include #include "wzcsapi.h" extern const WCHAR c_szBiNdisAtm[]; extern const WCHAR c_szInfId_MS_AtmElan[]; const WCHAR c_szDevice[] = L"\\DEVICE\\"; #define MAX_TYPE_NAME_LEN 45 //+--------------------------------------------------------------------------- // // 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(IN HINSTANCE hInstance, IN 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, OUT NETCON_MEDIATYPE *pncm, OUT NETCON_SUBMEDIATYPE *pncms) const { 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(IN LPCWSTR szName) const { 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) const { HRESULT hr = S_OK; WCHAR szTemp[NETCON_MAX_NAME_LEN]; WCHAR szBaseName[NETCON_MAX_NAME_LEN]; Assert(szName) *szName = NULL; lstrcpynW(szTemp, szHintName, celems(szTemp) - MAX_TYPE_NAME_LEN); // reserve bytes at end to include specialized info. DWORD dwInstance = 2; lstrcpynW(szBaseName, szTemp, celems(szBaseName) ); NETCON_MEDIATYPE ncmdup; NETCON_SUBMEDIATYPE ncmsdup; if (NameExists(szTemp, &ncmdup, &ncmsdup)) { BOOL fHasTypeAlready = FALSE; if ( (ncmdup == ncm) || (NCM_LAN == ncm) ) { fHasTypeAlready = TRUE; } if (!fHasTypeAlready) { if (DwFormatString(L"%1!s! (%2!s!)", szTemp, celems(szTemp), szBaseName, szHintType)) { lstrcpynW(szBaseName, szTemp, celems(szBaseName)); } else { hr = HrFromLastWin32Error(); } } else { if (!DwFormatString(L"%1!s! %2!d!", szTemp, celems(szTemp), szBaseName, dwInstance)) { hr = HrFromLastWin32Error(); } dwInstance++; } while ( SUCCEEDED(hr) && NameExists(szTemp, &ncmdup, &ncmsdup) && (dwInstance < 65535) ) { if (!DwFormatString(L"%1!s! %2!d!", szTemp, celems(szTemp), szBaseName, dwInstance)) { hr = HrFromLastWin32Error(); } dwInstance++; } if ( SUCCEEDED(hr) && (dwInstance >= 65535) && NameExists(szTemp, &ncmdup, &ncmsdup) ) { hr = E_FAIL; } } if (S_OK == hr) { hr = HrCoTaskMemAllocAndDupSz(szTemp, szName, NETCON_MAX_NAME_LEN); } return hr; } //+--------------------------------------------------------------------------- // // 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) const { Assert(szName); *szName = NULL; WCHAR szHintName[NETCON_MAX_NAME_LEN]; WCHAR szTypeName[MAX_TYPE_NAME_LEN - 3]; // - 3 as this is put later into a MAX_TYPE_NAME_LEN character // buffer with ' (%s)' at the end if (!szHint || *szHint == L'\0') { int nSiz = LoadString (m_hInstance, uiNameID, szHintName, celems(szHintName) ); AssertSz(nSiz, "Resource string not found"); } else { lstrcpynW(szHintName, szHint, celems(szHintName) ); } int nSiz = LoadString (m_hInstance, uiTypeId, szTypeName, celems(szTypeName) ); 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) const { 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(&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; 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(&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)) { if (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; } } if (NCSM_LAN == *pncms) { // Could still be wireless... Check with Zero Config: if (IsMediaWireless(NCM_LAN, guid)) { *pncms = NCSM_WIRELESS; } } } } // 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) const { 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_DEFAULT_IncomingName not found"); if (nSiz) { hr = HrCoTaskMemAllocAndDupSz(szIncomingName, szName, NETCON_MAX_NAME_LEN); } 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: 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, // Object DeviceName, // Object Name OBJ_CASE_INSENSITIVE, // Attributes NULL, // root directory NULL); // security descriptor 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: // szDeviceName [in] Name of device // dwIoControlCode [in] Device IO Control code // Oid [in] OID to query for // pnSize [in out] pnSize - size of buffer, returns size filled into 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(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: // guidId [in] Guid of device // Oid [in] OID to query for // pnSize [in out] pnSize - size of buffer, returns size filled into buffer // pbValue [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)]; lstrcpynW(szDeviceName, c_szDevice, celems(szDeviceName) ); ::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: // ncm [in] Media type (if not NCM_LAN) function will return false // gdDevice [in] GUID of Network Card // // Returns: TRUE if WireLess, FALSE if not or error // // Author: deonb 27 Feb 2001 // // Notes: // BOOL IsMediaWireless(IN NETCON_MEDIATYPE ncm, IN const GUID & gdDevice) { BOOL bRet; Assert(gdDevice != GUID_NULL); bRet = FALSE; // Prime the structure switch( ncm ) { case NCM_LAN: INTF_ENTRY intfEntry; ZeroMemory(&intfEntry, sizeof(INTF_ENTRY)); LPOLESTR lpszClsId = NULL; HRESULT hr = StringFromCLSID(gdDevice, &lpszClsId); if (S_OK == hr) { intfEntry.wszGuid = lpszClsId; DWORD dwErr = WZCQueryInterface(NULL, INTF_OIDSSUPP, &intfEntry, NULL); hr = HRESULT_FROM_WIN32(dwErr); if (S_OK == hr) { if (intfEntry.dwCtlFlags & INTFCTL_OIDSSUPP) { bRet = TRUE; } } CoTaskMemFree(lpszClsId); } TraceErrorOptional("IsMediaWireless failed with", hr, (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr) ); } return bRet; } //+--------------------------------------------------------------------------- // // Function: CIntelliName::IsMedia1394 // // Purpose: Queries a LAN Card to see if it's 1394 (FireWire / iLink) // // Arguments: // ncm [in] Media type (if not NCM_LAN) function will return false // gdDevice [in] GUID of Network Card // // Returns: TRUE if WireLess, FALSE if not or error // // Author: deonb 27 Feb 2001 // // Notes: // BOOL IsMedia1394(IN NETCON_MEDIATYPE ncm, IN 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; }