WINDOWS网络流量监控(区分物理网卡)(Win32)

最新推荐文章于 2024-07-26 10:43:05 发布
最新推荐文章于 2024-07-26 10:43:05 发布
阅读量2.3k 收藏 4
点赞数
分类专栏： 操作系统 文章标签： C++ 性能 流量 物理网卡
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangbeacon/article/details/8666800
版权 
#include <tchar.h>
#include <STDIO.H>
#include <locale.h>
#include <WINDOWS.H>

#include <atlconv.h>
#include <atlstr.h>

#include <vector>
#include <list>
#include <map>

#include <strsafe.h>

#include <boost\format.hpp>
#include <boost\io\ios_state.hpp>
#include <boost\algorithm\string.hpp>
#include <boost\xpressive\xpressive_dynamic.hpp>

#define PERF_SUBKEY_GLOBAL      _T("Global")
#define REG_SUBKEY_COUNTER      _T("Counter")
#define REG_SUBKEY_HELP         _T("Help")
#define FIRST_PERF_OBJECT_TYPE( PerfData ) ((PPERF_OBJECT_TYPE)((PBYTE)PerfData + PerfData->HeaderLength))
#define NEXT_PERF_OBJECT_TYPE( PerfObj ) ((PPERF_OBJECT_TYPE)((PBYTE)PerfObj + PerfObj->TotalByteLength))
#define FIRST_PERF_COUNTER_DEFINITION( PerfObj ) ((PPERF_COUNTER_DEFINITION)((PBYTE)PerfObj + PerfObj->HeaderLength))
#define NEXT_PERF_COUNTER_DEFINITION( PerfCounterDef ) ((PPERF_COUNTER_DEFINITION)((PBYTE)PerfCounterDef + PerfCounterDef->ByteLength))
#define FIRST_PERF_INSTANCE_DEFINITION( PerfObj ) ((PPERF_INSTANCE_DEFINITION)((PBYTE)PerfObj + PerfObj->DefinitionLength))
#define PERF_COUNTER_BLOCK_FROM_INSTANCE( PerfInst ) ((PPERF_COUNTER_BLOCK)((PBYTE)PerfInst + PerfInst->ByteLength))
#define PERF_COUNTER_BLOCK_FROM_OBJECT( PerfObj ) ((PPERF_COUNTER_BLOCK)((PBYTE)PerfObj + PerfObj->DefinitionLength))
#define NEXT_PERF_INSTANCE_DEFINITION( PerfInst ) ((PPERF_INSTANCE_DEFINITION)((PBYTE)PerfInst + PerfInst->ByteLength + PERF_COUNTER_BLOCK_FROM_INSTANCE(PerfInst)->ByteLength ))
#define GET_COUNTER_VALUE_DWORD( PerfCounter, PerfCounterDef ) (*(LPDWORD)((LPBYTE)PerfCounter + PerfCounterDef->CounterOffset ))
#define GET_COUNTER_VALUE_OF_TYPE( PerfCounter, PerfCounterDef, Type ) (*(Type*)((LPBYTE)PerfCounter + PerfCounterDef->CounterOffset ))

namespace std
{
    typedef basic_string<TCHAR, char_traits<TCHAR>, allocator<TCHAR> > tstring;
}

std::map<DWORD, CString> g_mapCounters;
std::map<DWORD, CString> g_mapHelps;
std::map<std::tstring, BOOL>  g_mapPhys;


typedef struct _PerfInstance_t
{
    PPERF_INSTANCE_DEFINITION       pInstance;
    CString                         strInstanceName;
    CString                         strParentInstanceName;
    PPERF_COUNTER_BLOCK             pPerfCounters;
}PerfInstance_t, *pPerfInstance_t;
typedef struct _PerfObject_t
{
    PPERF_OBJECT_TYPE               pPerfObject;
    
    std::vector<PPERF_COUNTER_DEFINITION>
                                    vecPerfCounterDefs;

    PPERF_COUNTER_BLOCK             pPerfCounters;
    std::vector<PerfInstance_t>     vecPerfInstances;
}PerfObject_t, *pPerfObject_t;
typedef struct _PerfData_t
{
    std::vector<PerfObject_t>       vecPerfObjects;
}PerfData_t, *pPerfData_t;

