|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1998 - 2001
//
// File : bridge.cpp
//
// Contents : bridge context specific code
//
// Notes :
//
// Author : Raghu Gatta (rgatta) 11 May 2001
//
//----------------------------------------------------------------------------
#include "precomp.h"
#pragma hdrstop
const TCHAR c_stRegKeyBridgeAdapters[] = _T("SYSTEM\\CurrentControlSet\\Services\\Bridge\\Parameters\\Adapters");const TCHAR c_stFCMode[] = _T("ForceCompatibilityMode");
CMD_ENTRY g_BridgeSetCmdTable[] = { CREATE_CMD_ENTRY(BRIDGE_SET_ADAPTER, HandleBridgeSetAdapter),};
CMD_ENTRY g_BridgeShowCmdTable[] = { CREATE_CMD_ENTRY(BRIDGE_SHOW_ADAPTER, HandleBridgeShowAdapter),};
CMD_GROUP_ENTRY g_BridgeCmdGroups[] = { CREATE_CMD_GROUP_ENTRY(GROUP_SET, g_BridgeSetCmdTable), CREATE_CMD_GROUP_ENTRY(GROUP_SHOW, g_BridgeShowCmdTable),};
ULONG g_ulBridgeNumGroups = sizeof(g_BridgeCmdGroups)/sizeof(CMD_GROUP_ENTRY);
CMD_ENTRY g_BridgeCmds[] ={ CREATE_CMD_ENTRY(INSTALL, HandleBridgeInstall), CREATE_CMD_ENTRY(UNINSTALL, HandleBridgeUninstall),};
ULONG g_ulBridgeNumTopCmds = sizeof(g_BridgeCmds)/sizeof(CMD_ENTRY);
DWORD WINAPIBridgeDump( IN LPCWSTR pwszRouter, IN OUT LPWSTR *ppwcArguments, IN DWORD dwArgCount, IN LPCVOID pvData ){ //
// Output the string that shows our settings.
// The idea here is to spit out a script that,
// when run from the command line (netsh -f script)
// will cause your component to be configured
// exactly as it is when this dump command was run.
//
PrintMessageFromModule( g_hModule, DMP_BRIDGE_HEADER ); PrintMessageFromModule( g_hModule, DMP_BRIDGE_FOOTER );
return NO_ERROR; }
HRESULTHrCycleBridge( IHNetBridge *pIHNetBridge ){ HRESULT hr = S_OK; //
// Check to see if the bridge is up and running.
// If it is, then disable and reenable
//
do { //
// Get the pointer to IID_IHNetConnection interface of this
// bridged connection
//
CComPtr<IHNetConnection> spIHNConn;
hr = pIHNetBridge->QueryInterface( IID_PPV_ARG(IHNetConnection, &spIHNConn) );
assert(SUCCEEDED(hr)); if (FAILED(hr)) { break; }
INetConnection *pINetConn;
hr = spIHNConn->GetINetConnection(&pINetConn);
if (SUCCEEDED(hr)) { NETCON_PROPERTIES* pNCProps;
hr = pINetConn->GetProperties(&pNCProps);
if(SUCCEEDED(hr)) { //
// check status - restart only if already running
//
if (pNCProps->Status == NCS_CONNECTED || pNCProps->Status == NCS_CONNECTING) { pINetConn->Disconnect();
pINetConn->Connect(); } NcFreeNetconProperties(pNCProps); }
ReleaseObj(pINetConn); } } while(FALSE); return hr;}
DWORDSetBridgeAdapterInfo( DWORD adapterId, BOOL bFlag ){ DWORD dwErr = NO_ERROR; IHNetCfgMgr* pIHNetCfgMgr = NULL; HRESULT hr = S_OK;
hr = HrInitializeHomenetConfig( &g_fInitCom, &pIHNetCfgMgr );
if (SUCCEEDED(hr)) { //
// Get the IHNetBridgeSettings
//
CComPtr<IHNetBridgeSettings> spIHNetBridgeSettings;
hr = pIHNetCfgMgr->QueryInterface( IID_PPV_ARG(IHNetBridgeSettings, &spIHNetBridgeSettings) );
if (SUCCEEDED(hr)) { //
// Get the IEnumHNetBridges
//
CComPtr<IEnumHNetBridges> spehBridges;
if ((hr = spIHNetBridgeSettings->EnumBridges(&spehBridges)) == S_OK) { //
// Get the first IHNetBridge
//
CComPtr<IHNetBridge> spIHNetBridge;
if ((hr = spehBridges->Next(1, &spIHNetBridge, NULL)) == S_OK) { { //
// We currently should have only one bridge;
// this may change in the future. The
// code here is just to catch future instances
// where this function would have to change in case
// there is more than one bridge.
//
CComPtr<IHNetBridge> spIHNetBridge2;
if ((hr = spehBridges->Next(1, &spIHNetBridge2, NULL)) == S_OK) { assert(FALSE); } }
//
// Get the IEnumHNetBridgedConnections
//
CComPtr<IEnumHNetBridgedConnections> spehBrdgConns;
if ((hr = spIHNetBridge->EnumMembers(&spehBrdgConns)) == S_OK) { //
// enumerate all the IHNetBridgedConnections
//
DWORD id = 0; IHNetBridgedConnection* pIHNetBConn;
spehBrdgConns->Reset(); while (S_OK == spehBrdgConns->Next(1, &pIHNetBConn, NULL)) { id++;
if (id != adapterId) { //
// release the IHNetBridgedConnection
//
ReleaseObj(pIHNetBConn); continue; } //
// Get the pointer to IID_IHNetConnection interface of this
// bridged connection
//
CComPtr<IHNetConnection> spIHNConn;
hr = pIHNetBConn->QueryInterface( IID_PPV_ARG(IHNetConnection, &spIHNConn) ); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { GUID *pGuid = NULL;
hr = spIHNConn->GetGuid(&pGuid);
if (SUCCEEDED(hr) && (NULL != pGuid)) { PTCHAR pwszKey = NULL; int keyLen; TCHAR wszGuid[128]; HKEY hKey = NULL; DWORD dwDisp = 0; BOOL bCycleBridge = TRUE; DWORD dwOldValue; DWORD dwNewValue = (bFlag) ? 1 : 0;
do { ZeroMemory(wszGuid, sizeof(wszGuid));
StringFromGUID2( *pGuid, wszGuid, ARRAYSIZE(wszGuid) );
keyLen = _tcslen(c_stRegKeyBridgeAdapters) + _tcslen(_T("\\")) + _tcslen(wszGuid) + 1;
pwszKey = (TCHAR *) HeapAlloc( GetProcessHeap(), 0, keyLen * sizeof(TCHAR) ); if (!pwszKey) { break; }
ZeroMemory(pwszKey, sizeof(pwszKey)); _tcscpy(pwszKey, c_stRegKeyBridgeAdapters); _tcscat(pwszKey, _T("\\")); _tcscat(pwszKey, wszGuid);
dwErr = RegCreateKeyEx( HKEY_LOCAL_MACHINE, pwszKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwDisp );
if (ERROR_SUCCESS != dwErr) { break; }
//
// if the key was old, get its value
// and compare to see if we need to
// cycle the bridge
//
if (dwDisp && dwDisp == REG_OPENED_EXISTING_KEY) { DWORD dwSize = sizeof(dwOldValue); if (ERROR_SUCCESS == RegQueryValueEx( hKey, c_stFCMode, NULL, NULL, (LPBYTE)&dwOldValue, &dwSize)) { if (dwOldValue == dwNewValue) { //
// no need to cycle the bridge
//
bCycleBridge = FALSE; } } } dwErr = RegSetValueEx( hKey, c_stFCMode, 0, REG_DWORD, (LPBYTE) &dwNewValue, sizeof(dwNewValue) );
if (ERROR_SUCCESS != dwErr) { break; }
if (bCycleBridge) { //
// cycle the (respective) bridge
//
hr = HrCycleBridge( spIHNetBridge ); }
} while(FALSE);
//
// cleanup
//
if (hKey) { RegCloseKey(hKey); }
if (pwszKey) { HeapFree(GetProcessHeap(), 0, pwszKey); }
CoTaskMemFree(pGuid); } }
//
// release the IHNetBridgedConnection
//
ReleaseObj(pIHNetBConn);
break; } //while
} } } }
//
// we are done completely
//
hr = HrUninitializeHomenetConfig( g_fInitCom, pIHNetCfgMgr ); }
return (hr==S_OK) ? dwErr : hr;}
DWORDWINAPIHandleBridgeSetAdapter( IN LPCWSTR pwszMachine, IN OUT LPWSTR *ppwcArguments, IN DWORD dwCurrentIndex, IN DWORD dwArgCount, IN DWORD dwFlags, IN LPCVOID pvData, OUT BOOL *pbDone ){ DWORD dwRet = NO_ERROR; PDWORD pdwTagType = NULL; DWORD dwNumOpt; DWORD dwNumArg; DWORD dwRes; DWORD dwErrIndex =-1, i;
//
// default values
//
DWORD id = 0; DWORD bFCMode = FALSE; TAG_TYPE pttTags[] = { {TOKEN_OPT_ID, NS_REQ_PRESENT, FALSE}, {TOKEN_OPT_FCMODE, NS_REQ_ZERO, FALSE} // not required to allow for
// addition of future flags
};
if (dwCurrentIndex >= dwArgCount) { // No arguments specified. At least interface name should be specified.
return ERROR_INVALID_SYNTAX; } dwNumArg = dwArgCount - dwCurrentIndex;
pdwTagType = (DWORD *) HeapAlloc( GetProcessHeap(), 0, dwNumArg * sizeof(DWORD) );
if (NULL == pdwTagType) { return ERROR_NOT_ENOUGH_MEMORY; }
dwRet = PreprocessCommand( g_hModule, ppwcArguments, dwCurrentIndex, dwArgCount, pttTags, ARRAYSIZE(pttTags), 1, // min args
2, // max args
pdwTagType );
if (NO_ERROR != dwRet) { HeapFree(GetProcessHeap(), 0, pdwTagType);
if (ERROR_INVALID_OPTION_TAG == dwRet) { return ERROR_INVALID_SYNTAX; }
return dwRet; }
for ( i = 0; i < dwNumArg; i++) { switch (pdwTagType[i]) { case 0: { //
// refers to the 'id' field
//
id = _tcstoul(ppwcArguments[dwCurrentIndex + i], NULL, 10); break; } case 1: { //
// refers to the 'forcecompatmode' field
// possible values are : enable or disable
//
TOKEN_VALUE rgEnums[] = { {TOKEN_OPT_VALUE_ENABLE, TRUE}, {TOKEN_OPT_VALUE_DISABLE, FALSE} }; dwRet = MatchEnumTag( g_hModule, ppwcArguments[i + dwCurrentIndex], ARRAYSIZE(rgEnums), rgEnums, &dwRes );
if (dwRet != NO_ERROR) { dwErrIndex = i; i = dwNumArg; dwRet = ERROR_INVALID_PARAMETER; break; }
switch (dwRes) { case 0: bFCMode = FALSE; break;
case 1: bFCMode = TRUE; break; }
break; } default: { i = dwNumArg; dwRet = ERROR_INVALID_PARAMETER; break; } } //switch
if (dwRet != NO_ERROR) { break ; } } //for
//
// adapter id MUST be present
//
if (!pttTags[0].bPresent) { dwRet = ERROR_INVALID_SYNTAX; }
switch(dwRet) { case NO_ERROR: break;
case ERROR_INVALID_PARAMETER: if (dwErrIndex != -1) { PrintError( g_hModule, EMSG_BAD_OPTION_VALUE, ppwcArguments[dwErrIndex + dwCurrentIndex], pttTags[pdwTagType[dwErrIndex]].pwszTag ); } dwRet = ERROR_SUPPRESS_OUTPUT; break; default: //
// error message already printed
//
break; }
if (pdwTagType) { HeapFree(GetProcessHeap(), 0, pdwTagType); }
if (NO_ERROR != dwRet) { return dwRet; }
//
// we have the requisite info - process them
//
//
// since we may or may not have flag info, check for it
//
if (pttTags[1].bPresent) { dwRet = SetBridgeAdapterInfo( id, bFCMode ); }
return dwRet;}
DWORDShowBridgeAdapterInfo( DWORD id, IHNetConnection *pIHNConn ){ HRESULT hr;
//
// print out the bridged connections details
//
PWSTR pwszName = NULL; PWSTR pwszState = NULL; hr = pIHNConn->GetName(&pwszName);
if (SUCCEEDED(hr) && (NULL != pwszName)) { GUID *pGuid = NULL;
hr = pIHNConn->GetGuid(&pGuid);
if (SUCCEEDED(hr) && (NULL != pGuid)) { WCHAR wszGuid[128]; ZeroMemory(wszGuid, sizeof(wszGuid)); StringFromGUID2(*pGuid, wszGuid, ARRAYSIZE(wszGuid));
//
// check to see if registry settings present
//
// for forcecompatmode:
// + if key is not present --> disabled
// + if key is present
// 0x1 --> enabled
// 0x0 --> disabled
// + all other errors --> unknown
//
{ HKEY hBAKey; DWORD msgState = STRING_UNKNOWN;
if (ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE, c_stRegKeyBridgeAdapters, 0, KEY_READ, &hBAKey)) { HKEY hBCKey; if (ERROR_SUCCESS == RegOpenKeyEx( hBAKey, wszGuid, 0, KEY_READ, &hBCKey)) { DWORD dwFCModeState = 0; DWORD dwSize = sizeof(dwFCModeState); if (ERROR_SUCCESS == RegQueryValueEx( hBCKey, c_stFCMode, NULL, NULL, (LPBYTE)&dwFCModeState, &dwSize)) { switch (dwFCModeState) { case 0: msgState = STRING_DISABLED; break; case 1: msgState = STRING_ENABLED; break; default: msgState = STRING_UNKNOWN; } } else { //
// value not present
//
msgState = STRING_DISABLED; }
RegCloseKey(hBCKey); } else { //
// bridged connection guid key not present
//
msgState = STRING_DISABLED; }
RegCloseKey(hBAKey); }
pwszState = MakeString(g_hModule, msgState); }
PrintMessage( L" %1!2d! %2!-27s! %3!s!%n", id, pwszName, pwszState );
if (pwszState) { FreeString(pwszState); }
CoTaskMemFree(pGuid); }
CoTaskMemFree(pwszName); }
return NO_ERROR;}
DWORDShowBridgeAllAdapterInfo( BOOL bShowAll, // TRUE to show all
DWORD adapterId // valid only if bShowAll is FALSE
){ IHNetCfgMgr* pIHNetCfgMgr = NULL; HRESULT hr = S_OK;
hr = HrInitializeHomenetConfig( &g_fInitCom, &pIHNetCfgMgr );
if (SUCCEEDED(hr)) { //
// Get the IHNetBridgeSettings
//
CComPtr<IHNetBridgeSettings> spIHNetBridgeSettings;
hr = pIHNetCfgMgr->QueryInterface( IID_PPV_ARG(IHNetBridgeSettings, &spIHNetBridgeSettings) );
if (SUCCEEDED(hr)) { //
// Get the IEnumHNetBridges
//
CComPtr<IEnumHNetBridges> spehBridges;
if ((hr = spIHNetBridgeSettings->EnumBridges(&spehBridges)) == S_OK) { //
// Get the first IHNetBridge
//
CComPtr<IHNetBridge> spIHNetBridge;
if ((hr = spehBridges->Next(1, &spIHNetBridge, NULL)) == S_OK) { { //
// We currently should have only one bridge;
// this may change in the future. The
// code here is just to catch future instances
// where this function would have to change in case
// there is more than one bridge.
//
CComPtr<IHNetBridge> spIHNetBridge2;
if ((hr = spehBridges->Next(1, &spIHNetBridge2, NULL)) == S_OK) { assert(FALSE); } }
//
// Get the IEnumHNetBridgedConnections
//
CComPtr<IEnumHNetBridgedConnections> spehBrdgConns;
if ((hr = spIHNetBridge->EnumMembers(&spehBrdgConns)) == S_OK) { //
// spit out header for displaying the list
//
PrintMessageFromModule( g_hModule, MSG_BRIDGE_ADAPTER_INFO_HDR ); //
// enumerate all the IHNetBridgedConnections
//
DWORD id = 0; IHNetBridgedConnection* pIHNetBConn;
spehBrdgConns->Reset(); while (S_OK == spehBrdgConns->Next(1, &pIHNetBConn, NULL)) { id++;
//
// check if we are looking for a specific id
//
if (FALSE == bShowAll && id != adapterId) { //
// release the IHNetBridgedConnection
//
ReleaseObj(pIHNetBConn); continue; } //
// Get the pointer to IID_IHNetConnection interface of this
// bridged connection
//
CComPtr<IHNetConnection> spIHNConn;
hr = pIHNetBConn->QueryInterface( IID_PPV_ARG(IHNetConnection, &spIHNConn) ); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { ShowBridgeAdapterInfo( id, spIHNConn ); }
//
// release the IHNetBridgedConnection
//
ReleaseObj(pIHNetBConn);
//
// if we reached here and we were looking for a
// specific id, our work is done - break out
//
if (FALSE == bShowAll) { break; } }
//
// spit out footer for displaying the list
//
PrintMessageFromModule( g_hModule, TABLE_SEPARATOR ); } } } }
//
// we are done completely
//
hr = HrUninitializeHomenetConfig( g_fInitCom, pIHNetCfgMgr ); }
return (hr==S_OK) ? NO_ERROR : hr;
}
DWORDWINAPIHandleBridgeShowAdapter( IN LPCWSTR pwszMachine, IN OUT LPWSTR *ppwcArguments, IN DWORD dwCurrentIndex, IN DWORD dwArgCount, IN DWORD dwFlags, IN LPCVOID pvData, OUT BOOL *pbDone )/*++
Routine Description:
Gets options for showing bridge adapter info
Arguements:
ppwcArguments - Argument array dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
Return Value:
NO_ERROR --*/{ IHNetCfgMgr* pIHNetCfgMgr = NULL; HRESULT hr = S_OK; BOOL bShowAll = FALSE; DWORD id = 0, i, dwRet = NO_ERROR, dwNumOpt, dwNumArg, dwSize, dwRes; PDWORD pdwTagType = NULL;
TAG_TYPE pttTags[] = { {TOKEN_OPT_ID, NS_REQ_ZERO, FALSE} };
if (dwCurrentIndex > dwArgCount) { //
// No arguments specified
//
return ERROR_INVALID_SYNTAX; }
if (dwCurrentIndex == dwArgCount) { bShowAll = TRUE; }
dwNumArg = dwArgCount - dwCurrentIndex;
pdwTagType = (DWORD *) HeapAlloc( GetProcessHeap(), 0, dwNumArg * sizeof(DWORD) );
if (dwNumArg && NULL == pdwTagType) { return ERROR_NOT_ENOUGH_MEMORY; }
dwRet = PreprocessCommand( g_hModule, ppwcArguments, dwCurrentIndex, dwArgCount, pttTags, ARRAYSIZE(pttTags), 0, // min args
1, // max args
pdwTagType );
if (NO_ERROR == dwRet) { //
// process each argument...
//
for (i = 0; i < (dwArgCount - dwCurrentIndex); i++) { //
// Check its corresponding value in the pdwTagType array.
//
switch (pdwTagType[i]) { case 0: //
// refers to the 'id' field
//
id = _tcstoul(ppwcArguments[dwCurrentIndex + i], NULL, 10); break; default: //
// Since there is only one valid value, means the arg
// wasn't recognized. Shouldn't reach this point because
// PreprocessCommand wouldn't have returned NO_ERROR if
// this was the case.
//
dwRet = ERROR_INVALID_SYNTAX; break; } }
dwRet = ShowBridgeAllAdapterInfo( bShowAll, id ) ; } else { dwRet = ERROR_SHOW_USAGE; }
//
// cleanup
//
if (pdwTagType) { HeapFree(GetProcessHeap(), 0, pdwTagType); }
return dwRet;}
DWORDWINAPIHandleBridgeInstall( IN LPCWSTR pwszMachine, IN OUT LPWSTR *ppwcArguments, IN DWORD dwCurrentIndex, IN DWORD dwArgCount, IN DWORD dwFlags, IN LPCVOID pvData, OUT BOOL *pbDone ){
PrintMessageFromModule( g_hModule, HLP_BRIDGE_USE_GUI, CMD_INSTALL );
return NO_ERROR;}
DWORDWINAPIHandleBridgeUninstall( IN LPCWSTR pwszMachine, IN OUT LPWSTR *ppwcArguments, IN DWORD dwCurrentIndex, IN DWORD dwArgCount, IN DWORD dwFlags, IN LPCVOID pvData, OUT BOOL *pbDone ){ PrintMessageFromModule( g_hModule, HLP_BRIDGE_USE_GUI, CMD_UNINSTALL );
return NO_ERROR;}
|
