📄 如何得到拨号网络传输速度.htm

📁 adsl拨号工具有很多功能不错啊大家试试
💻 HTM
字号:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- saved from url=(0063)http://www.chinaoak.com/download/material/network/DialSpeed.htm -->
<!-- saved from url=(0048)http://myhomeland.home.sohu.com/vc/ras_speed.htm --><HTML><HEAD><TITLE>如何得到拨号网络传输速度</TITLE>
<META content="text/html; charset=gb_2312-80" http-equiv=Content-Type>
<META content="MSHTML 5.00.3700.6699" name=GENERATOR></HEAD>
<BODY bgColor=#ffffff>
<TABLE align=center cellPadding=0 cellSpacing=0 width=600><!--整体框架-->
  <TBODY>
  <TR>
    <TD>
      <TABLE border=0 cellPadding=2 cellSpacing=0 width="100%"><!--标记放置区域-->
        <TBODY>
        <TR bgColor=#cccccc>
          <TD align=middle>
            <P><FONT color=white><FONT 
            color=white>如何得到拨号网络传输速度<BR>闻怡洋</FONT></FONT></P>
            <P align=left>这段时间很多朋友都写邮件问我如何得到拨号上网时的网络速度，下面的代码是在我的软件<A 
            href="http://www.vchelp.net/soft/dial_monitor/index.htm">Dial 
            Monitor</A>中节选出来的相关程序片。 </P>
            <P align=left>H文件：rasSpdM.h 
            <DIV align=left><PRE>#ifndef __RASSPDMON_H_
#define __RASSPDMON_H_

void InitSpeedMonitor(void);
void ClearSpeedMonitor(void);
void GetRASSpeed(DWORD* pTPS,DWORD* pRPS,DWORD* pTT,DWORD* pRT);
////参数：每秒发送，每秒接收，总发送，总接受


#endif
</PRE></DIV>
            <P align=left>CPP文件rasSpdM.cpp</P>
            <DIV align=left><PRE>#include "stdafx.h"
#include "rasSpdM.h"


#include <WINPERF.H>

#define TOTALBYTES    4096
#define BYTEINCREMENT 1024

LPSTR lpNameStrings=NULL;
LPSTR *lpNamesArray=NULL;
BOOL glo_fFromDynReg=TRUE;

/*
在9x下通过dyn_data注册表得到速度
*/
DWORD GetTotalRecv(void)
{
	HKEY hKey;
	DWORD dwValue=(DWORD)-1;
	if(0==RegOpenKey(HKEY_DYN_DATA,"PerfStats\\StatData",&amp;hKey))
	{
		DWORD dwType,dwLen=sizeof(DWORD);
		RegQueryValueEx(hKey,"Dial-Up Adapter\\TotalBytesRecvd",NULL,&amp;dwType,(BYTE*)&amp;dwValue,&amp;dwLen);
		RegCloseKey(hKey);
	}
	return dwValue;
}
DWORD GetTotalXmit(void)
{
	HKEY hKey;
	DWORD dwValue=(DWORD)-1;
	if(0==RegOpenKey(HKEY_DYN_DATA,"PerfStats\\StatData",&amp;hKey))
	{
		DWORD dwType,dwLen=sizeof(DWORD);
		RegQueryValueEx(hKey,"Dial-Up Adapter\\TotalBytesXmit",NULL,&amp;dwType,(BYTE*)&amp;dwValue,&amp;dwLen);
		RegCloseKey(hKey);
	}
	return dwValue;
}
DWORD GetPerSecondRecv(void)
{
	HKEY hKey;
	DWORD dwValue=(DWORD)-1;
	if(0==RegOpenKey(HKEY_DYN_DATA,"PerfStats\\StatData",&amp;hKey))
	{
		DWORD dwType,dwLen=sizeof(DWORD);
		RegQueryValueEx(hKey,"Dial-Up Adapter\\BytesRecvd",NULL,&amp;dwType,(BYTE*)&amp;dwValue,&amp;dwLen);
		RegCloseKey(hKey);
	}
	return dwValue;
}
DWORD GetPerSecondXmit(void)
{
	HKEY hKey;
	DWORD dwValue=(DWORD)-1;
	if(0==RegOpenKey(HKEY_DYN_DATA,"PerfStats\\StatData",&amp;hKey))
	{
		DWORD dwType,dwLen=sizeof(DWORD);
		RegQueryValueEx(hKey,"Dial-Up Adapter\\BytesXmit",NULL,&amp;dwType,(BYTE*)&amp;dwValue,&amp;dwLen);
		RegCloseKey(hKey);
	}
	return dwValue;
}

/*****************************************************************
在NT下通过per Data得到
 *****************************************************************/

PPERF_OBJECT_TYPE FirstObject( PPERF_DATA_BLOCK PerfData )
{
    return( (PPERF_OBJECT_TYPE)((PBYTE)PerfData + 
        PerfData-&gt;HeaderLength) );
}

PPERF_OBJECT_TYPE NextObject( PPERF_OBJECT_TYPE PerfObj )
{
    return( (PPERF_OBJECT_TYPE)((PBYTE)PerfObj + 
        PerfObj-&gt;TotalByteLength) );
}

