able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/config/shell/statmon/smsa.cpp

879 lines
29 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "pch.h"
#pragma hdrstop
#include "sminc.h"
#include "smpsh.h"
#include "ncui.h"
#include "ndispnp.h"
extern const WCHAR c_szDevice[];
#include "initguid.h"
DEFINE_GUID(CLSID_SharedAccessConnectionManager, 0xBA126AE0,0x2166,0x11D1,0xB1,0xD0,0x00,0x80,0x5F,0xC1,0x27,0x0E); // REMOVE
//+---------------------------------------------------------------------------
//
// Member: CSharedAccessStatEngine::CSharedAccessStatEngine
//
// Purpose: Creator
//
// Arguments: None
//
// Returns: Nil
//
CSharedAccessStatEngine::CSharedAccessStatEngine(VOID)
{
m_ncmType = NCM_SHAREDACCESSHOST_LAN;
m_ncsmType = NCSM_NONE;
m_dwCharacter = 0;
m_pGlobalInterfaceTable = NULL;
m_dwCommonInterfaceCookie = 0;
m_dwWANConnectionCookie = 0;
m_bRequested = FALSE;
m_Status = NCS_CONNECTED;
m_ulTotalBytesSent = 0;
m_ulTotalBytesReceived = 0;
m_ulTotalPacketsSent = 0;
m_ulTotalPacketsReceived = 0;
m_ulUptime = 0;
m_ulSpeedbps = 0;
return;
}
HRESULT CSharedAccessStatEngine::FinalConstruct(VOID)
{
HRESULT hr = S_OK;
TraceError("CSharedAccessStatEngine::FinalConstruct", hr);
return hr;
}
HRESULT CSharedAccessStatEngine::FinalRelease(VOID)
{
if(0 != m_dwCommonInterfaceCookie)
{
m_pGlobalInterfaceTable->RevokeInterfaceFromGlobal(m_dwCommonInterfaceCookie);
}
if(0 != m_dwWANConnectionCookie)
{
m_pGlobalInterfaceTable->RevokeInterfaceFromGlobal(m_dwWANConnectionCookie);
}
if(NULL != m_pGlobalInterfaceTable)
{
ReleaseObj(m_pGlobalInterfaceTable);
}
return S_OK;
}
HRESULT CSharedAccessStatEngine::Initialize(NETCON_MEDIATYPE MediaType, INetSharedAccessConnection* pNetSharedAccessConnection)
{
HRESULT hr;
m_ncmType = MediaType;
m_ncsmType = NCSM_NONE;
IGlobalInterfaceTable* pGlobalInterfaceTable;
hr = HrCreateInstance(CLSID_StdGlobalInterfaceTable, CLSCTX_INPROC_SERVER, &m_pGlobalInterfaceTable);
if(SUCCEEDED(hr))
{
GUID LocalDeviceGuid;
hr = pNetSharedAccessConnection->GetLocalAdapterGUID(&LocalDeviceGuid);
if(SUCCEEDED(hr))
{
const WCHAR c_szDevicePrefix[] = L"\\DEVICE\\";
lstrcpy(m_szLocalDeviceGuidStorage, c_szDevicePrefix);
SIZE_T DeviceLength = (sizeof(c_szDevicePrefix) / sizeof(WCHAR)) - 1;
StringFromGUID2(LocalDeviceGuid, m_szLocalDeviceGuidStorage + DeviceLength, (sizeof(m_szLocalDeviceGuidStorage) / sizeof(WCHAR)) - DeviceLength);
::RtlInitUnicodeString(&m_LocalDeviceGuid, m_szLocalDeviceGuidStorage);
}
if(SUCCEEDED(hr))
{
IUPnPService* pWANCommonInterfaceConfigService;
hr = pNetSharedAccessConnection->GetService(SAHOST_SERVICE_WANCOMMONINTERFACECONFIG, &pWANCommonInterfaceConfigService);
if(SUCCEEDED(hr))
{
IUPnPService* pWANConnectionService;
hr = pNetSharedAccessConnection->GetService(NCM_SHAREDACCESSHOST_LAN == m_ncmType ? SAHOST_SERVICE_WANIPCONNECTION : SAHOST_SERVICE_WANPPPCONNECTION, &pWANConnectionService);
if(SUCCEEDED(hr))
{
hr = m_pGlobalInterfaceTable->RegisterInterfaceInGlobal(pWANCommonInterfaceConfigService, IID_IUPnPService, &m_dwCommonInterfaceCookie);
if(SUCCEEDED(hr))
{
hr = m_pGlobalInterfaceTable->RegisterInterfaceInGlobal(pWANConnectionService, IID_IUPnPService, &m_dwWANConnectionCookie);
}
pWANConnectionService->Release();
}
pWANCommonInterfaceConfigService->Release();
}
}
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CSharedAccessStatEngine::HrUpdateData
//
// Purpose: Get new statistics from the devices. This data is used to be
// displayed in the UI.
//
// Arguments: pdwChangeFlags - Where to modify the changed flags. This
// param may be NULL.
//
// Returns: Error code
//
HRESULT
CSharedAccessStatEngine::HrUpdateData (
DWORD* pdwChangeFlags,
BOOL* pfNoLongerConnected)
{
HRESULT hr = S_OK;
// Initialize the output parameter.
//
*pfNoLongerConnected = FALSE;
EnterCriticalSection(&g_csStatmonData);
// Make sure we have a statistics structure
//
if (!m_psmEngineData)
{
m_psmEngineData = new STATMON_ENGINEDATA;
if (m_psmEngineData)
{
ZeroMemory(m_psmEngineData, sizeof(STATMON_ENGINEDATA));
}
}
if (m_psmEngineData)
{
if(FALSE == m_bRequested) // protected statmondata critsec
{
InternalAddRef(); // bump the refcount so the callback will have a valid ref
m_bRequested = TRUE;
if(0 == QueueUserWorkItem(StaticUpdateStats, this, WT_EXECUTEDEFAULT))
{
InternalRelease();
m_bRequested = FALSE;
}
}
if (fIsConnectedStatus(m_Status))
{
m_psmEngineData->SMED_CONNECTIONSTATUS = NCS_CONNECTED;
// Update shared access data
UINT64 uOldPacketsTransmitting = m_psmEngineData->SMED_PACKETSTRANSMITTING;
UINT64 uOldPacketsReceiving = m_psmEngineData->SMED_PACKETSRECEIVING;
m_psmEngineData->SMED_BYTESTRANSMITTING = static_cast<UINT64>(m_ulTotalBytesSent);
m_psmEngineData->SMED_BYTESRECEIVING = static_cast<UINT64>(m_ulTotalBytesReceived);
m_psmEngineData->SMED_PACKETSTRANSMITTING = static_cast<UINT64>(m_ulTotalPacketsSent);
m_psmEngineData->SMED_PACKETSRECEIVING = static_cast<UINT64>(m_ulTotalPacketsReceived);
m_psmEngineData->SMED_DURATION = static_cast<UINT>(m_ulUptime);
m_psmEngineData->SMED_SPEEDTRANSMITTING = static_cast<UINT>(m_ulSpeedbps);
m_psmEngineData->SMED_SPEEDRECEIVING = static_cast<UINT>(m_ulSpeedbps);
// update the change flags
if (pdwChangeFlags)
{
*pdwChangeFlags = SMDCF_NULL;
if(uOldPacketsTransmitting != m_psmEngineData->SMED_PACKETSTRANSMITTING)
{
*pdwChangeFlags |= SMDCF_TRANSMITTING;
}
if(uOldPacketsReceiving != m_psmEngineData->SMED_PACKETSRECEIVING)
{
*pdwChangeFlags |= SMDCF_RECEIVING;
}
}
HrGetAutoNetSetting(m_guidId, &(m_psmEngineData->SMED_DHCP_ADDRESS_TYPE) );
m_psmEngineData->SMED_INFRASTRUCTURE_MODE = IM_NOT_SUPPORTED;
NIC_STATISTICS nsNewLanStats;
ZeroMemory(&nsNewLanStats, sizeof(nsNewLanStats));
nsNewLanStats.Size = sizeof(NIC_STATISTICS);
if(::NdisQueryStatistics(&m_LocalDeviceGuid, &nsNewLanStats))
{
m_psmEngineData->SMED_SALOCAL_BYTESTRANSMITTING = nsNewLanStats.BytesSent;
m_psmEngineData->SMED_SALOCAL_BYTESRECEIVING = nsNewLanStats.DirectedBytesReceived;
m_psmEngineData->SMED_SALOCAL_PACKETSTRANSMITTING = nsNewLanStats.PacketsSent;
m_psmEngineData->SMED_SALOCAL_PACKETSRECEIVING = nsNewLanStats.DirectedPacketsReceived;
}
}
else
{
*pfNoLongerConnected = TRUE;
m_psmEngineData->SMED_CONNECTIONSTATUS = NCS_DISCONNECTED;
}
}
else
{
hr = E_OUTOFMEMORY;
}
LeaveCriticalSection(&g_csStatmonData);
TraceError("CSharedAccessStatEngine::HrUpdateData", hr);
return hr;
}
HRESULT CSharedAccessStatEngine::UpdateStats()
{
HRESULT hr = S_OK;
IUPnPService* pWANConnection;
hr = m_pGlobalInterfaceTable->GetInterfaceFromGlobal(m_dwWANConnectionCookie, IID_IUPnPService, reinterpret_cast<void**>(&pWANConnection));
if(SUCCEEDED(hr))
{
IUPnPService* pWANCommonInterfaceConfig;
hr = m_pGlobalInterfaceTable->GetInterfaceFromGlobal(m_dwCommonInterfaceCookie, IID_IUPnPService, reinterpret_cast<void**>(&pWANCommonInterfaceConfig));
if(SUCCEEDED(hr))
{
BSTR ConnectionStatus;
hr = GetStringStateVariable(pWANConnection, L"ConnectionStatus", &ConnectionStatus);
if(SUCCEEDED(hr))
{
if(0 == lstrcmp(ConnectionStatus, L"Connected"))
{
m_Status = NCS_CONNECTED;
VARIANT OutArgs;
hr = InvokeVoidAction(pWANCommonInterfaceConfig, L"X_GetICSStatistics", &OutArgs);
if(SUCCEEDED(hr))
{
SAFEARRAY* pArray = V_ARRAY(&OutArgs);
LONG lIndex = 0;
VARIANT Param;
lIndex = 0;
hr = SafeArrayGetElement(pArray, &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalBytesSent = V_UI4(&Param);
}
VariantClear(&Param);
}
lIndex = 1;
hr = SafeArrayGetElement(pArray, &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalBytesReceived = V_UI4(&Param);
}
VariantClear(&Param);
}
lIndex = 2;
hr = SafeArrayGetElement(pArray, &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalPacketsSent = V_UI4(&Param);
}
VariantClear(&Param);
}
lIndex = 3;
hr = SafeArrayGetElement(pArray, &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalPacketsReceived = V_UI4(&Param);
}
VariantClear(&Param);
}
lIndex = 4;
hr = SafeArrayGetElement(pArray, &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulSpeedbps = V_UI4(&Param);
}
VariantClear(&Param);
}
lIndex = 5;
hr = SafeArrayGetElement(pArray, &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulUptime = V_UI4(&Param);
}
VariantClear(&Param);
}
VariantClear(&OutArgs);
}
else if(UPNP_E_INVALID_ACTION == hr) // gateway does not support our custom action, revert to default chatty behavior
{
VARIANT OutArgs;
LONG lIndex = 0;
VARIANT Param;
hr = InvokeVoidAction(pWANCommonInterfaceConfig, L"GetTotalBytesSent", &OutArgs);
if(SUCCEEDED(hr))
{
lIndex = 0;
hr = SafeArrayGetElement(V_ARRAY(&OutArgs), &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalBytesSent = V_UI4(&Param);
}
VariantClear(&Param);
}
VariantClear(&OutArgs);
}
if(SUCCEEDED(hr))
{
lIndex = 0;
hr = InvokeVoidAction(pWANCommonInterfaceConfig, L"GetTotalBytesReceived", &OutArgs);
if(SUCCEEDED(hr))
{
hr = SafeArrayGetElement(V_ARRAY(&OutArgs), &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalBytesReceived = V_UI4(&Param);
}
VariantClear(&Param);
}
VariantClear(&OutArgs);
}
}
if(SUCCEEDED(hr))
{
lIndex = 0;
hr = InvokeVoidAction(pWANCommonInterfaceConfig, L"GetTotalPacketsSent", &OutArgs);
if(SUCCEEDED(hr))
{
hr = SafeArrayGetElement(V_ARRAY(&OutArgs), &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalPacketsSent = V_UI4(&Param);
}
VariantClear(&Param);
}
VariantClear(&OutArgs);
}
}
if(SUCCEEDED(hr))
{
hr = InvokeVoidAction(pWANCommonInterfaceConfig, L"GetTotalPacketsReceived", &OutArgs);
if(SUCCEEDED(hr))
{
lIndex = 0;
hr = SafeArrayGetElement(V_ARRAY(&OutArgs), &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulTotalPacketsReceived = V_UI4(&Param);
}
VariantClear(&Param);
}
VariantClear(&OutArgs);
}
}
if(SUCCEEDED(hr))
{
hr = InvokeVoidAction(pWANCommonInterfaceConfig, L"GetCommonLinkProperties", &OutArgs);
if(SUCCEEDED(hr))
{
lIndex = 2;
hr = SafeArrayGetElement(V_ARRAY(&OutArgs), &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulSpeedbps = V_UI4(&Param);
}
VariantClear(&Param);
}
VariantClear(&OutArgs);
}
}
if(SUCCEEDED(hr))
{
hr = InvokeVoidAction(pWANConnection, L"GetStatusInfo", &OutArgs);
if(SUCCEEDED(hr))
{
lIndex = 2;
hr = SafeArrayGetElement(V_ARRAY(&OutArgs), &lIndex, &Param);
if(SUCCEEDED(hr))
{
if(V_VT(&Param) == VT_UI4)
{
m_ulUptime = V_UI4(&Param);
}
VariantClear(&Param);
}
VariantClear(&OutArgs);
}
}
if(UPNP_E_INVALID_ACTION == hr)
{
hr = S_OK; // server does not support statistics
m_ulTotalBytesSent = 0;
m_ulTotalBytesReceived = 0;
m_ulTotalPacketsSent = 0;
m_ulTotalPacketsReceived = 0;
m_ulSpeedbps = 0;
m_ulUptime = 0;
}
}
if(FAILED(hr))
{
m_Status = NCS_DISCONNECTED;
}
}
else
{
m_Status = NCS_DISCONNECTED;
}
SysFreeString(ConnectionStatus);
}
ReleaseObj(pWANCommonInterfaceConfig);
}
ReleaseObj(pWANConnection);
}
m_bRequested = FALSE;
InternalRelease(); // release ref given to us in HrUpdateData
return hr;
}
DWORD CSharedAccessStatEngine::StaticUpdateStats(LPVOID lpParameter)
{
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if(SUCCEEDED(hr))
{
CSharedAccessStatEngine* pThis = reinterpret_cast<CSharedAccessStatEngine*>(lpParameter);
hr = pThis->UpdateStats();
CoUninitialize();
}
return 0;
}
HRESULT CSharedAccessStatEngine::GetStringStateVariable(IUPnPService* pService, LPWSTR pszVariableName, BSTR* pString)
{
HRESULT hr = S_OK;
VARIANT Variant;
VariantInit(&Variant);
BSTR VariableName;
VariableName = SysAllocString(pszVariableName);
if(NULL != VariableName)
{
hr = pService->QueryStateVariable(VariableName, &Variant);
if(SUCCEEDED(hr))
{
if(V_VT(&Variant) == VT_BSTR)
{
*pString = V_BSTR(&Variant);
}
else
{
hr = E_UNEXPECTED;
}
}
if(FAILED(hr))
{
VariantClear(&Variant);
}
SysFreeString(VariableName);
}
else
{
hr = E_OUTOFMEMORY;
}
TraceHr (ttidError, FAL, hr, FALSE, "CSharedAccessConnection::GetStringStateVariable");
return hr;
}
HRESULT CSharedAccessStatEngine::InvokeVoidAction(IUPnPService * pService, LPTSTR pszCommand, VARIANT* pOutParams)
{
HRESULT hr;
BSTR bstrActionName;
bstrActionName = SysAllocString(pszCommand);
if (NULL != bstrActionName)
{
SAFEARRAYBOUND rgsaBound[1];
SAFEARRAY * psa = NULL;
rgsaBound[0].lLbound = 0;
rgsaBound[0].cElements = 0;
psa = SafeArrayCreate(VT_VARIANT, 1, rgsaBound);
if (psa)
{
LONG lStatus;
VARIANT varInArgs;
VARIANT varReturnVal;
VariantInit(&varInArgs);
VariantInit(pOutParams);
VariantInit(&varReturnVal);
varInArgs.vt = VT_VARIANT | VT_ARRAY;
V_ARRAY(&varInArgs) = psa;
hr = pService->InvokeAction(bstrActionName,
varInArgs,
pOutParams,
&varReturnVal);
if(SUCCEEDED(hr))
{
VariantClear(&varReturnVal);
}
SafeArrayDestroy(psa);
}
else
{
hr = E_OUTOFMEMORY;
}
SysFreeString(bstrActionName);
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////
// //
// CPspSharedAccessGen //
// //
//////////////////////////////////////////////////////////////////////////////
CPspSharedAccessGen::CPspSharedAccessGen(VOID)
{
m_ncmType = NCM_SHAREDACCESSHOST_LAN;
m_ncsmType = NCSM_NONE;
m_dwCharacter =0;
m_adwHelpIDs = NULL;
return;
}
//+---------------------------------------------------------------------------
//
// Member: CPspSharedAccessGen::put_MediaType
//
// Purpose: Set the media typew
//
// Arguments: ncm - the media type
// ncsm - the submedia type
//
// Returns: Nothing
//
void CPspSharedAccessGen::put_MediaType(NETCON_MEDIATYPE ncm, NETCON_SUBMEDIATYPE ncsm)
{
m_ncmType = ncm;
m_ncsmType = ncsm;
}
//+---------------------------------------------------------------------------
//
// Member: CPspSharedAccessGen::ShouldShowPackets
//
// Purpose: Decided whether to show bytes or packets
//
// Arguments: pseNewData - The new stats being displayed on the page
//
// Returns: Nothing
//
BOOL CPspSharedAccessGen::ShouldShowPackets(const STATMON_ENGINEDATA* pseNewData)
{
return (((0 == pseNewData->SMED_BYTESTRANSMITTING) && (0 == pseNewData->SMED_BYTESRECEIVING)) ||
((0 == pseNewData->SMED_SALOCAL_BYTESTRANSMITTING) && (0 == pseNewData->SMED_SALOCAL_BYTESRECEIVING))); // REVIEW assuming all adapters can show packets
}
//+---------------------------------------------------------------------------
//
// Member: CPspSharedAccessGen::UpdatePageBytesTransmitting
//
// Purpose: Updates the bytes Transmitting display for the ICS host on the general page
//
// Arguments: pseOldData - The old stats being displayed on the page
// pseNewData - The new stats being displayed on the page
// iStat - The which stats to display
//
// Returns: Nothing
//
VOID
CPspSharedAccessGen::UpdatePageBytesTransmitting(
const STATMON_ENGINEDATA* pseOldData,
const STATMON_ENGINEDATA* pseNewData,
StatTrans iStat)
{
if(0 != pseNewData->SMED_SPEEDTRANSMITTING) // we use 0 in the speed field to indicate that statistics are not valid
{
CPspStatusMonitorGen::UpdatePageBytesTransmitting(pseOldData, pseNewData, iStat); // First update the local data
}
else
{
SetDlgItemText(IDC_TXT_SM_BYTES_TRANS, SzLoadIds(IDS_SM_NOTAVAILABLE));
}
UINT64 ui64Old;
UINT64 ui64New;
if (Stat_Bytes == iStat)
{
ui64Old = pseOldData->SMED_SALOCAL_BYTESTRANSMITTING;
ui64New = pseNewData->SMED_SALOCAL_BYTESTRANSMITTING;
}
else
{
ui64Old = pseOldData->SMED_SALOCAL_PACKETSTRANSMITTING;
ui64New = pseNewData->SMED_SALOCAL_PACKETSTRANSMITTING;
}
// See if either is different
//
if (ui64Old != ui64New)
{
SetDlgItemFormatted64bitInteger(
m_hWnd,
IDC_TXT_SM_SALOCAL_BYTES_TRANS,
ui64New, FALSE);
}
}
//+---------------------------------------------------------------------------
//
// Member: CPspSharedAccessGen::UpdatePageBytesReceiving
//
// Purpose: Updates the bytes receiving display for the ICS host on the general page
//
// Arguments: puiOld - The old stats being displayed on the page
// puiNew - The new stats being displayed on the page
// iStat - The which stats to display
//
// Returns: Nothing
//
VOID
CPspSharedAccessGen::UpdatePageBytesReceiving(
const STATMON_ENGINEDATA* pseOldData,
const STATMON_ENGINEDATA* pseNewData,
StatTrans iStat)
{
if(0 != pseNewData->SMED_SPEEDTRANSMITTING) // we use 0 in the speed field to indicate that statistics are not valid
{
CPspStatusMonitorGen::UpdatePageBytesReceiving(pseOldData, pseNewData, iStat); // First update the local data
}
else
{
SetDlgItemText(IDC_TXT_SM_BYTES_RCVD, SzLoadIds(IDS_SM_NOTAVAILABLE));
}
UINT64 ui64Old;
UINT64 ui64New;
if (Stat_Bytes == iStat)
{
ui64Old = pseOldData->SMED_SALOCAL_BYTESRECEIVING;
ui64New = pseNewData->SMED_SALOCAL_BYTESRECEIVING;
}
else
{
ui64Old = pseOldData->SMED_SALOCAL_PACKETSRECEIVING;
ui64New = pseNewData->SMED_SALOCAL_PACKETSRECEIVING;
}
// See if either is different
//
if (ui64Old != ui64New)
{
SetDlgItemFormatted64bitInteger(
m_hWnd,
IDC_TXT_SM_SALOCAL_BYTES_RCVD,
ui64New, FALSE);
}
}
VOID CPspSharedAccessGen::UpdatePageIcon(DWORD dwChangeFlags)
{
// Keep the flags for the next update
//
m_dwChangeFlags = dwChangeFlags;
}
VOID CPspSharedAccessGen::UpdatePageSpeed(
const STATMON_ENGINEDATA* pseOldData,
const STATMON_ENGINEDATA* pseNewData)
{
if(0 != pseNewData->SMED_SPEEDTRANSMITTING) // we use 0 in the speed field to indicate that statistics are not valid
{
CPspStatusMonitorGen::UpdatePageSpeed(pseOldData, pseNewData);
}
else
{
SetDlgItemText(IDC_TXT_SM_SPEED, SzLoadIds(IDS_SM_NOTAVAILABLE));
}
}
VOID
CPspSharedAccessGen::UpdatePageDuration(
const STATMON_ENGINEDATA* pseOldData,
const STATMON_ENGINEDATA* pseNewData)
{
if(0 != pseNewData->SMED_SPEEDTRANSMITTING) // we use 0 in the speed field to indicate that statistics are not valid
{
CPspStatusMonitorGen::UpdatePageDuration(pseOldData, pseNewData);
}
else
{
SetDlgItemText(IDC_TXT_SM_DURATION, SzLoadIds(IDS_SM_NOTAVAILABLE));
}
}
//////////////////////////////////////////////////////////////////////////////
// //
// CPspSharedAccessTool //
// //
//////////////////////////////////////////////////////////////////////////////
CPspSharedAccessTool::CPspSharedAccessTool(VOID)
{
m_ncmType = NCM_SHAREDACCESSHOST_LAN;
m_ncsmType = NCSM_NONE;
m_dwCharacter = 0;
return;
}
//+---------------------------------------------------------------------------
//
// Member: CPspSharedAccessTool::HrInitToolPageType
//
// Purpose: Gets from the connection any information that is relevant to
// this particular connection type.
//
// Arguments: pncInit - The connection assocatied with this dialog
//
// Returns: Error code
//
HRESULT CPspSharedAccessTool::HrInitToolPageType(INetConnection* pncInit)
{
HRESULT hr = S_OK;
TraceError("CPspSharedAccessTool::HrInitToolPageType", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CPspSharedAccessTool::HrAddCommandLineFlags
//
// Purpose: Adds the flags for this selection to the command line for the
// tool being launched.
//
// Arguments: pstrFlags - The command line that the flags have to be
// appended to
// psmteSel - The tool entry associated with this selection
//
// Returns: Error code
//
HRESULT CPspSharedAccessTool::HrAddCommandLineFlags(tstring* pstrFlags,
CStatMonToolEntry* psmteSel)
{
HRESULT hr = S_OK;
DWORD dwFlags = 0x0;
// Same some indirections
//
dwFlags = psmteSel->dwFlags;
//
// // Check what flags are asked for and provide them if we can
// //
//
// if (SCLF_ADAPTER & dwFlags)
// {
// pstrFlags->append(c_szCmdLineFlagPrefix);
// pstrFlags->append(g_asmtfMap[STFI_ADAPTER].pszFlag);
// pstrFlags->append(c_szSpace);
// pstrFlags->append(m_strLocalDeviceName);
// }
TraceError("CPspStatusMonitorTool::HrAddCommandLineFlags", hr);
return hr;
}
HRESULT CPspSharedAccessTool::HrGetDeviceType(INetConnection* pncInit)
{
UINT uiRet = 0;
// Set the default type
m_strDeviceType = L"Ethernet";
return S_OK;
}
HRESULT CPspSharedAccessTool::HrGetComponentList(INetConnection* pncInit)
{
// Get a readonly INetCfg, enumerate components bound to this adapter
HRESULT hr = S_OK;
return hr;
}
Reference in a new issue Copy permalink