// 获得性能数据块
std::vector<BYTE> GetRegValueData(
    LPCTSTR lpSubKey,
    HKEY hParentKey = HKEY_PERFORMANCE_DATA,
    LPCTSTR lpMachineName = NULL,
    DWORD dwPerSize = 0x400 )
{
    DWORD dwType;

    CONST DWORD dwDefaultBufferSize = dwPerSize;
    DWORD dwBufferSize = dwDefaultBufferSize;
    // 性能数据缓冲
    std::vector<BYTE> vecBuffer;

    HKEY hKey = hParentKey;
    if( lpMachineName && lpMachineName[0] != _T('\0') )
    {
        if( RegConnectRegistry(
            lpMachineName,
            hKey,
            &hKey ) != ERROR_SUCCESS )
            return vecBuffer;
    }

    LSTATUS lStatus;
    vecBuffer.resize(dwBufferSize);

    while( ( lStatus = RegQueryValueEx(
        hKey,
        lpSubKey,
        NULL,
        &dwType,
        vecBuffer.data(),
        &dwBufferSize ) ) != ERROR_SUCCESS )
    {
        if( lStatus == ERROR_MORE_DATA )
        {
            // 缓冲尺寸太小,增加内存分配
            dwBufferSize += dwDefaultBufferSize;
            vecBuffer.resize( dwBufferSize );
        }
        else
        {
            vecBuffer.clear();
            return vecBuffer;
        }
    }

    vecBuffer.resize( dwBufferSize );
    return vecBuffer;
}

std::vector<BYTE> GetRegValueData(
    DWORD dwSubKey,
    HKEY hParentKey = HKEY_PERFORMANCE_DATA,
    LPCTSTR lpMachineName = NULL,
    DWORD dwPerSize = 0x400 )
{
    TCHAR szSubKey[0x10];
    _ltot_s( dwSubKey, szSubKey, 0x10, 10 );
    return GetRegValueData( szSubKey, hParentKey, lpMachineName, dwPerSize );
}

// 枚举性能对象
BOOL EnumPerfObject(
    IN  PERF_DATA_BLOCK * pPerfData,
    OUT std::list<PERF_OBJECT_TYPE> & vecRefObjType )
{
    vecRefObjType.clear();

    PERF_OBJECT_TYPE * pObjType = FIRST_PERF_OBJECT_TYPE( pPerfData );
    for( DWORD i(0); i < pPerfData->NumObjectTypes; ++i )
    {
        vecRefObjType.push_back( *pObjType );
        pObjType = NEXT_PERF_OBJECT_TYPE( pObjType );
    }

    return TRUE;
}

// 获取性能计数器名字
BOOL GetCounters( std::map<DWORD, CString> & mapCounters )
{
    mapCounters.clear();

    std::vector<BYTE> vecBuffer = GetRegValueData( REG_SUBKEY_COUNTER, HKEY_PERFORMANCE_NLSTEXT );
    if( vecBuffer.empty() ) return FALSE;

    LPTSTR lpStr = (LPTSTR)vecBuffer.data();
    while( *lpStr )
    {
        DWORD dwCounter = _ttol(lpStr);
        lpStr += lstrlen(lpStr) + 1;
        mapCounters[dwCounter] = lpStr;
        lpStr += lstrlen(lpStr) + 1;
    }

    return TRUE;
}
// 获取性能计数器的帮助
BOOL GetHelps( std::map<DWORD, CString> & mapHelps )
{
    mapHelps.clear();

    std::vector<BYTE> vecBuffer = GetRegValueData( REG_SUBKEY_HELP, HKEY_PERFORMANCE_NLSTEXT );
    if( vecBuffer.empty() ) return FALSE;

    LPTSTR lpStr = (LPTSTR)vecBuffer.data();
    while( *lpStr )
    {
        DWORD dwCounter = _ttol(lpStr);
        lpStr += lstrlen(lpStr) + 1;
        mapHelps[dwCounter] = lpStr;
        lpStr += lstrlen(lpStr) + 1;
    }

    return TRUE;
}

PPERF_OBJECT_TYPE GetObjectType(
    PPERF_DATA_BLOCK pPerfDataBlock,
    DWORD dwObjectNameTitleIndex )
{
    PPERF_OBJECT_TYPE pPerfObjectType = FIRST_PERF_OBJECT_TYPE( pPerfDataBlock );

    for( DWORD i(0); i < pPerfDataBlock->NumObjectTypes; ++i )
    {
        if( pPerfObjectType->ObjectNameTitleIndex == dwObjectNameTitleIndex )
        {
            return pPerfObjectType;
        }
        pPerfObjectType = NEXT_PERF_OBJECT_TYPE( pPerfObjectType );
    }

    return NULL;
}

PPERF_INSTANCE_DEFINITION GetParentInstance(
    PPERF_OBJECT_TYPE const pPerfObjectType,
    DWORD dwInstanceIndex )
{
    PPERF_INSTANCE_DEFINITION pPerfInstanceDefinition = FIRST_PERF_INSTANCE_DEFINITION( pPerfObjectType );
    PPERF_COUNTER_BLOCK pPerfCounterBlock = NULL;
    for( DWORD i(0); i < dwInstanceIndex; ++i )
    {
        pPerfCounterBlock = PERF_COUNTER_BLOCK_FROM_INSTANCE( pPerfInstanceDefinition );

        pPerfInstanceDefinition = NEXT_PERF_INSTANCE_DEFINITION( pPerfInstanceDefinition );
    }

    return pPerfInstanceDefinition;
}

CString GetInstanceName(
    PPERF_INSTANCE_DEFINITION pPerfInstanceDefinition,
    UINT CodePage )
{
    CStringW strInstanceNameW;
    const DWORD dwMaxInstNameLen = 0xFF;
    if( pPerfInstanceDefinition->NameLength > dwMaxInstNameLen ) return CString();

    LPBYTE lpInstanceName = (LPBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->NameOffset;
    if( CodePage == 0 ) // Unicode
    {
        DWORD cch = pPerfInstanceDefinition->NameLength / 2;
        StringCchCopyNW(
            strInstanceNameW.GetBuffer( cch + 1 ),
            cch + 1,
            (LPCWSTR)lpInstanceName,
            cch );
        strInstanceNameW.ReleaseBuffer();
    }
    else if( CodePage != UINT_MAX ) // 异常值
    {
        CStringA strInstanceNameA;
        StringCbCopyNA(
            strInstanceNameA.GetBuffer( pPerfInstanceDefinition->NameLength + 1 ),
            pPerfInstanceDefinition->NameLength + 1,
            (LPCSTR)lpInstanceName,
            pPerfInstanceDefinition->NameLength );
        strInstanceNameA.ReleaseBuffer();

        strInstanceNameW = CA2W( strInstanceNameA, CodePage );
    }
    
    return CString( strInstanceNameW );
}
void GetFullInstanceName(
    PPERF_DATA_BLOCK const pPerfDataBlock,
    PPERF_INSTANCE_DEFINITION pInstance,
    UINT CodePage,
    CString & strName,
    CString & strParentName )
{
    strName = GetInstanceName( pInstance, CodePage );

    if( pInstance->ParentObjectTitleIndex )
    {
        PPERF_OBJECT_TYPE pParentObject = GetObjectType(
            pPerfDataBlock,
            pInstance->ParentObjectTitleIndex );

        if( pParentObject )
        {
            PPERF_INSTANCE_DEFINITION pParentInstance = GetParentInstance(
                pParentObject,
                pInstance->ParentObjectInstance );
            if( pParentInstance )
            {
                strParentName = GetInstanceName( pParentInstance, CodePage );
            }
        }
    }
}

DWORD LoadCounterDefs(
    PPERF_OBJECT_TYPE const pPerfObject,
    std::vector<PPERF_COUNTER_DEFINITION> & vecPerfCounterDefs )
{
    vecPerfCounterDefs.clear();
    DWORD dwSkippedBaseRecords = 0;

    PPERF_COUNTER_DEFINITION pPerfCounterDef = FIRST_PERF_COUNTER_DEFINITION( pPerfObject );
    for( DWORD i(0); i < pPerfObject->NumCounters; ++i )
    {
        vecPerfCounterDefs.push_back( pPerfCounterDef );

        pPerfCounterDef = NEXT_PERF_COUNTER_DEFINITION( pPerfCounterDef );
    }

    return pPerfObject->NumCounters - dwSkippedBaseRecords;
}
void LoadInstances(
    PPERF_DATA_BLOCK const pPerfData,
    PPERF_OBJECT_TYPE const pPerfObject,
    std::vector<PerfInstance_t> & vecPerfInstances )
{
    vecPerfInstances.clear();

    PPERF_INSTANCE_DEFINITION pInstance = FIRST_PERF_INSTANCE_DEFINITION( pPerfObject );
    for( LONG i(0); i < pPerfObject->NumInstances; ++i )
    {
        PerfInstance_t perfInst;
        perfInst.pPerfCounters = PERF_COUNTER_BLOCK_FROM_INSTANCE( pInstance );
        perfInst.pInstance = pInstance;

        GetFullInstanceName(
            pPerfData,
            pInstance,
            pPerfObject->CodePage,
            perfInst.strInstanceName,
            perfInst.strParentInstanceName );

        vecPerfInstances.push_back( perfInst );

        pInstance = NEXT_PERF_INSTANCE_DEFINITION( pInstance );
    }
}
BOOL LoadObjects(
    PPERF_DATA_BLOCK const pPerfDataBlock,
    std::vector<PerfObject_t> & vecPerfObjects )
{
    vecPerfObjects.clear();

    PPERF_OBJECT_TYPE pPerfObject = FIRST_PERF_OBJECT_TYPE( pPerfDataBlock );
    for( DWORD i(0); i < pPerfDataBlock->NumObjectTypes; ++i )
    {
        PerfObject_t perfObj;
        perfObj.pPerfObject = pPerfObject;

        LoadCounterDefs( pPerfObject, perfObj.vecPerfCounterDefs );


        if( pPerfObject->NumInstances == 0 ||
            pPerfObject->NumInstances == PERF_NO_INSTANCES )
        {
            // 没有实例对象
            perfObj.pPerfCounters = PERF_COUNTER_BLOCK_FROM_OBJECT( pPerfObject );
        }
        else
        {
            LoadInstances( pPerfDataBlock, pPerfObject, perfObj.vecPerfInstances );
        }
        vecPerfObjects.push_back( perfObj );

        pPerfObject = NEXT_PERF_OBJECT_TYPE( pPerfObject );
        if( (LPBYTE)pPerfObject >= (LPBYTE)pPerfDataBlock + pPerfDataBlock->TotalByteLength ) break;
    }

    return TRUE;
}

BOOL LoadObjectData(
    PPERF_DATA_BLOCK const pPerfDataBlock,
    PerfData_t & perfData )
{
    if( pPerfDataBlock == NULL ) return FALSE;

    TCHAR szSubKey[0x400] = {0};

    if( !(pPerfDataBlock->Signature[0] == L'P' && 
        pPerfDataBlock->Signature[1] == L'E' &&
        pPerfDataBlock->Signature[2] == L'R' &&
        pPerfDataBlock->Signature[3] == L'F' ) )
    {
        return FALSE;
    }
    
    return LoadObjects( pPerfDataBlock, perfData.vecPerfObjects );
}

DWORD GetNumberOfTextEntries(LPCTSTR lpszSource)
{
    DWORD dwEntries = 0;
    DWORD dwSize = sizeof(DWORD);
    HKEY hKey = NULL;
    do
    {
        LRESULT lResult = RegOpenKeyEx(
            HKEY_LOCAL_MACHINE,
            _T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib"),
            0,
            KEY_READ,
            &hKey );
        if( lResult != ERROR_SUCCESS ) break;

        lResult = RegQueryValueEx(
            hKey,
            lpszSource,
            NULL,
            0,
            (LPBYTE)&dwEntries,
            &dwSize );
        if( lResult != ERROR_SUCCESS ) break;

    }while(false);

    if( hKey ) RegCloseKey( hKey );

    return dwEntries;
}

enum ETrafficType               // (查 mapCounters 表可得知)
{
    EAllTraffic      = 388,     // 总的流量
    EIncomingTraffic = 264,     // 输入流量
    EOutGoingTraffic = 506      // 输出流量
};

LSTATUS GetRegDWORDValue( HKEY hRootKey, CString strPath, CString strValueName, DWORD & dwValue )
{
    HKEY hKey;
    LSTATUS lStatus;
    do
    {
        lStatus = RegOpenKey(
            hRootKey,
            strPath,
            &hKey );
        if( lStatus != ERROR_SUCCESS ) break;

        DWORD dwLen = sizeof(DWORD);
        lStatus = RegQueryValueEx(
            hKey,
            strValueName,
            NULL,
            NULL,
            reinterpret_cast<LPBYTE>(&dwValue),
            &dwLen );

    } while (false);

    if( hKey != NULL ) RegCloseKey( hKey );

    return lStatus;
}


LSTATUS GetRegStringValue( HKEY hRootKey, CString strPath, CString strValueName, CString & strValue )
{
    HKEY hKey;
    LSTATUS lStatus;
    do
    {
        lStatus = RegOpenKey(
            hRootKey,
            strPath,
            &hKey );
        if( lStatus != ERROR_SUCCESS ) break;

        DWORD dwMaxValueLen;
        lStatus = RegQueryInfoKey(
            hKey,
            NULL,
            NULL,
            0,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            &dwMaxValueLen,
            NULL,
            NULL );
        if( lStatus != ERROR_SUCCESS ) break;

        lStatus = RegQueryValueEx(
            hKey,
            strValueName,
            NULL,
            NULL,
            reinterpret_cast<LPBYTE>(strValue.GetBuffer( dwMaxValueLen / sizeof(TCHAR) )),
            &dwMaxValueLen );
        strValue.ReleaseBuffer();

    } while (false);

    if( hKey != NULL ) RegCloseKey( hKey );

    return lStatus;
}

void FixInstanceName( std::tstring & name )
{
    name = boost::xpressive::regex_replace(
        name,
        boost::xpressive::basic_regex<std::tstring::const_iterator>::compile( _T("\\W") ),
        _T("") );
    boost::erase_all( name, _T("_") );
}
LSTATUS GetApaptersIsHardwareList( std::map<std::tstring, BOOL> & map )
{
    map.clear();

    LSTATUS lStatus = 0;
    HKEY hKey = NULL;
    do
    {
        CString strRootPath = _T("SYSTEM\\ControlSet001\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}");
        // 打开适配器的注册表路径
        lStatus = RegOpenKey(
            HKEY_LOCAL_MACHINE,
            strRootPath,
            &hKey );
        if( lStatus != ERROR_SUCCESS ) break;
        
        // 获得子键数目和子值最大字节数
        DWORD dwSubKeys;
        DWORD dwMaxKeyNameLen;
        lStatus = RegQueryInfoKey(
            hKey,
            NULL,
            NULL,
            0,
            &dwSubKeys,
            &dwMaxKeyNameLen,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL );
        if( lStatus != ERROR_SUCCESS ) break;

        for( DWORD i(0); i < dwSubKeys; ++i )
        {
            CString strSubKeyName;
            lStatus = RegEnumKey(
                hKey,
                i,
                strSubKeyName.GetBuffer( dwMaxKeyNameLen ),
                dwMaxKeyNameLen );
            strSubKeyName.ReleaseBuffer();
            if( lStatus != ERROR_SUCCESS ) break;

            CString strAdapterPath = (strRootPath + CString(_T("\\")) + strSubKeyName);

            /*
            // 方法一: 获得 DeviceInstanceId
            CString strDeviceInstanceId;
            lStatus = GetRegStringValue( HKEY_LOCAL_MACHINE, strAdapterPath, _T("DeviceInstanceID"), strDeviceInstanceId );
            if( lStatus != ERROR_SUCCESS ) break;
            */
            
            // 方法一: 获得 Characteristics
            DWORD dwCharacteristics;
            lStatus = GetRegDWORDValue( HKEY_LOCAL_MACHINE, strAdapterPath, _T("Characteristics"), dwCharacteristics );
            if( lStatus != ERROR_SUCCESS ) break;

            // 获得驱动描述
            CString strDriverDesc;
            lStatus = GetRegStringValue( HKEY_LOCAL_MACHINE, strAdapterPath, _T("DriverDesc"), strDriverDesc );
            if( lStatus == ERROR_SUCCESS )
            {
                std::tstring tsDriverDesc = strDriverDesc;
                FixInstanceName( tsDriverDesc );
                /*
                // 方法一: 如果 DeviceInstanceId 是以 USB\\ 或 PCI\\ 开头的, 则认为其为物理适配器
                map[tsDriverDesc] =
                    ( strDeviceInstanceId.Left( 4 ).CompareNoCase(_T("USB\\")) == 0 ||
                    strDeviceInstanceId.Left( 4 ).CompareNoCase(_T("PCI\\")) == 0 );
                    */
                // 方法二: 判断 Characteristics(特征) 中是否含有 NCF_PHYSICAL 标志
                map[tsDriverDesc] = ( dwCharacteristics & 0x4 );       // NCF_PHYSICAL
            }
        }
    }while(false);

    return lStatus;
}

void PrintObjectNames(
    std::basic_ostream<TCHAR, std::char_traits<TCHAR> > & os,
    const PerfData_t & perfData,
    const std::map<DWORD, CString> & mapCounters,
    const std::map<DWORD, CString> & mapHelps )
{
    typedef boost::basic_format<TCHAR> format_t;
    typedef std::map< DWORD, DWORD > map_traffics_t;
    typedef std::map<std::tstring, map_traffics_t > map_inst_traffics_t;
    static map_inst_traffics_t map_inst_traffics;                       // 用于保存上一次的流量数据
    for( size_t i = 0; i < perfData.vecPerfObjects.size(); ++i )
    {
        const PerfObject_t & perfObject = perfData.vecPerfObjects[i];
        DWORD dwIndex = perfObject.pPerfObject->ObjectNameTitleIndex;
        
        DWORD dwTotalIn = 0, dwTotalOut = 0;
        if( perfObject.vecPerfInstances.size() == 0 )
        {
            // 如果不是网络适配器(不同的协议种类),那么就不统计
            continue;
        }
        else
        {
            for( size_t j = 0; j < perfObject.vecPerfInstances.size(); ++j )
            {
                std::tstring strInstanceName = perfObject.vecPerfInstances[j].strInstanceName;
                FixInstanceName( strInstanceName );
                // 修正名字(耗资源)

                os << format_t( _T("%1%(%2%)\n") )
                    % perfObject.vecPerfInstances[j].strParentInstanceName.GetString()
                    % perfObject.vecPerfInstances[j].strInstanceName.GetString();
                BOOL bIsPhysicalAdapter = FALSE;
                auto iterPhy = g_mapPhys.find( strInstanceName );
                if( iterPhy != g_mapPhys.end() )
                {
                    bIsPhysicalAdapter = iterPhy->second;
                }
        
                PPERF_COUNTER_BLOCK pPerfCounter = perfObject.vecPerfInstances[j].pPerfCounters;
                DWORD dwAllTraffic = 0, dwIncomingTraffic = 0, dwOutGoingTraffic = 0;

                for( size_t k = 0; k < perfObject.vecPerfCounterDefs.size(); ++k )
                {
                    DWORD dwCounterVal = GET_COUNTER_VALUE_DWORD( pPerfCounter, perfObject.vecPerfCounterDefs[k] );
                    dwIndex = perfObject.vecPerfCounterDefs[k]->CounterNameTitleIndex;
                    switch( dwIndex )
                    {
                    case EAllTraffic: dwAllTraffic = dwCounterVal; break;
                    case EIncomingTraffic: dwIncomingTraffic = dwCounterVal; break;
                    case EOutGoingTraffic: dwOutGoingTraffic = dwCounterVal; break;
                    }
                }

                if( map_inst_traffics.count(strInstanceName ) )
                {
                    if( map_inst_traffics[strInstanceName].size() != 0 )
                    {
                        DWORD dwIn = dwIncomingTraffic - map_inst_traffics[strInstanceName].at(EIncomingTraffic);
                        DWORD dwOut = dwOutGoingTraffic - map_inst_traffics[strInstanceName].at(EOutGoingTraffic);
                        if( bIsPhysicalAdapter )
                        {
                            dwTotalIn += dwIn;
                            dwTotalOut += dwOut;
                        }
                        format_t fmt( _T("  | %s:%|.2f| KB/S - %s:%|.2f| KB/S\n") );
                        fmt % mapCounters.at(EIncomingTraffic).GetString()
                            % ( dwIn / 1024.0f )
                            % mapCounters.at(EOutGoingTraffic).GetString()
                            % ( dwOut / 1024.0f );
                        os << fmt.str();
                    }
                }
                
                map_traffics_t map_traffics;
                map_traffics[EAllTraffic] = dwAllTraffic;
                map_traffics[EIncomingTraffic] = dwIncomingTraffic;
                map_traffics[EOutGoingTraffic] = dwOutGoingTraffic;
                map_inst_traffics[strInstanceName] = map_traffics;
            }
        }

        // 总流量*
        os << _T(" ==== Total ==== ") << std::endl;
        format_t fmt( _T("  | %s:%|.2f| KB/S - %s:%|.2f| KB/S\n") );
        fmt % mapCounters.at(EIncomingTraffic).GetString()
            % ( dwTotalIn / 1024.0f )
            % mapCounters.at(EOutGoingTraffic).GetString()
            % ( dwTotalOut / 1024.0f );
        os << fmt.str();
    }
}

int _tmain()
{
    setlocale(LC_ALL,"");
    // 获得计数器名字和帮助
    GetCounters( g_mapCounters );
    GetHelps( g_mapHelps );

    GetApaptersIsHardwareList( g_mapPhys );

    while( true )
    {
        std::vector<BYTE> vecPerfDataBlock = GetRegValueData(510);
        PPERF_DATA_BLOCK pPerfDataBlock = (PPERF_DATA_BLOCK)vecPerfDataBlock.data();
    
        std::list<PERF_OBJECT_TYPE> vecRefObjType;
        EnumPerfObject( (PPERF_DATA_BLOCK)vecPerfDataBlock.data(), vecRefObjType );
    
        PerfData_t perfData;
        LoadObjectData( pPerfDataBlock, perfData );

        PrintObjectNames( 
#ifdef UNICODE
            std::wcout
#else
            std::cout
#endif
            , perfData, g_mapCounters, g_mapHelps );
        Sleep(1000);
        system("cls");
    }

    getchar();
    return 0;
}

贝神
关注
专栏目录
【图文教程】监控系统命令
孫筅貹
08-10 1296
监控系统命令1. W命令2. vmstat命令3. top命令4. sar命令5. nload命令6. 监控io性能iostat命令iotop命令7. free命令8. ps命令9. netstat命令10. tcpdump命令tshark命令11. Linux网络相关命令12. 扩展 1. W命令 w含义：查看当前系统的负载。 学习如何监控系统状态，是因为作为一个运维工程师需要了解 Lin...
2022第三届全国大学生网络安全精英赛练习题（3）
派大星子的博客
11-21 9648
2022第三届全国大学生网络安全精英赛练习题（3）
基于windows的网络流量监控
05-11
可以监控流入和流出的网络上的数据流，用图形的形式现实出来，可以在windows平台上运行
windows下网络流量监控
关注系统性能调优
03-29 4648
今天做性能测试，分析得出测试遇到的瓶颈是本机的网络流量的限制。安装loadrunner软件的机器是windows XP的，网卡是百兆，那流量最大为10M。现在要监控下是否已经达到瓶颈。Windows下有自己的监控工具，比较方便，配置方法如下：            1. 【我的电脑】--》【管理】--》【系统工具】--》【性能日志和警报】--》【计算器日志】            2.   右
Windows系统网络流量监控与限制攻略
m0_74075744的博客
07-24 1346
使用这些工具，我们可以为不同的应用程序设置不同的流量限制，甚至可以为特定的IP地址或域名设置流量限制。Windows系统提供了一些内置的工具和方法，可以帮助我们监控和限制电脑的网络宽带流量。除了任务管理器外，还有一些第三方网络监控工具可以提供更详细的信息和更直观的图表展示，如NetSpeedMonitor等。5. 在“QoS数据包计划程序”窗口中，勾选“为此连接启用QoS”，然后选择适当的选项（如“指定入站TCP吞吐量级别”或“指定出站TCP吞吐量级别”）来设置QoS规则。
十二、windows网络知识梳理（12）--进阶知识流量监控-Winpcap
xiaobai_2511的博客
03-24 757
winpcap 是不能嗅探本地回环包的，不像npcap可以直接检索单本地的LoopBack(127.0.0.1)如果非要的话，也是有两种方法的。1、把本地包的下一跳直接设置成网关的，本地宝就会通过网卡到网关，这样就能捕捉到了。详细教程可以参考这里。该方式把所有本地包都从网关过了一下，导致效率低了。2、导出wpcap.dll的导出函数。重新设计。
Nagios监控Windows的网卡流量
weixin_34318956的博客
05-12 83
Nagios监控Windows的网卡流量 使用/usr/local/nagios/libexec/中的check_traffic.sh，不但可以监控Linux的网卡流量，也可以监控Windows服务器的流量。 1 Check_traffic.sh用法用法 [root@oracle...
用Win32 API监控网络流量的方法（转）
IT民工
12-04 7935
最近想做个网络流量统计的小工具，找到一些方案。 转自：http://hi.baidu.com/gyan_katsura/item/e2e82430e15d71d51b96968e 毕设要做计算机系统数据采集监控方面的，其中有一项是监控系统上的各个网络适配器上的流量。 简单调研了一下，结果如下： 1.首先要用到的头文件和库：iphlpapi.h和iphlpapi.lib 2.直接体
网络安全专业名词解释
aixmmmlll的博客
05-16 3896
1.Burp Suite 是一款信息安全从业人员必备的集成型的渗透测试工具，它采用自动测试和半自动测试的方式，通过拦截HTTP/HTTPS的Web数据包，充当浏览器和相关应用程序的中间人，进行拦截、修改、重放数据包进行测试，是Web安全人员的一把必备的瑞士军刀。 2.Bypass就是绕过的意思，渗透测试人员通过特殊语句的构建或者做混淆等进行渗透测试，然后达到绕过WAF的手法。 3.C2全称为Command and Control，命令与控制，常见于APT攻击场景中。作动词解释时理解为恶意软件与攻击者进行交互
软考-软件设计师(4)-计算机网络与安全:OSI七层、子网划分、网络安全控制技术、网络安全协议、网络安全威胁、对称与非对称加密等高频考点
最新发布
BADAO_LIUMANG_QIZHI的博客
07-26 880
1、基本子网划分，取网络号：A类保留第一个位，后面全0（如IP地址：10.1.0.0,网络号：10.0.0.0）；B类保留前两位，后面全0（如IP地址：131.2.3.0,网络号：131.2.0.0）；C类保留前三位，后面全0（如IP地址：192.168.1.5,网络号：192.168.1.0）。2、复杂子网划分，取网络号：首先将掩码为255的部分对应的部分照抄，然后对非255部分，将掩码和IP地址均转成二进制进行"与"运算。
【Ethereal：网络数据嗅探器软件】
马玉洁的专栏
12-17 1973
 （Ethereal：A Network Packet Sniffing Tool） 　　Ethereal 是当前较为流行的一种计算机网络调试和数据包嗅探软件。Ethereal 基本类似于tcpdump，但 Ethereal 还具有设计完美的 GUI 和众多分类信息及过滤选项。用户通过 Ethereal，同时将网卡插入混合模式，可以查看到网络中发送的所有通信流量。 　　Ethereal 应
vc网卡流量监控（网速监控）(GetIfTable)
09-11
程序和源码已打包，编译需XPSP2 PSDK ，写的比较乱，等有时间再整理
监视网络流量的windows api GetIfTable
04-09
得到网卡流量的windows api GetIfTable
WIN7网络流量监控小工具
01-04
WIN7网络流量监控小工具，WIN7网络流量监控小工具，WIN7网络流量监控小工具
一个简单网络流量监控软件的设计实现
04-23
基于winpcap类库的基础上，使用MFC作为框架，实现了网络嗅探器的基本功能——侦听选择网卡，过滤规则，查看数据包详细信息，数据存储。
CactiforWindows 网络流量监测图形分析工具 v1.2.15
11-25
为您提供CactiforWindows 网络流量监测图形分析工具下载，Cacti是一套基于PHP,MySQL,SNMP及RRDTool开发的网络流量监测图形分析工具。Cacti通过snmpget来获取数据，使用RRDtool绘画图形，而且你完全可以不需要了解RRDtool复杂的参数。Cacti提供了非常强大的数据和用户管理功能，可以指定每一个用户能查看树状结构、host以及任何一张图，还可以与LDAP结合进行用户验证，同时也能自己增加模板，功能非常强大完善，界面友好
10流量监控工具TCPDUMP
weixin_46686336的博客
04-03 1313
Linux作为网络服务器，特别是作为路由器和网关时，数据的采集和分析是不可少的。TcpDump是Linux中强大的网络数据采集分析工具之一。TCPDump（dump the traffic on a network），根据使用者的定义对网络上的数据包进行截获的包分析工具，支持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。基于数据包的五元组（源IP、目的IP、源端口、目的端口、协议）
系统状态监测命令
X_20150817的博客
09-16 122
系统状态监测命令 1.ifconfig命令：用于获取网卡配置与网络状态等信息。 格式：ifconfig [网卡名] [参数]。 2.uname命令：用于查看系统内核与系统版本等信息。 格式：uname [参数]。 uname -a #完整地查看系统内核与系统版本等信息 3.uptime命令：用于查看系统的负载信息。 4.free命令：用于显示当前系统中内存的使用量信息。 格式：free [参数]。 free -h #输出当前内存的实时使用量信息 5.who命令：用于查看当前登入主机的用户终端信息。 格式：w
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值