PPERF_INSTANCE_DEFINITION FirstInstance( PPERF_OBJECT_TYPE PerfObj )
{
    return( (PPERF_INSTANCE_DEFINITION)((PBYTE)PerfObj + 
        PerfObj-&gt;DefinitionLength) );
}

PPERF_INSTANCE_DEFINITION NextInstance( 
    PPERF_INSTANCE_DEFINITION PerfInst )
{
    PPERF_COUNTER_BLOCK PerfCntrBlk;

    PerfCntrBlk = (PPERF_COUNTER_BLOCK)((PBYTE)PerfInst + 
        PerfInst-&gt;ByteLength);

    return( (PPERF_INSTANCE_DEFINITION)((PBYTE)PerfCntrBlk + 
        PerfCntrBlk-&gt;ByteLength) );
}

PPERF_COUNTER_DEFINITION FirstCounter( PPERF_OBJECT_TYPE PerfObj )
{
    return( (PPERF_COUNTER_DEFINITION) ((PBYTE)PerfObj + 
        PerfObj-&gt;HeaderLength) );
}

PPERF_COUNTER_DEFINITION NextCounter( 
    PPERF_COUNTER_DEFINITION PerfCntr )
{
    return( (PPERF_COUNTER_DEFINITION)((PBYTE)PerfCntr + 
        PerfCntr-&gt;ByteLength) );
}

/*****************************************************************
 *                                                               *
 * Load the counter and object names from the registry to the    *
 * global variable lpNamesArray.                                 *
 *                                                               *
 *****************************************************************/

void GetNameStrings( )
{
    HKEY hKeyPerflib;      // handle to registry key
    HKEY hKeyPerflib009;   // handle to registry key
    DWORD dwMaxValueLen;   // maximum size of key values
    DWORD dwBuffer;        // bytes to allocate for buffers
    DWORD dwBufferSize;    // size of dwBuffer
    LPSTR lpCurrentString; // pointer for enumerating data strings
    DWORD dwCounter;       // current counter index

// Get the number of Counter items.

    RegOpenKeyEx( HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib",
        0,
        KEY_READ,
        &amp;hKeyPerflib);

    dwBufferSize = sizeof(dwBuffer);

    RegQueryValueEx( hKeyPerflib,
        "Last Counter",
        NULL,
        NULL,
        (LPBYTE) &amp;dwBuffer,
        &amp;dwBufferSize );

    RegCloseKey( hKeyPerflib );

// Allocate memory for the names array.

    lpNamesArray = (char**)malloc( (dwBuffer+1) * sizeof(LPSTR) );
// Open key containing counter and object names.

    RegOpenKeyEx( HKEY_LOCAL_MACHINE,
    "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib\\009",
        0,
        KEY_READ,
        &amp;hKeyPerflib009);

// Get the size of the largest value in the key (Counter or Help).

    RegQueryInfoKey( hKeyPerflib009,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        &amp;dwMaxValueLen,
        NULL,
        NULL);

// Allocate memory for the counter and object names.

    dwBuffer = dwMaxValueLen + 1;

    lpNameStrings = (char*)malloc( dwBuffer * sizeof(CHAR) );

// Read Counter value.

    RegQueryValueEx( hKeyPerflib009,
        "Counter",
        NULL,
        NULL,
        (BYTE*)lpNameStrings, &amp;dwBuffer );

// Load names into an array, by index.

    int iC=1;
	for( lpCurrentString = lpNameStrings; *lpCurrentString;
         lpCurrentString += (lstrlen(lpCurrentString)+1) )
    {
        dwCounter = atol( lpCurrentString );
        lpCurrentString += (lstrlen(lpCurrentString)+1);

		//printf("%d length=%d data=%s\n",iC++,dwCounter,lpCurrentString);
        lpNamesArray[dwCounter] = (LPSTR) lpCurrentString;
    }
}

/*****************************************************************
得到下RAS速度
 *****************************************************************/
void GetRASSpeedOn9X(DWORD* pTPS,DWORD* pRPS,DWORD* pTT,DWORD* pRT)
{// under 9x
	*pTPS=GetPerSecondXmit();
	*pRPS=GetPerSecondRecv();
	*pTT=GetTotalXmit();
	*pRT=GetTotalRecv();
}

