able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/config/netcfg/atlkcfg/atlkobj.cpp

2431 lines
64 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// ATlkObj.cpp : Implementation of CATlkObj
#include "pch.h"
#pragma hdrstop
#include <atalkwsh.h>
#include "atlkobj.h"
#include "ncatlui.h"
#include "ncmisc.h"
#include "ncreg.h"
#include "ncpnp.h"
#include "ncsvc.h"
#include <netconp.h>
extern const WCHAR c_szAdapterSections[];
//extern const WCHAR c_szAdapters[];
extern const WCHAR c_szBackslash[];
extern const WCHAR c_szDevice[];
extern const WCHAR c_szSpecificTo[];
extern const WCHAR c_szInfId_MS_NdisWanAtalk[];
extern const WCHAR c_szEmpty[];
// Registry Paths
static const WCHAR c_szAtlk[] = L"AppleTalk";
static const WCHAR c_szATLKParameters[] = L"System\\CurrentControlSet\\Services\\AppleTalk\\Parameters";
static const WCHAR c_szATLKAdapters[] = L"System\\CurrentControlSet\\Services\\AppleTalk\\Parameters\\Adapters";
// Values under the Adapter component's "Parameters" key
static const WCHAR c_szMediaType[] = L"MediaType"; //$ REVIEW duplicate string
// Values under AppleTalk\Parameters
static const WCHAR c_szDefaultPort[] = L"DefaultPort"; // REG_SZ
static const WCHAR c_szDesiredZone[] = L"DesiredZone"; // REG_SZ
static const WCHAR c_szEnableRouter[] = L"EnableRouter"; // REG_DWORD
// Values under AppleTalk\Parameters\Adapters\<AdapterId>
static const WCHAR c_szAarpRetries[] = L"AarpRetries"; // REG_DWORD
static const WCHAR c_szDdpCheckSums[] = L"DdpCheckSums"; // REG_DWORD
static const WCHAR c_szDefaultZone[] = L"DefaultZone"; // REG_SZ
static const WCHAR c_szNetworkRangeLowerEnd[] = L"NetworkRangeLowerEnd";// REG_DWORD
static const WCHAR c_szNetworkRangeUpperEnd[] = L"NetworkRangeUpperEnd";// REG_DWORD
static const WCHAR c_szPortName[] = L"PortName"; // REG_SZ
static const WCHAR c_szRouterPramNode[] = L"RouterPramNode"; // REG_DWORD
static const WCHAR c_szSeedingNetwork[] = L"SeedingNetwork"; // REG_DWORD
static const WCHAR c_szUserPramNode1[] = L"UserPramNode1"; // REG_DWORD
static const WCHAR c_szUserPramNode2[] = L"UserPramNode2"; // REG_DWORD
static const WCHAR c_szZoneList[] = L"ZoneList"; // REG_MULTI_SZ
// Useful default constant
const WCHAR c_chAt = L'@';
static const WCHAR c_dwZero = 0L;
static const WCHAR c_dwTen = 10L;
//static const WCHAR c_szMacPrint[] = L"MacPrint";
// Declare structure for reading/writing AppleTalk\Parameters values
static const REGBATCH regbatchATLKParams[] = {
{HKEY_LOCAL_MACHINE, c_szATLKParameters, c_szDefaultPort, REG_SZ,
offsetof(ATLK_PARAMS,szDefaultPort), (BYTE *)&c_szEmpty},
{HKEY_LOCAL_MACHINE, c_szATLKParameters, c_szDesiredZone, REG_SZ,
offsetof(ATLK_PARAMS,szDesiredZone), (BYTE *)&c_szEmpty},
{HKEY_LOCAL_MACHINE, c_szATLKParameters, c_szEnableRouter, REG_DWORD,
offsetof(ATLK_PARAMS,dwEnableRouter), (BYTE *)&c_szEmpty}};
static const REGBATCH regbatchATLKAdapters[] = {
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szAarpRetries, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwAarpRetries), (BYTE *)&c_dwTen},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szDdpCheckSums, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwDdpCheckSums), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szNetworkRangeLowerEnd, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwNetworkRangeLowerEnd), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szNetworkRangeUpperEnd, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwNetworkRangeUpperEnd), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szRouterPramNode, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwRouterPramNode), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szSeedingNetwork, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwSeedingNetwork), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szUserPramNode1, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwUserPramNode1), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szUserPramNode2, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwUserPramNode2), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szMediaType, REG_DWORD,
offsetof(ATLK_ADAPTER,m_dwMediaType), (BYTE *)&c_dwZero},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szDefaultZone, REG_SZ,
offsetof(ATLK_ADAPTER,m_szDefaultZone), (BYTE *)&c_szEmpty},
{HKEY_LOCAL_MACHINE, c_szEmpty, c_szPortName, REG_SZ,
offsetof(ATLK_ADAPTER,m_szPortName), (BYTE *)&c_szEmpty}};
// Local utility functions
HRESULT HrQueryAdapterComponentInfo(INetCfgComponent *pncc,
CAdapterInfo * pAI);
HRESULT HrPortNameFromAdapter(INetCfgComponent *pncc, tstring * pstr);
// Prototype from nwlnkcfg\nwlnkutl.h
HRESULT HrAnswerFileAdapterToPNCC(INetCfg *pnc, PCWSTR pszAdapterId,
INetCfgComponent** ppncc);
//
// Function: CATlkObj::CATlkObj
//
// Purpose: ctor for the CATlkObj class
//
// Parameters: none
//
// Returns: none
//
CATlkObj::CATlkObj() : m_pNetCfg(NULL),
m_pNCC(NULL),
m_eInstallAction(eActUnknown),
m_pspObj(NULL),
m_pATLKEnv(NULL),
m_pATLKEnv_PP(NULL),
m_pUnkPropContext(NULL),
m_nIdxAdapterSelected(CB_ERR),
m_fAdapterListChanged(FALSE),
m_fPropertyChange(FALSE),
m_fFirstTimeInstall(FALSE)
{
}
//
// Function: CATlkObj::CATlkObj
//
// Purpose: dtor for the CATlkObj class
//
// Parameters: none
//
// Returns: none
//
CATlkObj::~CATlkObj()
{
// Should always be cleaned up in advance of reach this dtor
Assert(NULL == m_pATLKEnv_PP);
ReleaseObj(m_pUnkPropContext);
ReleaseObj(m_pNetCfg);
ReleaseObj(m_pNCC);
CleanupPropPages();
delete m_pATLKEnv;
}
// INetCfgNotify
STDMETHODIMP CATlkObj::Initialize ( INetCfgComponent* pnccItem,
INetCfg* pNetCfg, BOOL fInstalling )
{
Validate_INetCfgNotify_Initialize(pnccItem, pNetCfg, fInstalling);
ReleaseObj(m_pNCC);
m_pNCC = pnccItem;
AddRefObj(m_pNCC);
ReleaseObj(m_pNetCfg);
m_pNetCfg = pNetCfg;
AddRefObj(m_pNetCfg);
m_fFirstTimeInstall = fInstalling;
// Read the current configuration
HRESULT hr = CATLKEnv::HrCreate(&m_pATLKEnv, this);
TraceError("CATlkObj::Initialize",hr);
return hr;
}
STDMETHODIMP CATlkObj::ReadAnswerFile(PCWSTR pszAnswerFile,
PCWSTR pszAnswerSection )
{
Validate_INetCfgNotify_ReadAnswerFile(pszAnswerFile, pszAnswerSection );
HRESULT hr = S_OK;
m_eInstallAction = eActInstall;
// Only process answer file and install sub-components if the answer file
// is present. If the answer file is not present we should already be installed.
if (NULL != pszAnswerFile)
{
hr = HrProcessAnswerFile(pszAnswerFile, pszAnswerSection);
}
TraceError("CATlkObj::ReadAnswerFile",hr);
return hr;
}
//
// Function: CATlkObj::HrProcessAnswerFile
//
// Purpose: Process the answer file information, merging
// its contents into the internal information
//
// Parameters:
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATlkObj::HrProcessAnswerFile(PCWSTR pszAnswerFile,
PCWSTR pszAnswerSection)
{
TraceFileFunc(ttidDefault);
CSetupInfFile csif;
BOOL fValue;
HRESULT hr = S_OK;
INFCONTEXT infctx;
tstring str;
AssertSz(pszAnswerFile, "Answer file string is NULL!");
AssertSz(pszAnswerSection, "Answer file sections string is NULL!");
// Open the answer file.
hr = csif.HrOpen(pszAnswerFile, NULL, INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL);
if (FAILED(hr))
{
goto Error;
}
// Read the property containing the list of adapter sections
hr = ::HrSetupFindFirstLine(csif.Hinf(), pszAnswerSection,
c_szAdapterSections, &infctx);
if (S_OK == hr)
{
DWORD dwIdx;
DWORD dwCnt = SetupGetFieldCount(&infctx);
// For each adapter in the list read the adapter information
for (dwIdx=1; dwIdx <= dwCnt; dwIdx++)
{
hr = ::HrSetupGetStringField(infctx, dwIdx, &str);
if (FAILED(hr))
{
TraceError("CATlkObj::HrProcessAnswerFile - Failed to read adapter section name",hr);
break;
}
hr = HrReadAdapterAnswerFileSection(&csif, str.c_str());
if (FAILED(hr))
{
goto Error;
}
}
}
TraceTag(ttidDefault, "***Appletalk processing default port***");
// Read the default port property (REG_SZ)
hr = csif.HrGetString(pszAnswerSection, c_szDefaultPort, &str);
if (SUCCEEDED(hr))
{
tstring strNew = str;
// If the \device\ prefix is present, strip it off
//
if (0 == _wcsnicmp(str.c_str(), c_szDevice, wcslen(c_szDevice)))
{
strNew = ((PWSTR)str.c_str()) + wcslen(c_szDevice);
TraceTag(ttidDefault, "Removing the device prefix. Device=%S",strNew.c_str());
}
// Convert the Adapter0x to \Device\{bind-name}
INetCfgComponent* pncc = NULL;
hr = ::HrAnswerFileAdapterToPNCC(PNetCfg(), strNew.c_str(), &pncc);
if (S_OK == hr)
{
PWSTR pszBindName;
hr = pncc->GetBindName(&pszBindName);
ReleaseObj(pncc);
if (FAILED(hr))
{
goto Error;
}
str = c_szDevice;
str += pszBindName;
CoTaskMemFree(pszBindName);
TraceTag(ttidDefault, "Port located and configured");
m_pATLKEnv->SetDefaultPort(str.c_str());
}
}
TraceTag(ttidDefault, "***Appletalk finished processing default port***");
// Read the default zone property (REG_SZ)
hr = csif.HrGetString(pszAnswerSection, c_szDesiredZone, &str);
if (SUCCEEDED(hr))
{
m_pATLKEnv->SetDesiredZone(str.c_str());
}
// Read the EnableRouter property (DWORD used as a boolean)
hr = csif.HrGetStringAsBool(pszAnswerSection, c_szEnableRouter, &fValue);
if (SUCCEEDED(hr))
{
m_pATLKEnv->EnableRouting(fValue);
}
// Determine the best default port overriding the recorded default only
// if the default port cannot be found
m_pATLKEnv->InitDefaultPort();
hr = S_OK;
m_fPropertyChange = TRUE;
Error:
TraceError("CATlkObj::HrProcessAnswerFile", hr);
return hr;
}
//
// Function: CATlkObj::HrReadAdapterAnswerFileSection
//
// Purpose: Read the adapter answer file section and create
// the adapter info section if successful
//
// Parameters:
//
// Returns:
//
HRESULT
CATlkObj::HrReadAdapterAnswerFileSection(CSetupInfFile * pcsif,
PCWSTR pszSection)
{
HRESULT hr = S_OK;
CAdapterInfo * pAI = NULL;
tstring str;
INetCfgComponent* pncc = NULL;
// Read the SpecificTo adapter name
hr = pcsif->HrGetString(pszSection, c_szSpecificTo, &str);
if (FAILED(hr))
{
goto Error;
}
// Search for the specified adapter in the set of existing adapters
hr = ::HrAnswerFileAdapterToPNCC(PNetCfg(), str.c_str(), &pncc);
if (FAILED(hr))
{
goto Error;
}
// if we found the adapter component object (pncc != NULL) process
// the adapter section
if (pncc)
{
DWORD dwData;
DWORD dwDataUpper;
INFCONTEXT infctx;
pAI = new CAdapterInfo();
Assert(NULL != pAI);
pAI->SetDirty(TRUE);
// Get the adapter component info (media type, description, ...)
hr = ::HrQueryAdapterComponentInfo(pncc, pAI);
if (FAILED(hr))
{
goto Error;
}
// Read the NetworkRangeUpperEnd
hr = pcsif->HrGetDword(pszSection, c_szNetworkRangeUpperEnd, &dwDataUpper);
if (FAILED(hr))
{
dwDataUpper = pAI->DwQueryNetRangeUpper();
TraceTag(ttidDefault, "CATlkObj::HrReadAdapterAnswerFileSection - Defaulting property %S",c_szNetworkRangeUpperEnd);
}
// Read the NetworkRangeLowerEnd
hr = pcsif->HrGetDword(pszSection, c_szNetworkRangeLowerEnd, &dwData);
if (FAILED(hr))
{
dwData = pAI->DwQueryNetRangeLower();
TraceTag(ttidDefault, "CATlkObj::HrReadAdapterAnswerFileSection - Defaulting property %S",c_szNetworkRangeLowerEnd);
}
pAI->SetAdapterNetRange(dwData, dwDataUpper);
// Read the DefaultZone
hr = pcsif->HrGetString(pszSection, c_szDefaultZone, &str);
if (SUCCEEDED(hr))
{
pAI->SetDefaultZone(str.c_str());
}
// Read the SeedingNetwork
hr = pcsif->HrGetDword(pszSection, c_szNetworkRangeLowerEnd, &dwData);
if (SUCCEEDED(hr))
{
pAI->SetSeedingNetwork(!!dwData);
}
// Generate the PortName
hr = ::HrPortNameFromAdapter(pncc, &str);
if (FAILED(hr))
{
goto Error;
}
pAI->SetPortName(str.c_str());
// Read the ZoneList
hr = HrSetupFindFirstLine(pcsif->Hinf(), pszSection, c_szZoneList,
&infctx);
if (S_OK == hr)
{
DWORD dwIdx;
DWORD dwCnt = SetupGetFieldCount(&infctx);
// For each adapter in the list read the adapter information
for (dwIdx=1; dwIdx <= dwCnt; dwIdx++)
{
hr = ::HrSetupGetStringField(infctx, dwIdx, &str);
if (FAILED(hr))
{
TraceError("CATlkObj::HrProcessAnswerFile - Failed to read adapter section name",hr);
goto Error;
}
if (!str.empty())
{
pAI->LstpstrZoneList().push_back(new tstring(str));
}
}
}
pAI->SetDirty(TRUE);
m_pATLKEnv->AdapterInfoList().push_back(pAI);
MarkAdapterListChanged();
}
// Normalize any errors
hr = S_OK;
Done:
ReleaseObj(pncc);
return hr;
Error:
delete pAI;
TraceError("CATlkObj::HrReadAdapterAnswerFileSection",hr);
goto Done;
}
STDMETHODIMP CATlkObj::Install (DWORD)
{
CAdapterInfo * pAI;
ATLK_ADAPTER_INFO_LIST::iterator iter;
m_eInstallAction = eActInstall;
// Mark all the initially detected adapters as dirty
for (iter = m_pATLKEnv->AdapterInfoList().begin();
iter != m_pATLKEnv->AdapterInfoList().end();
iter++)
{
pAI = *iter;
pAI->SetDirty(TRUE);
}
return S_OK;
}
STDMETHODIMP CATlkObj::Removing ()
{
m_eInstallAction = eActRemove;
return S_OK;
}
STDMETHODIMP CATlkObj::Validate ()
{
return S_OK;
}
STDMETHODIMP CATlkObj::CancelChanges ()
{
return S_OK;
}
STDMETHODIMP CATlkObj::ApplyRegistryChanges ()
{
HRESULT hr = S_OK;
// Have any changes been validated?
switch(m_eInstallAction)
{
case eActInstall:
hr = HrCommitInstall();
if (SUCCEEDED(hr))
{
m_fFirstTimeInstall = FALSE;
hr = HrAtlkReconfig();
}
break;
case eActRemove:
hr = HrCommitRemove();
break;
default: // eActUnknown
if (m_fAdapterListChanged || m_fPropertyChange)
{
// Update the registry if the adapter list changed
Assert(NULL != m_pATLKEnv);
hr = m_pATLKEnv->HrUpdateRegistry();
if (SUCCEEDED(hr))
{
hr = HrAtlkReconfig();
}
}
break;
}
TraceError("CATlkObj::ApplyRegistryChanges",hr);
return hr;
}
// INetCfgProperties
STDMETHODIMP CATlkObj::SetContext(IUnknown * pUnk)
{
ReleaseObj(m_pUnkPropContext);
m_pUnkPropContext = pUnk;
if (m_pUnkPropContext)
{
AddRefObj(m_pUnkPropContext);
}
return S_OK;
}
STDMETHODIMP CATlkObj::MergePropPages (
IN OUT DWORD* pdwDefPages,
OUT LPBYTE* pahpspPrivate,
OUT UINT* pcPages,
IN HWND hwndParent,
OUT PCWSTR* pszStartPage)
{
Validate_INetCfgProperties_MergePropPages (
pdwDefPages, pahpspPrivate, pcPages, hwndParent, pszStartPage);
HRESULT hr = S_OK;
HPROPSHEETPAGE *ahpsp = NULL;
CAdapterInfo * pAI = NULL;
Assert(pahpspPrivate);
Assert(NULL == *pahpspPrivate); // Out param init done via Validate above
*pcPages = 0;
Assert(NULL != m_pATLKEnv);
if (NULL != m_pATLKEnv_PP)
{
TraceError("CATlkObj::MergePropPages - multiple property page instances requested.", hr);
return E_UNEXPECTED;
}
// AppleTalk requires "complete" installation before property changes are
// allowed. If we've just installed but Apply has not yet been pressed,
// disallow property page display
if (m_fFirstTimeInstall)
{
NcMsgBox(::GetFocus(), IDS_ATLK_CAPTION, IDS_ATLK_INSTALL_PENDING,
MB_OK | MB_ICONEXCLAMATION);
return S_FALSE;
}
// Start with new property pages each time.
CleanupPropPages();
// Locate the adapter referenced in the connection we stashed away
if (NULL != m_pUnkPropContext)
{
INetLanConnectionUiInfo * pLanConn = NULL;
ATLK_ADAPTER_INFO_LIST::iterator iter;
hr = m_pUnkPropContext->QueryInterface(IID_INetLanConnectionUiInfo,
reinterpret_cast<LPVOID *>(&pLanConn));
if (S_OK == hr)
{
GUID guid;
hr = pLanConn->GetDeviceGuid(&guid);
ReleaseObj(pLanConn);
if (SUCCEEDED(hr))
{
// Find the adapter in our adapter list
for (iter = m_pATLKEnv->AdapterInfoList().begin();
iter != m_pATLKEnv->AdapterInfoList().end();
iter++)
{
CAdapterInfo * pAITmp = *iter;
if (guid == *pAITmp->PInstanceGuid())
{
// Copy the adapter data
hr = pAITmp->HrCopy(&pAI);
break;
}
}
}
}
if (SUCCEEDED(hr))
{
// If no adapter in this connection or it's
// disabled/hidden/deleted we show no pages
if ((NULL == pAI) || pAI->FDeletePending() ||
pAI->FDisabled() || pAI->FHidden())
{
Assert(0 == *pcPages);
hr = S_FALSE;
goto cleanup;
}
}
}
else
{
// m_pUnkPropContext should have been set first
hr = E_UNEXPECTED;
}
if (FAILED(hr))
{
goto Error;
}
// Create a copy of the enviroment for property page usage
hr = m_pATLKEnv->HrCopy(&m_pATLKEnv_PP);
if (FAILED(hr))
{
goto Error;
}
Assert(NULL != m_pATLKEnv_PP);
Assert(NULL != pAI);
// Query the zonelist every time, only for non-Seeding adapters.
if (!pAI->FSeedingNetwork() || !m_pATLKEnv_PP->FRoutingEnabled())
{
(void) m_pATLKEnv->HrGetAppleTalkInfoFromNetwork(pAI);
}
// Add the adapter to the property sheet's list
m_pATLKEnv_PP->AdapterInfoList().push_back(pAI);
// Allocate the CPropSheetPage object for the "General" page
m_pspObj = new CATLKGeneralDlg(this, m_pATLKEnv_PP);
// Allocate a buffer large enough to hold the handle to the Appletalk config.
// property page.
ahpsp = (HPROPSHEETPAGE *)CoTaskMemAlloc(sizeof(HPROPSHEETPAGE));
if (!ahpsp)
{
hr = E_OUTOFMEMORY;
goto cleanup; // Alloc failed to no need to free ahpsp
}
// Create the actual PROPSHEETPAGE for each object.
ahpsp[0] = m_pspObj->CreatePage(DLG_ATLK_GENERAL, 0);
// Validate what we've created
if (NULL == ahpsp[0])
{
hr = E_OUTOFMEMORY;
goto Error;
}
else
{
*pahpspPrivate = (LPBYTE)ahpsp;
*pcPages = 1;
}
cleanup:
TraceError("CATlkObj::MergePropPages", hr);
return hr;
Error:
CoTaskMemFree(ahpsp);
delete m_pATLKEnv_PP;
m_pATLKEnv_PP = NULL;
goto cleanup;
}
//
// Function: CATlkObj::CleanupPropPages
//
// Purpose:
//
// Parameters:
//
// Returns: nothing
//
VOID CATlkObj::CleanupPropPages()
{
delete m_pspObj;
m_pspObj = NULL;
}
//
// Function: CATlkObj::ValidateProperties
//
// Purpose:
//
// Parameters:
//
// Returns: HRESULT, S_OK on success
//
STDMETHODIMP CATlkObj::ValidateProperties (HWND)
{
return S_OK;
}
//
// Function: CATlkObj::CancelProperties
//
// Purpose:
//
// Parameters:
//
// Returns: HRESULT, S_OK on success
//
STDMETHODIMP CATlkObj::CancelProperties ()
{
// Discard any changes made via the property pages
delete m_pATLKEnv_PP;
m_pATLKEnv_PP = NULL;
return S_OK;
}
//
// Function: CATlkObj::ApplyProperties
//
// Purpose:
//
// Parameters:
//
// Returns: HRESULT, S_OK on success
//
STDMETHODIMP CATlkObj::ApplyProperties ()
{
// Extract the adapter info from the property sheet's
// enviroment block
Assert(!m_pATLKEnv_PP->AdapterInfoList().empty());
CAdapterInfo * pAICurrent = m_pATLKEnv_PP->AdapterInfoList().front();
m_pATLKEnv_PP->AdapterInfoList().pop_front();
Assert(NULL != pAICurrent);
// Remove the current adapter from the original enviroment
CAdapterInfo * pAI;
ATLK_ADAPTER_INFO_LIST::iterator iter;
for (iter = m_pATLKEnv->AdapterInfoList().begin();
iter != m_pATLKEnv->AdapterInfoList().end();
iter++)
{
pAI = *iter;
if (0 == _wcsicmp(pAI->SzBindName(), pAICurrent->SzBindName()))
{
m_pATLKEnv->AdapterInfoList().erase(iter, iter);
break;
}
}
// Add pAICurrent to the base enviroment block
m_pATLKEnv->AdapterInfoList().push_back(pAICurrent);
// Update the base enviroment from the property sheet's enviroment
m_pATLKEnv->SetDefaultMediaType(m_pATLKEnv_PP->DwDefaultAdaptersMediaType());
m_pATLKEnv->EnableRouting(m_pATLKEnv_PP->FRoutingEnabled());
m_pATLKEnv->SetDefaultPort(m_pATLKEnv_PP->SzDefaultPort());
m_pATLKEnv->SetDesiredZone(m_pATLKEnv_PP->SzDesiredZone());
m_pATLKEnv->SetRouterChanged(m_pATLKEnv_PP->FRouterChanged());
m_pATLKEnv->SetDefAdapterChanged(m_pATLKEnv_PP->FDefAdapterChanged());
// Delete the property pages enviroment block
delete m_pATLKEnv_PP;
m_pATLKEnv_PP = NULL;
// Properties changed
m_fPropertyChange = TRUE;
return S_OK;
}
// INetCfgBindNotify
STDMETHODIMP
CATlkObj::QueryBindingPath (
DWORD dwChangeFlag,
INetCfgBindingPath* pncbpItem )
{
Validate_INetCfgBindNotify_QueryBindingPath( dwChangeFlag, pncbpItem );
return S_OK;
}
STDMETHODIMP
CATlkObj::NotifyBindingPath (
DWORD dwChangeFlag,
INetCfgBindingPath* pncbpItem )
{
HRESULT hr = S_OK;
INetCfgComponent *pnccFound = NULL;
Validate_INetCfgBindNotify_NotifyBindingPath( dwChangeFlag, pncbpItem );
Assert(NULL != m_pATLKEnv);
// Only Interested in lower binding Add's and Remove's
if (dwChangeFlag & (NCN_ADD | NCN_REMOVE | NCN_ENABLE | NCN_DISABLE))
{
CIterNetCfgBindingInterface ncbiIter(pncbpItem);
INetCfgBindingInterface *pncbi;
// Enumerate the binding interfaces looking for the last Adapter
while (SUCCEEDED(hr) &&
(S_OK == (hr = ncbiIter.HrNext (&pncbi))))
{
INetCfgComponent *pncc;
hr = pncbi->GetLowerComponent(&pncc);
if (S_OK == hr)
{
GUID guidClass;
hr = pncc->GetClassGuid(&guidClass);
if ((S_OK == hr) && (GUID_DEVCLASS_NET == guidClass))
{
ULONG ulStatus = 0;
hr = pncc->GetDeviceStatus(&ulStatus);
if(S_OK == hr)
{
ReleaseObj(pnccFound);
pnccFound = pncc; // Transfer Ownership
pncc = NULL;
}
else
{
ReleaseObj(pncc);
}
}
else
{
ReleaseObj(pncc);
}
}
ReleaseObj(pncbi);
}
if (FAILED(hr))
{
goto Error;
}
// Did we find the Adapter?
if (pnccFound)
{
BOOL fFound = FALSE;
PWSTR pszBindName = NULL;
CAdapterInfo * pAI;
ATLK_ADAPTER_INFO_LIST::iterator iterAdapterInfo;
Assert(NULL != m_pATLKEnv);
ATLK_ADAPTER_INFO_LIST pAI_List = m_pATLKEnv->AdapterInfoList();
hr = pnccFound->GetBindName(&pszBindName);
if (S_OK != hr)
{
goto Error;
}
// Search the adapter list
for (iterAdapterInfo = pAI_List.begin();
iterAdapterInfo != pAI_List.end();
iterAdapterInfo++)
{
pAI = *iterAdapterInfo;
if (0 == lstrcmpiW(pszBindName, pAI->SzBindName()))
{
fFound = TRUE;
break;
}
}
Assert(NULL != pszBindName);
CoTaskMemFree(pszBindName);
// Apply the appropriate delta to the adapter list
if (fFound && (dwChangeFlag & NCN_REMOVE))
{
// Delete the adapter from the list
pAI->SetDeletePending(TRUE);
m_fAdapterListChanged = TRUE;
}
else if (!fFound && (dwChangeFlag & NCN_ADD))
{
// Add the adapter to the list
hr = m_pATLKEnv->HrAddAdapter(pnccFound);
m_fAdapterListChanged = TRUE;
}
else if (fFound && (dwChangeFlag & NCN_ADD))
{
// Re-enable the adapters existance
pAI->SetDeletePending(FALSE);
}
if (fFound)
{
if (dwChangeFlag & NCN_ENABLE)
{
pAI->SetDisabled(FALSE);
m_fAdapterListChanged = TRUE;
}
else if (dwChangeFlag & NCN_DISABLE)
{
pAI->SetDisabled(TRUE);
m_fAdapterListChanged = TRUE;
}
}
}
if (SUCCEEDED(hr))
{
hr = S_OK; // Normalize return value
}
}
Error:
::ReleaseObj(pnccFound);
TraceError("CATlkObj::NotifyBindingPath",hr);
return hr;
}
//
// Function: CATlkObj::HrCommitInstall
//
// Purpose: Commit Installation registry changes to the registry
//
// Parameters: None
//
// Returns: HRESULT, S_OK on success
//
//
HRESULT CATlkObj::HrCommitInstall()
{
HRESULT hr;
Assert(NULL != m_pATLKEnv);
hr = m_pATLKEnv->HrUpdateRegistry();
TraceError("CATlkObj::HrCommitInstall",hr);
return hr;
}
//
// Function: CATlkObj::HrCommitRemove
//
// Purpose: Remove from the registry settings which were created by this
// component's installation.
//
// Parameters: None
//
// Returns: HRESULT, S_OK on success
//
//
HRESULT CATlkObj::HrCommitRemove()
{
// Everything is removed via the inf file presently
return S_OK;
}
//
// Function: CATLKEnv::HrCreate
//
// Purpose: Construct the AppleTalk Enviroment tracking object
//
// Paramaters: ppATLKEnv [out] - AppleTalk Enviroment Object created
// pmsc [in] - AppleTalk notification object
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrCreate(CATLKEnv **ppATLKEnv, CATlkObj *pmsc)
{
HRESULT hr = S_OK;
CATLKEnv *pATLKEnv = NULL;
*ppATLKEnv = NULL;
// Construct the new enviroment object
pATLKEnv = new CATLKEnv(pmsc);
if (pATLKEnv == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
// Read AppleTalk Info
hr = pATLKEnv->HrReadAppleTalkInfo();
if (FAILED(hr))
{
goto Error;
}
*ppATLKEnv = pATLKEnv;
Done:
return hr;
Error:
TraceError("CATLKEnv::HrCreate",hr);
delete pATLKEnv;
goto Done;
}
//
// Function: CATLKEnv::CATLKEnv
//
// Purpose: ctor for the CATLKEnv class
//
// Parameters: none
//
// Returns: none
//
CATLKEnv::CATLKEnv(CATlkObj *pmsc) :
m_pmsc(pmsc),
m_fATrunning(FALSE),
m_dwDefaultAdaptersMediaType(MEDIATYPE_ETHERNET),
m_fRouterChanged(FALSE),
m_fDefAdapterChanged(FALSE)
{
ZeroMemory(&m_Params, sizeof(m_Params));
}
//
// Function: CATLKEnv::~CATLKEnv
//
// Purpose: dtor for the CATLKEnv class
//
// Parameters: none
//
// Returns: none
//
CATLKEnv::~CATLKEnv()
{
// Cleanup the AppleTalk\Parameters internal data structure
delete [] m_Params.szDefaultPort;
delete [] m_Params.szDesiredZone;
// Cleanup the contents of the Adapter Info List
while (!m_lstpAdapters.empty())
{
delete m_lstpAdapters.front();
m_lstpAdapters.pop_front();
}
}
//
// Function: CATLKEnv::HrCopy
//
// Purpose: Creates a copy of the current Enviroment
//
// Parameters: ppEnv [out] - If the function succeeds, ppEnv will contain a
// copy of the enviroment.
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrCopy(CATLKEnv **ppEnv)
{
HRESULT hr = S_OK;
CATLKEnv * pEnv;
// Allocate a new enviroment object
*ppEnv = NULL;
pEnv = new CATLKEnv(m_pmsc);
if (NULL != pEnv)
{
// Copy the members
pEnv->m_fATrunning = m_fATrunning;
pEnv->SetDefaultMediaType(DwDefaultAdaptersMediaType());
pEnv->EnableRouting(FRoutingEnabled());
pEnv->SetDefaultPort(SzDefaultPort());
pEnv->SetDesiredZone(SzDesiredZone());
pEnv->SetRouterChanged(FRouterChanged());
pEnv->SetDefAdapterChanged(FDefAdapterChanged());
*ppEnv = pEnv;
}
else
{
hr = E_OUTOFMEMORY;
}
TraceError("CATLKEnv::HrCopy",hr);
return S_OK;
}
//
// Function: CATLKEnv::HrReadAppleTalkInfo
//
// Purpose: Retrieve the AppleTalk registry Settings
//
// Parameters: none
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrReadAppleTalkInfo()
{
HRESULT hr;
// Read the AppleTalk\Parameters values
RegReadValues(celems(regbatchATLKParams), regbatchATLKParams,
(BYTE *)&m_Params, KEY_READ);
// Read info for each adapter listed under AppleTalk\Parameters\Adapters
hr = HrGetAdapterInfo();
TraceError("CATLKEnv::HrReadAppleTalkInfo",hr);
return hr;
}
//
// Function: CATLKEnv::HrGetOneAdaptersInfo
//
// Purpose: Retrieve the AppleTalk Adapter information for one adapter
//
// Parameters:
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrGetOneAdaptersInfo(INetCfgComponent* pncc,
CAdapterInfo **ppAI)
{
HKEY hkeyAdapterRoot = NULL;
HKEY hkeyAdapter = NULL;
HRESULT hr;
INT idx;
CAdapterInfo * pAI = NULL;
REGBATCH regbatch;
tstring strKey;
tstring strKeyPath = c_szATLKAdapters;
*ppAI = NULL;
// Construct the adapter info object
pAI = new CAdapterInfo;
if (pAI == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
// Get the adapter component info (media type, description, ...)
hr = ::HrQueryAdapterComponentInfo(pncc, pAI);
if (FAILED(hr))
{
goto Error;
}
hr = ::HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, strKeyPath.c_str(),
KEY_READ, &hkeyAdapterRoot);
if (S_OK == hr)
{
strKey = pAI->SzBindName();
// Try to open the key for this specific adapter
hr = ::HrRegOpenKeyEx(hkeyAdapterRoot, pAI->SzBindName(),
KEY_READ, &hkeyAdapter);
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
{
// We weren't able to find this in the registry, write it out
// when we can (self repair)
pAI->SetDirty(TRUE);
}
strKeyPath += c_szBackslash;
strKeyPath += strKey.c_str();
// If we located the key query the data
if (S_OK == hr)
{
hr = HrRegQueryColString(hkeyAdapter, c_szZoneList,
&pAI->LstpstrZoneList());
// Since CAdapterInfo defaults allocations, need to free
// them before RegReadValues writes over them and causes a leak.
//
delete [] pAI->m_AdapterInfo.m_szDefaultZone;
delete [] pAI->m_AdapterInfo.m_szPortName;
pAI->m_AdapterInfo.m_szDefaultZone = NULL;
pAI->m_AdapterInfo.m_szPortName = NULL;
// Read the adapter information
for (idx=0; idx<celems(regbatchATLKAdapters); idx++)
{
regbatch = regbatchATLKAdapters[idx];
regbatch.pszSubkey = strKeyPath.c_str();
RegReadValues(1, &regbatch, (BYTE *)pAI->PAdapterInfo(), KEY_READ);
}
}
}
if (FAILED(hr) && (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) != hr))
{
// Something other than a "not found" error
goto Error;
}
// Normalize return value
hr = S_OK;
// If the port name was not found then generate one
if (0 == wcslen(pAI->SzPortName()))
{
tstring str;
hr = ::HrPortNameFromAdapter(pncc, &str);
if (FAILED(hr))
{
goto Error;
}
pAI->SetPortName(str.c_str());
}
// Set the return value
*ppAI = pAI;
Done:
::RegSafeCloseKey(hkeyAdapter);
::RegSafeCloseKey(hkeyAdapterRoot);
return hr;
Error:
TraceError("CATLKEnv::HrGetOneAdaptersInfo",hr);
delete pAI;
goto Done;
}
//
// Function: CATLKEnv::HrGetAdapterInfo
//
// Purpose: Retrieve the AppleTalk Adapter information
//
// Parameters: none
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrGetAdapterInfo()
{
HRESULT hr = S_OK;
CAdapterInfo * pAI = NULL;
INetCfgComponent* pncc = NULL;
INetCfgComponent* pnccUse = NULL;
// Find each netcard, to do so, trace the bindings to their end
// If the endpoint is a netcard then add it to the list
CIterNetCfgBindingPath ncbpIter(m_pmsc->PNCComponent());
INetCfgBindingPath* pncbp;
while (SUCCEEDED(hr) &&
(S_OK == (hr = ncbpIter.HrNext (&pncbp))))
{
// Iterate the binding interfaces of this path.
CIterNetCfgBindingInterface ncbiIter(pncbp);
INetCfgBindingInterface* pncbi;
while (SUCCEEDED(hr) &&
(S_OK == (hr = ncbiIter.HrNext (&pncbi))))
{
// Retrieve the lower component
hr = pncbi->GetLowerComponent(&pncc);
if (S_OK == hr)
{
GUID guidClass;
// Is it an Adapter?
hr = pncc->GetClassGuid(&guidClass);
if ((S_OK == hr) && (guidClass == GUID_DEVCLASS_NET))
{
ULONG ulStatus = 0;
hr = pncc->GetDeviceStatus(&ulStatus);
if(SUCCEEDED(hr))
{
ReleaseObj(pnccUse);
pnccUse = pncc;
pncc = NULL;
}
else
{
// Release the lower component
ReleaseObj(pncc);
hr = S_OK;
break;
}
}
else
{
// Release the lower component
ReleaseObj(pncc);
}
}
// Release the binding interface
ReleaseObj (pncbi);
}
if (NULL != pnccUse)
{
// Query the Adapter information
hr = HrGetOneAdaptersInfo(pnccUse, &pAI);
if (SUCCEEDED(hr))
{
if (S_FALSE == pncbp->IsEnabled())
{
pAI->SetDisabled(TRUE);
}
// Add this Adapter to the list
m_lstpAdapters.push_back(pAI);
}
ReleaseObj(pnccUse);
pnccUse = NULL;
}
// Release the binding path
ReleaseObj (pncbp);
}
if (FAILED(hr))
{
goto Error;
}
// Initialize the default port, etc
InitDefaultPort();
// Normalize the HRESULT. (i.e. don't return S_FALSE)
hr = S_OK;
Error:
TraceError("CATLKEnv::HrGetAdapterInfo",hr);
return hr;
}
//
// Function: CATLKEnv::HrGetAppleTalkInfoFromNetwork
//
// Purpose: ???
//
// Parameters: none
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrGetAppleTalkInfoFromNetwork(CAdapterInfo * pAI)
{
SOCKADDR_AT address;
HRESULT hr = S_FALSE;
BOOL fWSInitialized = FALSE;
SOCKET mysocket = INVALID_SOCKET;
WSADATA wsadata;
DWORD wsaerr = 0;
tstring strPortName;
// Create the socket/bind
wsaerr = WSAStartup(0x0101, &wsadata);
if (0 != wsaerr)
{
goto Error;
}
// Winsock successfully initialized
fWSInitialized = TRUE;
mysocket = socket(AF_APPLETALK, SOCK_DGRAM, DDPPROTO_ZIP);
if (INVALID_SOCKET == mysocket)
{
goto Error;
}
address.sat_family = AF_APPLETALK;
address.sat_net = 0;
address.sat_node = 0;
address.sat_socket = 0;
wsaerr = bind(mysocket, (struct sockaddr *)&address, sizeof(address));
if (wsaerr != 0)
{
goto Error;
}
// Mark AppleTalk as running
SetATLKRunning(TRUE);
// For each known adapter, create a device name by merging the "\\device\\"
// prefix and the adapter's bind name.
strPortName = c_szDevice;
strPortName += pAI->SzBindName();
// Failures from query the zone list for a given adapter can be from
// the adapter not connected to the network, zone seeder not running, etc.
// Because we want to process all the adapters, we ignore these errors.
(void)pAI->HrGetAndSetNetworkInformation(mysocket,strPortName.c_str());
// Success, or at least not a critical failure
hr = S_OK;
Done:
if (INVALID_SOCKET != mysocket)
{
closesocket(mysocket);
}
if (fWSInitialized)
{
WSACleanup();
}
TraceError("CATLKEnv::HrGetAppleTalkInfoFromNetwork",(S_FALSE == hr ? S_OK : hr));
return hr;
Error:
wsaerr = ::WSAGetLastError();
goto Done;
}
//
// Function: CATLKEnv::HrAddAdapter
//
// Purpose: Add and adapter to the list of currently bound adapters
//
// Parameters: pnccFound - Notification object for the bound adapter to add
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrAddAdapter(INetCfgComponent * pnccFound)
{
HRESULT hr;
CAdapterInfo * pAI = NULL;
Assert(NULL != pnccFound);
// Create an AdapterInfo instance for the adapter
hr = HrGetOneAdaptersInfo(pnccFound, &pAI);
if (FAILED(hr))
{
goto Error;
}
// Add this Adapter to the list
m_lstpAdapters.push_back(pAI);
pAI->SetDirty(TRUE);
// If there is now only one adapter in the list, update the defaults
if (1 == m_lstpAdapters.size())
{
tstring str;
str = c_szDevice;
str += m_lstpAdapters.front()->SzBindName();
SetDefaultPort(str.c_str());
SetDefaultMediaType(m_lstpAdapters.front()->DwMediaType());
}
Error:
TraceError("CATLKEnv::HrAddAdapter",hr);
return hr;
}
//
// Function: CATLKEnv::SetDefaultPort
//
// Purpose: Change the default port name
//
// Parameters: psz [in] - The new default port name
//
// Returns: HRESULT, S_OK on success
//
void CATLKEnv::SetDefaultPort(PCWSTR psz)
{
Assert(psz);
delete [] m_Params.szDefaultPort;
m_Params.szDefaultPort = new WCHAR[wcslen(psz)+1];
wcscpy(m_Params.szDefaultPort, psz);
}
//
// Function: CATLKEnv::SetDesiredZone
//
// Purpose: Change the desired zone
//
// Parameters: sz [in] - The new desired zone
//
// Returns: HRESULT, S_OK on success
//
void CATLKEnv::SetDesiredZone(PCWSTR psz)
{
Assert(psz);
delete [] m_Params.szDesiredZone;
m_Params.szDesiredZone = new WCHAR[wcslen(psz)+1];
wcscpy(m_Params.szDesiredZone, psz);
}
CAdapterInfo * CATLKEnv::PAIFindDefaultPort()
{
CAdapterInfo * pAI = NULL;
ATLK_ADAPTER_INFO_LIST::iterator iter;
// Find the default port
//
for (iter = m_lstpAdapters.begin();
iter != m_lstpAdapters.end();
iter++)
{
tstring strPortName;
pAI = *iter;
// Retain adapter selection as the default port
strPortName = c_szDevice;
strPortName += pAI->SzBindName();
if (pAI->FDeletePending() || pAI->FDisabled() || pAI->FHidden() ||
pAI->IsRasAdapter())
{
continue;
}
if (0 == _wcsicmp(SzDefaultPort(), strPortName.c_str()))
{
return pAI;
}
}
return NULL;
}
//
// Function: CATLKEnv::HrUpdateRegistry
//
// Purpose: Write the AppleTalk local (internal) data back to the registry
//
// Parameters: none
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrUpdateRegistry()
{
HRESULT hr = S_OK;
CAdapterInfo * pAI = NULL;
HKEY hkeyAdapter;
DWORD dwDisposition;
ATLK_ADAPTER_INFO_LIST::iterator iter;
// If the current default port is unavailable, find an alternate
pAI = PAIFindDefaultPort();
if (NULL == pAI)
{
InitDefaultPort();
pAI = PAIFindDefaultPort();
}
// If the default adapter changed then three specific values for that
// adapter need to be reset to zero.
//
if (pAI && FDefAdapterChanged())
{
pAI->ZeroSpecialParams();
pAI->SetDirty(TRUE);
}
// Commit the registry changes
hr = ::HrRegWriteValues(celems(regbatchATLKParams), regbatchATLKParams,
(BYTE *)&m_Params, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS);
if (S_OK != hr)
{
goto Error;
}
// Create the Adapters key AppleTalk\Parameters\Adapters)
hr = HrRegCreateKeyEx(HKEY_LOCAL_MACHINE, c_szATLKAdapters,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&hkeyAdapter, &dwDisposition);
if (S_OK == hr)
{
// Enumerate the bound adapters and write the internal adapter list
for (iter = m_lstpAdapters.begin();
(iter != m_lstpAdapters.end()) && (SUCCEEDED(hr));
iter++)
{
pAI = *iter;
if (pAI->FDeletePending())
{
// Remove the AppleTalk\Adapter\{bindname} tree
hr = ::HrRegDeleteKeyTree(hkeyAdapter, pAI->SzBindName());
if (FAILED(hr) && (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) != hr))
{
goto Error;
}
}
else if (pAI->IsDirty())
{
hr = HrWriteOneAdapter(pAI);
}
}
RegCloseKey (hkeyAdapter);
}
Error:
TraceError("CATLKEnv::HrUpdateRegistry",hr);
return hr;
}
//
// Function: CATLKEnv::HrWriteOneAdapter
//
// Purpose: Write one adapter instance to the registry
//
// Parameters: pAI [in] - The adapter to presist in the registry
//
// Returns: HRESULT, S_OK on success
//
HRESULT CATLKEnv::HrWriteOneAdapter(CAdapterInfo *pAI)
{
DWORD dwDisposition;
HKEY hkeyAdapter = NULL;
HRESULT hr;
INT idx;
REGBATCH regbatch;
tstring str;
str = c_szATLKAdapters;
str += c_szBackslash;
str += pAI->SzBindName();
// Create the key described in str (AppleTalk\Parameters\Adapters\<adapter>)
hr = ::HrRegCreateKeyEx(HKEY_LOCAL_MACHINE, str.c_str(),
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&hkeyAdapter, &dwDisposition);
if (FAILED(hr))
{
goto Error;
}
// Write out the adapter parameters
for (idx = 0; idx < celems(regbatchATLKAdapters); idx++)
{
regbatch = regbatchATLKAdapters[idx];
regbatch.pszSubkey = str.c_str();
hr = ::HrRegWriteValues(1, &regbatch, (BYTE *)pAI->PAdapterInfo(),
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS);
if (FAILED(hr))
{
goto Error;
}
}
// Write out the zone list multi-sz (managed seperately)
hr = ::HrRegSetColString(hkeyAdapter, c_szZoneList, pAI->LstpstrZoneList());
Error:
::RegSafeCloseKey(hkeyAdapter);
TraceError("CATLKEnv::HrWriteOneAdapter",hr);
return S_OK;
}
//
// Function: CATLKEnv::DwMediaPriority
//
// Purpose: When determining the appropriate adapter for use as the
// "DefaultPort" certain mediatype's are faster. So all
// other things being equal, selecting a faster mediatype
// benefits the user the most.
//
// Parameters: dwMediaType [in] - MediaType used to determine priority ranking
//
// Returns: DWORD, value (1-5) with the lowest value representing the
// highest priority.
//
DWORD CATLKEnv::DwMediaPriority(DWORD dwMediaType)
{
switch(dwMediaType)
{
case MEDIATYPE_ETHERNET:
return 2;
case MEDIATYPE_TOKENRING:
return 3;
case MEDIATYPE_FDDI:
return 1;
case MEDIATYPE_LOCALTALK:
return 4;
default:
return 5;
}
}
//
// Function: CATLKEnv::InitDefaultPort
//
// Purpose: Select a default port if none yet has been selected. Retain
// some select information for assisting in dialog display issues.
//
// Parameters: none
//
// Returns: nothing
//
void CATLKEnv::InitDefaultPort()
{
CAdapterInfo * pAI = NULL;
tstring str;
ATLK_ADAPTER_INFO_LIST::iterator iter;
// If DefaultPort is set, does the associated adapter exist?
if (wcslen(SzDefaultPort()))
{
// Search for the adapter in the list
for (iter = AdapterInfoList().begin();
iter != AdapterInfoList().end();
iter++)
{
pAI = *iter;
if (pAI->FDeletePending() || pAI->FDisabled() || pAI->FHidden() ||
pAI->IsRasAdapter())
{
pAI = NULL;
continue;
}
str = c_szDevice;
str += pAI->SzBindName();
if (0 == wcscmp(str.c_str(), SzDefaultPort()))
{
break;
}
pAI = NULL;
}
}
// If DefaultPort is not set locate the best candidate
if (NULL == pAI)
{
CAdapterInfo * pAIBest = NULL;
SetDefaultPort(c_szEmpty);
// Search through the adapter list for the adapter
// with the fastest media type.
for (iter = AdapterInfoList().begin();
iter != AdapterInfoList().end();
iter++)
{
pAI = *iter;
if (pAI->FDeletePending() || pAI->FDisabled() || pAI->FHidden() ||
pAI->IsRasAdapter())
{
continue;
}
if ((NULL == pAIBest) ||
(DwMediaPriority(pAIBest->DwMediaType()) >
DwMediaPriority(pAI->DwMediaType())))
{
SetDefAdapterChanged(TRUE);
pAIBest = pAI;
}
}
pAI = pAIBest;
}
if (NULL != pAI)
{
// retain the selected adapter as the default port
str = c_szDevice;
str += pAI->SzBindName();
SetDefaultPort(str.c_str());
// retain the default media type
SetDefaultMediaType(pAI->DwMediaType());
}
else
{
SetDefaultPort(c_szEmpty);
}
}
//
// Function: CAdapterInfo::CAdapterInfo
//
// Purpose: ctor for the CAdapters class
//
// Parameters: none
//
// Returns: nothing
//
CAdapterInfo::CAdapterInfo() :
m_fDeletePending(FALSE),
m_fDisabled(FALSE),
m_fDirty(FALSE),
m_fRasAdapter(FALSE),
m_fRouterOnNetwork(FALSE),
m_fZoneListValid(FALSE),
m_dwNetworkUpper(0),
m_dwNetworkLower(0),
m_dwCharacteristics(0)
{
ZeroMemory(&m_guidInstance, sizeof(m_guidInstance));
// Initialize the AdapterInfo default values
ZeroMemory(&m_AdapterInfo, sizeof(m_AdapterInfo));
m_AdapterInfo.m_dwAarpRetries = c_dwTen;
m_AdapterInfo.m_dwMediaType = MEDIATYPE_ETHERNET;
SetDefaultZone(c_szEmpty);
SetPortName(c_szEmpty);
}
//
// Function: CAdapterInfo::~CAdapterInfo
//
// Purpose: ctor for the CAdapters class
//
// Parameters: none
//
// Returns: nothing
//
CAdapterInfo::~CAdapterInfo()
{
// Cleanup the AppleTalk\Adapters\<adapter> internal data structure
delete [] m_AdapterInfo.m_szDefaultZone;
delete [] m_AdapterInfo.m_szPortName;
DeleteColString(&m_lstpstrDesiredZoneList);
DeleteColString(&m_lstpstrZoneList);
}
//
// Function: CAdapterInfo::SetDefaultZone
//
// Purpose: Set the default zone for this adapter
//
// Parameters: sz - The new default zone
//
// Returns: nothing
//
void CAdapterInfo::SetDefaultZone(PCWSTR psz)
{
Assert(psz);
delete [] m_AdapterInfo.m_szDefaultZone;
m_AdapterInfo.m_szDefaultZone = NULL;
m_AdapterInfo.m_szDefaultZone = new WCHAR[wcslen(psz)+1];
wcscpy(m_AdapterInfo.m_szDefaultZone, psz);
}
//
// Function: CAdapterInfo::SetPortName
//
// Purpose: Set the port name for this adapter
//
// Parameters: sz - The new port name
//
// Returns: nothing
//
void CAdapterInfo::SetPortName(PCWSTR psz)
{
Assert(psz);
delete [] m_AdapterInfo.m_szPortName;
m_AdapterInfo.m_szPortName = NULL;
m_AdapterInfo.m_szPortName = new WCHAR[wcslen(psz)+1];
wcscpy(m_AdapterInfo.m_szPortName, psz);
}
//
// Function: CAdapterInfo::HrGetAndSetNetworkInformation
//
// Purpose:
//
// Parameters:
//
// Returns: HRESULT, S_OK on success
//
#define PARM_BUF_LEN 512
#define ASTERISK_CHAR "*"
HRESULT
CAdapterInfo::HrGetAndSetNetworkInformation (
SOCKET socket,
PCWSTR pszDevName)
{
HRESULT hr = FALSE;
CHAR *pZoneBuffer = NULL;
CHAR *pDefParmsBuffer = NULL;
CHAR *pZoneListStart;
INT BytesNeeded ;
WCHAR *pwDefZone = NULL;
tstring strTmpZone;
INT ZoneLen = 0;
DWORD wsaerr = 0;
CHAR *pDefZone = NULL;
PWSH_LOOKUP_ZONES pGetNetZones;
PWSH_LOOKUP_NETDEF_ON_ADAPTER pGetNetDefaults;
Assert(pszDevName);
pZoneBuffer = new CHAR [ZONEBUFFER_LEN + sizeof(WSH_LOOKUP_ZONES)];
Assert(pZoneBuffer);
if (pZoneBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
pGetNetZones = (PWSH_LOOKUP_ZONES)pZoneBuffer;
wcscpy((WCHAR *)(pGetNetZones+1), pszDevName);
BytesNeeded = ZONEBUFFER_LEN;
wsaerr = getsockopt(socket, SOL_APPLETALK, SO_LOOKUP_ZONES_ON_ADAPTER,
(char *)pZoneBuffer, &BytesNeeded);
if (0 != wsaerr)
{
//$ REVIEW - error mapping
#ifdef DBG
DWORD dwErr = WSAGetLastError();
TraceTag(ttidError, "CAdapterInfo::HrGetAndSetNetworkInformation getsocketopt returned: %08X",dwErr);
#endif
hr = E_UNEXPECTED;
goto Error;
}
pZoneListStart = pZoneBuffer + sizeof(WSH_LOOKUP_ZONES);
if (!lstrcmpA(pZoneListStart, ASTERISK_CHAR))
{
// Success, wildcard zone set.
goto Done;
}
hr = HrConvertZoneListAndAddToPortInfo(pZoneListStart,
((PWSH_LOOKUP_ZONES)pZoneBuffer)->NoZones);
if (FAILED(hr))
{
goto Error;
}
SetRouterOnNetwork(TRUE);
//
// Get the DefaultZone/NetworkRange Information
pDefParmsBuffer = new CHAR[PARM_BUF_LEN+sizeof(WSH_LOOKUP_NETDEF_ON_ADAPTER)];
Assert(pDefParmsBuffer);
if (pDefParmsBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
pGetNetDefaults = (PWSH_LOOKUP_NETDEF_ON_ADAPTER)pDefParmsBuffer;
BytesNeeded = PARM_BUF_LEN + sizeof(WSH_LOOKUP_NETDEF_ON_ADAPTER);
wcscpy((WCHAR*)(pGetNetDefaults+1), pszDevName);
pGetNetDefaults->NetworkRangeLowerEnd = pGetNetDefaults->NetworkRangeUpperEnd = 0;
wsaerr = getsockopt(socket, SOL_APPLETALK, SO_LOOKUP_NETDEF_ON_ADAPTER,
(char*)pDefParmsBuffer, &BytesNeeded);
if (0 != wsaerr)
{
#ifdef DBG
DWORD dwErr = WSAGetLastError();
#endif
hr = E_UNEXPECTED;
goto Error;
}
// Save the default information to PORT_INFO
SetExistingNetRange(pGetNetDefaults->NetworkRangeLowerEnd,
pGetNetDefaults->NetworkRangeUpperEnd);
pDefZone = pDefParmsBuffer + sizeof(WSH_LOOKUP_NETDEF_ON_ADAPTER);
ZoneLen = lstrlenA(pDefZone) + 1;
pwDefZone = new WCHAR [sizeof(WCHAR) * ZoneLen];
Assert(NULL != pwDefZone);
if (pwDefZone == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
mbstowcs(pwDefZone, pDefZone, ZoneLen);
strTmpZone = pwDefZone;
SetNetDefaultZone(strTmpZone.c_str());
if (pZoneBuffer != NULL)
{
delete [] pZoneBuffer;
}
if (pwDefZone != NULL)
{
delete [] pwDefZone;
}
if (pDefParmsBuffer != NULL)
{
delete [] pDefParmsBuffer;
}
Done:
Error:
TraceError("CAdapterInfo::HrGetAndSetNetworkInformation",hr);
return hr;
}
//
// Function: CAdapterInfo::HrConvertZoneListAndAddToPortInfo
//
// Purpose:
//
// Parameters:
//
// Returns: HRESULT, S_OK on success
//
HRESULT CAdapterInfo::HrConvertZoneListAndAddToPortInfo(CHAR * szZoneList, ULONG NumZones)
{
INT cbAscii = 0;
WCHAR *pszZone = NULL;
tstring *pstr;
Assert(NULL != szZoneList);
DeleteColString(&m_lstpstrDesiredZoneList);
while(NumZones--)
{
cbAscii = lstrlenA(szZoneList) + 1;
pszZone = new WCHAR [sizeof(WCHAR) * cbAscii];
Assert(NULL != pszZone);
if (pszZone == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
mbstowcs(pszZone, szZoneList, cbAscii);
pstr = new tstring(pszZone);
Assert(NULL != pstr);
m_lstpstrDesiredZoneList.push_back(pstr);
szZoneList += cbAscii;
delete [] pszZone;
}
return S_OK;
}
//
// Function: CAdapterInfo::HrCopy
//
// Purpose: Create a duplicate copy of 'this'
//
// Parameters: ppAI [out] - if the function succeeds, ppAI will contain the
// copy of 'this'.
//
// Returns: HRESULT, S_OK on success
//
HRESULT CAdapterInfo::HrCopy(CAdapterInfo ** ppAI)
{
CAdapterInfo *pAI;
list<tstring*>::iterator iter;
tstring * pstr;
Assert(NULL != ppAI);
// Create an adapter info structure
pAI = new CAdapterInfo;
Assert(pAI);
if (pAI == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
// Make a copy of everything
pAI->SetDisabled(FDisabled());
pAI->SetDeletePending(FDeletePending());
pAI->SetCharacteristics(GetCharacteristics());
pAI->SetMediaType(DwMediaType());
pAI->SetBindName(SzBindName());
pAI->SetDisplayName(SzDisplayName());
pAI->SetNetDefaultZone(SzNetDefaultZone());
pAI->SetRouterOnNetwork(FRouterOnNetwork());
pAI->SetExistingNetRange(DwQueryNetworkLower(), DwQueryNetworkUpper());
pAI->SetDirty(IsDirty());
pAI->SetRasAdapter(IsRasAdapter());
// Free the default data set by the constructor before overwriting it.
// (this whole thing is not a very good approach.)
//
delete [] pAI->m_AdapterInfo.m_szDefaultZone;
delete [] pAI->m_AdapterInfo.m_szPortName;
pAI->m_AdapterInfo = m_AdapterInfo;
// Cleanup the 'allocated' data cause by the bit copy
// so that SetDefaultZone and SetPortName don't try to free bogus
// stuff. (more "programming by side-affect")
//
pAI->m_AdapterInfo.m_szDefaultZone = NULL;
pAI->m_AdapterInfo.m_szPortName = NULL;
// Now copy the 'allocated' data
pAI->SetDefaultZone(SzDefaultZone());
pAI->SetPortName(SzPortName());
for (iter = LstpstrZoneList().begin();
iter != LstpstrZoneList().end();
iter++)
{
pstr = *iter;
pAI->LstpstrZoneList().push_back(new tstring(pstr->c_str()));
}
for (iter = LstpstrDesiredZoneList().begin();
iter != LstpstrDesiredZoneList().end();
iter++)
{
pstr = *iter;
pAI->LstpstrDesiredZoneList().push_back(new tstring(pstr->c_str()));
}
*ppAI = pAI;
return S_OK;
}
//
// Function: HrQueryAdapterComponentInfo
//
// Purpose: Fill out an CAdapterInfo instance with the data retrieved
// specifically from the component itself.
//
// Parameters: pncc [in] - The component object (adapter) to query
// pAI [in/out] - Where to place the queried info
//
// Returns: HRESULT, S_OK on success
//
HRESULT HrQueryAdapterComponentInfo(INetCfgComponent *pncc,
CAdapterInfo * pAI)
{
PWSTR psz = NULL;
DWORD dwCharacteristics;
HRESULT hr;
Assert(NULL != pncc);
Assert(NULL != pAI);
// Retrieve the component's name
hr = pncc->GetBindName(&psz);
if (FAILED(hr))
{
goto Error;
}
Assert(psz && *psz);
pAI->SetBindName(psz);
CoTaskMemFree(psz);
psz = NULL;
hr = pncc->GetInstanceGuid(pAI->PInstanceGuid());
if (FAILED(hr))
{
goto Error;
}
// Get the Adapter's display name
hr = pncc->GetDisplayName(&psz);
if (FAILED(hr))
{
goto Error;
}
Assert(psz);
pAI->SetDisplayName(psz);
CoTaskMemFree(psz);
psz = NULL;
// Get the Component ID so we can check if this is a RAS adapter
//
hr = pncc->GetId(&psz);
if (FAILED(hr))
{
goto Error;
}
Assert(psz && *psz);
pAI->SetRasAdapter(0 == _wcsicmp(c_szInfId_MS_NdisWanAtalk, psz));
CoTaskMemFree(psz);
psz = NULL;
// Failure is non-fatal
hr = pncc->GetCharacteristics(&dwCharacteristics);
if (SUCCEEDED(hr))
{
pAI->SetCharacteristics(dwCharacteristics);
}
// Get the media type (Optional key)
{
DWORD dwMediaType = MEDIATYPE_ETHERNET ;
INetCfgComponentBindings* pnccBindings = NULL;
hr = pncc->QueryInterface(IID_INetCfgComponentBindings,
reinterpret_cast<void**>(&pnccBindings));
if (S_OK == hr)
{
static const struct
{
PCWSTR pszInterface;
DWORD dwInterface;
DWORD dwFlags;
} InterfaceMap[] = {{L"ethernet", MEDIATYPE_ETHERNET, NCF_LOWER},
{L"tokenring", MEDIATYPE_TOKENRING, NCF_LOWER},
{L"fddi", MEDIATYPE_FDDI, NCF_LOWER},
{L"localtalk", MEDIATYPE_LOCALTALK, NCF_LOWER},
{L"wan", MEDIATYPE_WAN, NCF_LOWER}};
for (UINT nIdx=0; nIdx < celems(InterfaceMap); nIdx++)
{
hr = pnccBindings->SupportsBindingInterface(InterfaceMap[nIdx].dwFlags,
InterfaceMap[nIdx].pszInterface);
if (S_OK == hr)
{
dwMediaType = InterfaceMap[nIdx].dwInterface;
break;
}
}
::ReleaseObj(pnccBindings);
}
pAI->SetMediaType(dwMediaType);
hr = S_OK;
}
Error:
TraceError("HrQueryAdapterComponentInfo",hr);
return hr;
}
//
// Function: HrPortNameFromAdapter
//
// Purpose: Create a port name, for use as an adapters PortName
//
// Parameters: pncc [in] - The component object (adapter) to query
// pstr [in/out] - On success will contain the PortName
//
// Returns: HRESULT, S_OK on success
//
HRESULT HrPortNameFromAdapter(INetCfgComponent *pncc, tstring * pstr)
{
HRESULT hr;
PWSTR psz;
PWSTR pszBindName = NULL;
WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
DWORD dwSize = sizeof(szComputerName) / sizeof(WCHAR);
Assert(NULL != pstr);
Assert(NULL != pncc);
if (!GetComputerName(szComputerName, &dwSize))
{
hr = ::HrFromLastWin32Error();
goto Error;
}
hr = pncc->GetBindName(&pszBindName);
if (FAILED(hr))
{
goto Error;
}
// Replace the instances of '-' and '{' with '0' so the constructed
// portname is of the form [a-zA-Z0-9]*@<Computer Name> and is less
// than MAX_ZONE_NAME_LEN long.
psz = pszBindName;
while (*psz)
{
if ((*psz == L'-') || (*psz == L'{'))
{
*psz = L'0';
}
psz++;
}
*pstr = pszBindName;
if (pstr->size() + 1 + dwSize > MAX_ZONE_NAME_LEN)
{
pstr->resize(MAX_ZONE_NAME_LEN - (dwSize + 1));
}
*pstr += c_chAt;
*pstr += szComputerName;
Assert( MAX_ZONE_NAME_LEN >= pstr->size());
Error:
CoTaskMemFree(pszBindName);
TraceError("HrPortNameFromAdapter",hr);
return hr;
}
HRESULT CATlkObj::HrAtlkReconfig()
{
CServiceManager csm;
CService svr;
HRESULT hr = S_OK;
HRESULT hrRet;
BOOL fDirty = FALSE;
CAdapterInfo * pAI;
CAdapterInfo * pAIDefault = NULL;
ATLK_ADAPTER_INFO_LIST::iterator iter;
ATALK_PNP_EVENT Config;
if (m_pATLKEnv->AdapterInfoList().empty())
{
return hr;
}
ZeroMemory(&Config, sizeof(Config));
// If routing changed notify appletalk and return. No need to do the
// per adapter notifications.
if (m_pATLKEnv->FRouterChanged())
{
// notify atlk
Config.PnpMessage = AT_PNP_SWITCH_ROUTING;
hrRet = HrSendNdisPnpReconfig(NDIS, c_szAtlk, c_szEmpty,
&Config, sizeof(ATALK_PNP_EVENT));
if (FAILED(hrRet) &&
(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) != hrRet))
{
hr = NETCFG_S_REBOOT;
}
m_pATLKEnv->SetRouterChanged(FALSE);
return hr;
}
// Find the default adapter and also if any adapter's have changed
for (iter = m_pATLKEnv->AdapterInfoList().begin();
iter != m_pATLKEnv->AdapterInfoList().end();
iter++)
{
pAI = *iter;
tstring strPortName = c_szDevice;
strPortName += pAI->SzBindName();
if (pAI->FDeletePending() || pAI->FDisabled())
{
continue;
}
// Locate the default port
if (0 == _wcsicmp(strPortName.c_str(), m_pATLKEnv->SzDefaultPort()))
{
pAIDefault = pAI;
}
if (pAI->IsDirty())
{
fDirty = TRUE;
}
}
if ((NULL != pAIDefault) && m_pATLKEnv->FDefAdapterChanged())
{
// notify atlk
Config.PnpMessage = AT_PNP_SWITCH_DEFAULT_ADAPTER;
hrRet = HrSendNdisPnpReconfig(NDIS, c_szAtlk, NULL,
&Config, sizeof(ATALK_PNP_EVENT));
if (FAILED(hrRet) &&
(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) != hrRet))
{
hr = NETCFG_S_REBOOT;
}
// Clear the dirty state
m_pATLKEnv->SetDefAdapterChanged(FALSE);
pAIDefault->SetDirty(FALSE);
}
Config.PnpMessage = AT_PNP_RECONFIGURE_PARMS;
for (iter = m_pATLKEnv->AdapterInfoList().begin();
iter != m_pATLKEnv->AdapterInfoList().end();
iter++)
{
pAI = *iter;
if (pAI->FDeletePending() || pAI->FDisabled())
{
continue;
}
if (pAI->IsDirty())
{
// Now submit the reconfig notification
hrRet = HrSendNdisPnpReconfig(NDIS, c_szAtlk, pAI->SzBindName(),
&Config, sizeof(ATALK_PNP_EVENT));
if (FAILED(hrRet) &&
(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) != hrRet))
{
hr = NETCFG_S_REBOOT;
}
// Clear the dirty state
pAI->SetDirty(FALSE);
}
}
TraceError("CATLKObj::HrAtlkReconfig",hr);
return hr;
}
Reference in a new issue Copy permalink