void GetRASSpeedOnNT(DWORD* pTPS,DWORD* pRPS,DWORD* pTT,DWORD* pRT)
{// under NT
////参数：每秒发送，每秒接收，总发送，总接受
    PPERF_DATA_BLOCK PerfData = NULL;
    PPERF_OBJECT_TYPE PerfObj;
    PPERF_INSTANCE_DEFINITION PerfInst;
    PPERF_COUNTER_DEFINITION PerfCntr, CurCntr;
    PPERF_COUNTER_BLOCK PtrToCntr;
    DWORD BufferSize = TOTALBYTES;
    DWORD i, j, k;

// Get the name strings through the registry.

	//return;
// Allocate the buffer for the performance data.

    PerfData = (PPERF_DATA_BLOCK) malloc( BufferSize );

    while( RegQueryValueEx( HKEY_PERFORMANCE_DATA,
                               "906",//"Global",
                               NULL,
                               NULL,
                               (LPBYTE) PerfData,
                               &amp;BufferSize ) == ERROR_MORE_DATA )
    {
    // Get a buffer that is big enough.

        BufferSize += BYTEINCREMENT;
        PerfData = (PPERF_DATA_BLOCK) realloc( PerfData, BufferSize );
    }

// Get the first object type.

    PerfObj = FirstObject( PerfData );

// Process all objects.

    //printf("object total=%d\n",PerfData-&gt;NumObjectTypes);
	//getchar();
	for( i=0; i &lt; PerfData-&gt;NumObjectTypes; i++ )
    {
    // Display the object by index and name.

    // Get the first counter.

        PerfCntr = FirstCounter( PerfObj );

        if( PerfObj-&gt;NumInstances &gt; 0 )
        {
			//exit(0);
        }
        else
        {
        // Get the counter block.
            PtrToCntr = (PPERF_COUNTER_BLOCK) ((PBYTE)PerfObj +
                            PerfObj-&gt;DefinitionLength );

        // Retrieve all counters.

            for( j=0; j &lt; PerfObj-&gt;NumCounters; j++ )
            {
            // Display the counter by index and name.

               
		if(strcmp("Bytes Transmitted/Sec",lpNamesArray[PerfCntr-&gt;CounterNameTitleIndex])==0)
		{
			*pTPS=*((DWORD*)((BYTE*)PtrToCntr+PerfCntr-&gt;CounterOffset));
		}
		if(strcmp("Bytes Received/Sec",lpNamesArray[PerfCntr-&gt;CounterNameTitleIndex])==0)
		{
			*pRPS=*((DWORD*)((BYTE*)PtrToCntr+PerfCntr-&gt;CounterOffset));
		}
                if(strcmp("Bytes Transmitted",lpNamesArray[PerfCntr-&gt;CounterNameTitleIndex])==0)
		{
			*pTT=*((DWORD*)((BYTE*)PtrToCntr+PerfCntr-&gt;CounterOffset));
		}
                if(strcmp("Bytes Received",lpNamesArray[PerfCntr-&gt;CounterNameTitleIndex])==0)
		{
			*pRT=*((DWORD*)((BYTE*)PtrToCntr+PerfCntr-&gt;CounterOffset));
		}
		// Get the next counter.
		PerfCntr = NextCounter( PerfCntr );
		}
	}

    // Get the next object type.
        PerfObj = NextObject( PerfObj );
    }
}

void GetRASSpeed(DWORD* pTPS,DWORD* pRPS,DWORD* pTT,DWORD* pRT)
{////参数：每秒发送，每秒接收，总发送，总接受
	if(glo_fFromDynReg==FALSE)
	{
		GetRASSpeedOnNT(pTPS,pRPS, pTT,pRT);
	}
	else
	{
		GetRASSpeedOn9X(pTPS,pRPS, pTT,pRT);
	}
}

void InitSpeedMonitor(void)
{
	DWORD dwVersion = GetVersion();
	// Get major and minor version numbers of Windows
	DWORD dwWindowsMajorVersion =  (DWORD)(LOBYTE(LOWORD(dwVersion)));
	DWORD dwWindowsMinorVersion =  (DWORD)(HIBYTE(LOWORD(dwVersion)));
	// Get build numbers for Windows NT or Win32s
	if (dwVersion&gt;&gt;31 ==0)                // Windows NT
	{
		glo_fFromDynReg=FALSE;
		GetNameStrings( );
	}
	else         // Windows 95 - 98
		glo_fFromDynReg=TRUE;
}
void ClearSpeedMonitor(void)
{
	if(lpNameStrings)
		free(lpNameStrings);
	if(lpNamesArray)
		free(lpNamesArray);
}</PRE></DIV>
            <P align=left>使用方法：</P>
            <DIV align=left><PRE>#include "rasSpdM.h"
BOOL CYourApp::InitInstance()
{
	//初始化RAS速度访问
	InitSpeedMonitor();

...
}


#include "rasSpdM.h"
void CYourWnd::OnTimer(UINT nIDEvent) 
{
	DWORD dwR,dwS,dwPSR,dwPSS;//总接收，总发送，每秒接收，每秒发送
	GetRASSpeed(&amp;dwPSS,&amp;dwPSR,&amp;dwS,&amp;dwR);//pTPS,DWORD* pRPS,DWORD* pTT,DWORD* pRT)
	//参数：每秒发送，每秒接收，总发送，总接收
...
}</PRE></DIV>
            <P 
            align=left>但我在使用过程中发现每秒发送，每秒接收这两个结果并不十分正确，所以我是采用总数相减的方式来计算每秒速度的。</P></TD></TR></TBODY></TABLE>
      <TABLE border=0 cellPadding=0 cellSpacing=0 width="100%">
        <TBODY>
        <TR>
          <TD>&nbsp;</TD><!--end--></TR></TBODY></TABLE></TD></TR></TBODY></TABLE></BODY></HTML>
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -