You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
725 lines
20 KiB
725 lines
20 KiB
/************************************************************************
|
|
|
|
Copyright (c) 2000 - 2000 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
netspeed.cpp
|
|
|
|
Abstract :
|
|
|
|
Main source file for throttle control.
|
|
|
|
Author :
|
|
|
|
Revision History :
|
|
|
|
|
|
---> for small files, we need to feed the file size in to the block calculator,
|
|
because the server-speed estimator will be incorrect if m_BlockSize is 65000
|
|
but the download time is based on a file size of 2002 bytes.
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include <malloc.h>
|
|
#include <limits.h>
|
|
|
|
#if !defined(BITS_V12_ON_NT4)
|
|
#include "netspeed.tmh"
|
|
#endif
|
|
|
|
//
|
|
// the maximum % of the perceived bandwidth that BITS will use for itself
|
|
//
|
|
const float MAX_BANDWIDTH_FRACTION = 0.95f;
|
|
|
|
//
|
|
// timer periods in seconds
|
|
//
|
|
const float DEFAULT_BLOCK_INTERVAL = 2.0f;
|
|
const float MIN_BLOCK_INTERVAL = 0.001f;
|
|
const float MAX_BLOCK_INTERVAL = 5.0f;
|
|
|
|
//
|
|
// observed header sizes. request = 250, reply = 300
|
|
//
|
|
#define REQUEST_OVERHEAD 550
|
|
|
|
//
|
|
// smallest block we will pull down
|
|
//
|
|
#define MIN_BLOCK_SIZE 2000
|
|
|
|
//
|
|
// size when we occasionally pull down a block on a full network
|
|
//
|
|
#define BUSY_BLOCK_SIZE 1500
|
|
|
|
//
|
|
// Very small blocks give unreliable speed measurements.
|
|
//
|
|
#define MIN_BLOCK_SIZE_TO_MEASURE 500
|
|
|
|
const NETWORK_RATE CNetworkInterface::DEFAULT_SPEED = 1600.0f;
|
|
|
|
// Work around limitations of the protocol stack
|
|
|
|
const DWORD MAX_BLOCK_SIZE = 2147483648;
|
|
|
|
//------------------------------------------------------------------------
|
|
|
|
//
|
|
// The observed server speed is reported as the average of this many usable samples.
|
|
//
|
|
const float SERVER_SPEED_SAMPLE_COUNT = 3.0F;
|
|
|
|
/*
|
|
|
|
The algorithm used to determine the speed and loading of the network is as follows:
|
|
|
|
1. After contacting the web site with Wininet calls, see whether an HTTP 1.1 "Via" header is present.
|
|
If so, a proxy was used, and we locate the proper net card to talk with the proxy. Otherwise,
|
|
a proxy was not used, and we locate the proper net card to talk with the HTTP server itself.
|
|
|
|
2. Chop time into 1/2-second intervals, and measure the interface's bytes-in and bytes-out count
|
|
three times per interval: first at the beginning, just before a block is downloaded, second at
|
|
the completion of the block, and third at the end of the interval.
|
|
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CNetworkInterface::TakeSnapshot(
|
|
int StatIndex
|
|
)
|
|
{
|
|
DWORD s;
|
|
ULONG size = 0;
|
|
|
|
//
|
|
// The network speed can be calculated only if all three snapshots succeeded.
|
|
// We keep track of the error status of the current series of snapshots.
|
|
//
|
|
if (StatIndex == BLOCK_START)
|
|
{
|
|
m_SnapshotError = S_OK;
|
|
m_SnapshotsValid = false;
|
|
}
|
|
|
|
m_TempRow.dwIndex = m_InterfaceIndex;
|
|
DWORD dwGetIfEntryError = GetIfEntry( &m_TempRow );
|
|
if ( dwGetIfEntryError )
|
|
{
|
|
LogWarning( "[%d] : GetIfRow(%d) failed %!winerr!", StatIndex, m_InterfaceIndex, dwGetIfEntryError );
|
|
m_SnapshotError = HRESULT_FROM_WIN32( dwGetIfEntryError );
|
|
return m_SnapshotError;
|
|
}
|
|
|
|
QueryPerformanceCounter( &m_Snapshots[ StatIndex ].TimeStamp );
|
|
|
|
m_Snapshots[ StatIndex ].BytesIn = m_TempRow.dwInOctets;
|
|
m_Snapshots[ StatIndex ].BytesOut = m_TempRow.dwOutOctets;
|
|
|
|
LogDl( "[%d] : in=%d, out=%d, timestamp=%d",
|
|
StatIndex,
|
|
m_Snapshots[ StatIndex ].BytesIn,
|
|
m_Snapshots[ StatIndex ].BytesOut,
|
|
m_Snapshots[ StatIndex ].TimeStamp.u.LowPart );
|
|
|
|
if (StatIndex == BLOCK_INTERVAL_END &&
|
|
m_SnapshotError == S_OK)
|
|
{
|
|
m_SnapshotsValid = true;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
float
|
|
CNetworkInterface::GetTimeDifference(
|
|
int start,
|
|
int finish
|
|
)
|
|
{
|
|
float TotalTime;
|
|
|
|
TotalTime = m_Snapshots[ finish ].TimeStamp.QuadPart - m_Snapshots[ start ].TimeStamp.QuadPart;
|
|
|
|
TotalTime /= g_GlobalInfo->m_PerformanceCounterFrequency.QuadPart; // convert to seconds
|
|
|
|
if (TotalTime <= 0)
|
|
{
|
|
// pretend it was half a tick.
|
|
TotalTime = 1 / float(2 * g_GlobalInfo->m_PerformanceCounterFrequency.QuadPart);
|
|
}
|
|
|
|
return TotalTime;
|
|
}
|
|
|
|
|
|
CNetworkInterface::CNetworkInterface()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
HRESULT
|
|
CNetworkInterface::SetInterfaceIndex(
|
|
const TCHAR host[]
|
|
)
|
|
{
|
|
DWORD index;
|
|
|
|
HRESULT Hr = FindInterfaceIndex( host, &index );
|
|
if (FAILED(Hr))
|
|
return Hr;
|
|
|
|
if (m_InterfaceIndex != index)
|
|
{
|
|
m_InterfaceIndex = index;
|
|
Reset();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void
|
|
CNetworkInterface::Reset()
|
|
{
|
|
m_ServerSpeed = DEFAULT_SPEED;
|
|
m_NetcardSpeed = DEFAULT_SPEED;
|
|
m_PercentFree = 0.5f;
|
|
|
|
m_SnapshotsValid = false;
|
|
m_SnapshotError = E_FAIL;
|
|
m_state = DOWNLOADED_BLOCK;
|
|
}
|
|
|
|
|
|
void
|
|
CNetworkInterface::SetInterfaceSpeed()
|
|
{
|
|
float TotalTime, ratio;
|
|
NETWORK_RATE rate = 0;
|
|
|
|
//
|
|
// Adjust server speed based on block download stats.
|
|
//
|
|
if (m_SnapshotsValid && m_BlockSize)
|
|
{
|
|
float ExpectedTime = m_BlockInterval * m_PercentFree;
|
|
|
|
//
|
|
// Calculate interface speed from the time the last block took.
|
|
//
|
|
TotalTime = GetTimeDifference( BLOCK_START, BLOCK_END );
|
|
|
|
if (ExpectedTime > 0)
|
|
{
|
|
ratio = ExpectedTime / TotalTime;
|
|
|
|
rate = m_ServerSpeed * ratio;
|
|
}
|
|
else
|
|
{
|
|
// either m_PercentFree was zero, or the interval was zero. The ordinary calculation
|
|
// would always produce a ratio of zero and drag down our average speed incorrectly.
|
|
|
|
// use strict bytes per second measure
|
|
rate = m_BlockSize / TotalTime;
|
|
if (rate < m_ServerSpeed)
|
|
{
|
|
rate = m_ServerSpeed;
|
|
}
|
|
}
|
|
|
|
m_ServerSpeed *= (SERVER_SPEED_SAMPLE_COUNT-1) / SERVER_SPEED_SAMPLE_COUNT;
|
|
m_ServerSpeed += (rate / SERVER_SPEED_SAMPLE_COUNT);
|
|
|
|
LogDl("expected interval %f, actual= %f, rate= %!netrate!, avg %!netrate!",
|
|
ExpectedTime, TotalTime, rate, m_ServerSpeed );
|
|
}
|
|
|
|
//
|
|
// Adjust usage and netcard speed based on interval stats.
|
|
//
|
|
if (m_SnapshotsValid)
|
|
{
|
|
float Bytes;
|
|
|
|
Bytes = m_Snapshots[ BLOCK_END ].BytesIn - m_Snapshots[ BLOCK_START ].BytesIn;
|
|
Bytes += m_Snapshots[ BLOCK_END ].BytesOut - m_Snapshots[ BLOCK_START ].BytesOut;
|
|
|
|
ASSERT( Bytes >= 0 );
|
|
|
|
TotalTime = GetTimeDifference( BLOCK_START, BLOCK_END );
|
|
|
|
rate = Bytes/TotalTime;
|
|
|
|
// use whichever estimate is larger
|
|
|
|
if (rate < m_ServerSpeed)
|
|
{
|
|
rate = m_ServerSpeed;
|
|
}
|
|
|
|
if (m_NetcardSpeed == 0)
|
|
{
|
|
m_NetcardSpeed = rate;
|
|
}
|
|
else
|
|
{
|
|
if (rate < m_NetcardSpeed * 0.9f)
|
|
{
|
|
//
|
|
// If the rate drops precipitously, it's probably just a quiet moment on the Net;
|
|
// a strict average would unduly lower our estimated throughput.
|
|
// But reduce the average a little in case it's a long-term slowdown. If so,
|
|
// eventually the average will be lowered enough that the incoming rates are greater
|
|
// than m_NetcardSpeed / 2.
|
|
//
|
|
rate = m_NetcardSpeed * 0.9f;
|
|
}
|
|
|
|
//
|
|
// Keep a running average of the perceived rate.
|
|
//
|
|
m_NetcardSpeed *= (SERVER_SPEED_SAMPLE_COUNT-1) / SERVER_SPEED_SAMPLE_COUNT;
|
|
m_NetcardSpeed += (rate / SERVER_SPEED_SAMPLE_COUNT);
|
|
}
|
|
|
|
LogDl("bandwidth: bytes %f, time %f, rate %f, avg. %f", Bytes, TotalTime, rate, m_NetcardSpeed);
|
|
|
|
//
|
|
// Subtract our usage from the calculated usage. Compare usage to top speed to get free bandwidth.
|
|
//
|
|
Bytes = m_Snapshots[ BLOCK_INTERVAL_END ].BytesIn - m_Snapshots[ BLOCK_START ].BytesIn;
|
|
Bytes += m_Snapshots[ BLOCK_INTERVAL_END ].BytesOut - m_Snapshots[ BLOCK_START ].BytesOut;
|
|
Bytes -= m_BlockSize;
|
|
|
|
if (Bytes < 0)
|
|
{
|
|
Bytes = 0;
|
|
}
|
|
|
|
TotalTime = GetTimeDifference( BLOCK_START, BLOCK_INTERVAL_END );
|
|
|
|
rate = Bytes/TotalTime;
|
|
|
|
m_PercentFree = 1 - (rate / m_NetcardSpeed);
|
|
}
|
|
|
|
LogDl("usage: %f / %f, percent free %f", rate, m_NetcardSpeed, m_PercentFree);
|
|
|
|
if (m_PercentFree < 0)
|
|
{
|
|
m_PercentFree = 0;
|
|
}
|
|
else if (m_PercentFree > MAX_BANDWIDTH_FRACTION) // never monopolize the net
|
|
{
|
|
m_PercentFree = MAX_BANDWIDTH_FRACTION;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
CNetworkInterface::BlockSizeFromInterval(
|
|
SECONDS interval
|
|
)
|
|
{
|
|
NETWORK_RATE FreeBandwidth = GetInterfaceSpeed() * GetPercentFree() * interval;
|
|
|
|
if (FreeBandwidth <= REQUEST_OVERHEAD)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return FreeBandwidth - REQUEST_OVERHEAD;
|
|
}
|
|
|
|
CNetworkInterface::SECONDS
|
|
CNetworkInterface::IntervalFromBlockSize(
|
|
DWORD BlockSize
|
|
)
|
|
{
|
|
NETWORK_RATE FreeBandwidth = GetInterfaceSpeed() * GetPercentFree();
|
|
|
|
BlockSize += REQUEST_OVERHEAD;
|
|
|
|
if (BlockSize / MAX_BLOCK_INTERVAL > FreeBandwidth )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return BlockSize / FreeBandwidth;
|
|
}
|
|
|
|
void
|
|
CNetworkInterface::CalculateIntervalAndBlockSize(
|
|
UINT64 MaxBlockSize
|
|
)
|
|
{
|
|
MaxBlockSize = min( MaxBlockSize, MAX_BLOCK_SIZE );
|
|
|
|
if (MaxBlockSize == 0)
|
|
{
|
|
m_BlockInterval = 0;
|
|
m_BlockSize = 0;
|
|
|
|
SetTimerInterval( m_BlockInterval );
|
|
LogDl( "block %d bytes, interval %f seconds", m_BlockSize, m_BlockInterval );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Calculate new block size from the average interface speed.
|
|
//
|
|
DWORD OldState = m_state;
|
|
|
|
m_BlockInterval = DEFAULT_BLOCK_INTERVAL;
|
|
m_BlockSize = BlockSizeFromInterval( m_BlockInterval );
|
|
|
|
if (m_BlockSize > MaxBlockSize)
|
|
{
|
|
m_BlockSize = MaxBlockSize;
|
|
m_BlockInterval = IntervalFromBlockSize( m_BlockSize );
|
|
|
|
ASSERT( m_BlockInterval > 0 );
|
|
}
|
|
else if (m_BlockSize < MIN_BLOCK_SIZE)
|
|
{
|
|
m_BlockSize = min( MIN_BLOCK_SIZE, MaxBlockSize );
|
|
m_BlockInterval = IntervalFromBlockSize( m_BlockSize );
|
|
}
|
|
|
|
if (m_BlockInterval < 0)
|
|
{
|
|
m_BlockSize = 0;
|
|
}
|
|
|
|
//
|
|
// choose the new block download state.
|
|
//
|
|
if (m_BlockSize > 0)
|
|
{
|
|
m_state = DOWNLOADED_BLOCK;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The first time m_BlockSize is set to zero, retain the default interval.
|
|
// If blocksize is zero twice in a row, expand to MAX_BLOCK_INTERVAL.
|
|
// Then force a small download.
|
|
//
|
|
switch (OldState)
|
|
{
|
|
case DOWNLOADED_BLOCK:
|
|
{
|
|
m_BlockInterval = DEFAULT_BLOCK_INTERVAL;
|
|
m_state = SKIPPED_ONE_BLOCK;
|
|
break;
|
|
}
|
|
|
|
case SKIPPED_ONE_BLOCK:
|
|
{
|
|
m_BlockInterval = MAX_BLOCK_INTERVAL;
|
|
m_state = SKIPPED_TWO_BLOCKS;
|
|
break;
|
|
}
|
|
|
|
case SKIPPED_TWO_BLOCKS:
|
|
{
|
|
m_BlockSize = min( BUSY_BLOCK_SIZE, MaxBlockSize);
|
|
m_BlockInterval = MAX_BLOCK_INTERVAL;
|
|
m_state = DOWNLOADED_BLOCK;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
ASSERT( 0 );
|
|
}
|
|
}
|
|
|
|
SetTimerInterval( m_BlockInterval );
|
|
|
|
LogDl( "block %d bytes, interval %f seconds", m_BlockSize, m_BlockInterval );
|
|
|
|
ASSERT( m_BlockSize <= MaxBlockSize );
|
|
}
|
|
|
|
BOOL
|
|
CNetworkInterface::SetTimerInterval(
|
|
SECONDS interval
|
|
)
|
|
{
|
|
DWORD msec = interval*1000;
|
|
|
|
if (msec <= 0)
|
|
{
|
|
msec = MIN_BLOCK_INTERVAL;
|
|
}
|
|
|
|
LogDl( "%d milliseconds", msec );
|
|
|
|
if (FALSE == m_Timer.Start( msec ))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HRESULT
|
|
CNetworkInterface::FindInterfaceIndex(
|
|
const TCHAR host[],
|
|
DWORD * pIndex
|
|
)
|
|
{
|
|
//related to finding statistics
|
|
/* Use GetBestInterface with some IP address to get the index. Double check that this index
|
|
* occurs in the output of the IP Address table and look it up in the results of GetIfTable.
|
|
*/
|
|
|
|
#define AOL_ADAPTER _T("AOL Adapter")
|
|
#define AOL_DIALUP_ADAPTER _T("AOL Dial-Up Adapter")
|
|
|
|
BOOL bFound = FALSE;
|
|
BOOL bAOL = FALSE;
|
|
|
|
unsigned i;
|
|
DWORD dwAddr;
|
|
|
|
ULONG HostAddress;
|
|
struct sockaddr_in dest;
|
|
|
|
DWORD dwIndex = -1;
|
|
static TCHAR szIntfName[512];
|
|
|
|
*pIndex = -1;
|
|
|
|
try
|
|
{
|
|
//
|
|
// Translate the host name into a SOCKADDR.
|
|
//
|
|
|
|
unsigned length = 3 * lstrlen(host);
|
|
|
|
CAutoStringA AsciiHost ( new char[ length ]);
|
|
|
|
if (! WideCharToMultiByte( CP_ACP,
|
|
0, // no flags
|
|
host,
|
|
-1, // use strlen
|
|
AsciiHost.get(),
|
|
length, // use strlen
|
|
NULL, // no default char
|
|
NULL // no default char
|
|
))
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
LogError( "Unicode conversion failed %!winerr!", dwError );
|
|
return HRESULT_FROM_WIN32( dwError );
|
|
}
|
|
|
|
HostAddress = inet_addr( AsciiHost.get() );
|
|
if (HostAddress == -1)
|
|
{
|
|
struct hostent *pHostEntry = gethostbyname( AsciiHost.get() );
|
|
|
|
if (pHostEntry == 0)
|
|
{
|
|
DWORD dwError = WSAGetLastError();
|
|
LogError( "failed to find host '%s': %!winerr!", AsciiHost.get(), dwError );
|
|
return HRESULT_FROM_WIN32( dwError );
|
|
}
|
|
|
|
if (pHostEntry->h_addr_list[0] == NULL)
|
|
{
|
|
DWORD dwError = WSANO_DATA;
|
|
LogError( "host address list empty '%s': %!winerr!", AsciiHost.get(), dwError );
|
|
return HRESULT_FROM_WIN32( dwError );
|
|
}
|
|
|
|
HostAddress = *PULONG(pHostEntry->h_addr_list[0]);
|
|
}
|
|
}
|
|
catch ( ComError err )
|
|
{
|
|
LogError( "exception 0x%x finding server IP address", err.Error() );
|
|
return err.Error();
|
|
}
|
|
|
|
//for remote addr
|
|
dest.sin_addr.s_addr = HostAddress;
|
|
dest.sin_family = AF_INET;
|
|
dest.sin_port = 80;
|
|
|
|
DWORD dwGetBestInterfaceError = GetBestInterface(dest.sin_addr.s_addr, &dwIndex);
|
|
|
|
if (dwGetBestInterfaceError != NO_ERROR)
|
|
{
|
|
LogError( "GetBestInterface failed with error %!winerr!, might be Win95", dwGetBestInterfaceError);
|
|
|
|
//manually parse the routing table
|
|
|
|
ULONG size = 0;
|
|
DWORD dwIpForwardError = GetIpForwardTable(NULL, &size, FALSE);
|
|
if (dwIpForwardError != ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
LogError( "sizing GetIpForwardTable failed %!winerr!", dwIpForwardError );
|
|
return HRESULT_FROM_WIN32( dwIpForwardError );
|
|
}
|
|
|
|
|
|
auto_ptr<MIB_IPFORWARDTABLE> pIpFwdTable((PMIB_IPFORWARDTABLE)new char[size]);
|
|
if ( !pIpFwdTable.get() )
|
|
{
|
|
LogError( "out of memory getting %d bytes", size);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
dwIpForwardError = GetIpForwardTable(pIpFwdTable.get(), &size, TRUE);
|
|
|
|
if (dwIpForwardError == NO_ERROR) //sort by dest addr
|
|
{
|
|
//perform bitwise AND of dest address with netmask and see if it matches network dest
|
|
//todo check for multiple matches and then take longest mask
|
|
for (i=0; i < pIpFwdTable->dwNumEntries; i++)
|
|
{
|
|
if ((dest.sin_addr.s_addr & pIpFwdTable->table[i].dwForwardMask) == pIpFwdTable->table[i].dwForwardDest)
|
|
{
|
|
dwIndex = pIpFwdTable->table[i].dwForwardIfIndex;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dwIndex == -1)
|
|
{
|
|
// no match
|
|
return HRESULT_FROM_WIN32( ERROR_NETWORK_UNREACHABLE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogError( "GetIpForwardTable failed with error %!winerr!, exiting", dwIpForwardError );
|
|
return HRESULT_FROM_WIN32( dwIpForwardError );
|
|
}
|
|
}
|
|
|
|
//
|
|
// At this point dwIndex should be correct.
|
|
//
|
|
ASSERT( dwIndex != -1 );
|
|
|
|
#if DBG
|
|
try
|
|
{
|
|
//
|
|
// Discover the local IP address for the correct interface.
|
|
//
|
|
ULONG size = 0;
|
|
DWORD dwGetIpAddr = GetIpAddrTable(NULL, &size, FALSE);
|
|
if (dwGetIpAddr != ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
LogError( "GetIpAddrTable #1 returned %!winerr!", dwGetIpAddr );
|
|
return HRESULT_FROM_WIN32( dwGetIpAddr );
|
|
}
|
|
|
|
auto_ptr<MIB_IPADDRTABLE> pAddrTable( (PMIB_IPADDRTABLE) new char[size] );
|
|
|
|
dwGetIpAddr = GetIpAddrTable(pAddrTable.get(), &size, TRUE);
|
|
if (dwGetIpAddr != NO_ERROR)
|
|
{
|
|
LogError( "GetIpAddrTable #2 returned %!winerr!", dwGetIpAddr );
|
|
return HRESULT_FROM_WIN32( dwGetIpAddr );
|
|
}
|
|
|
|
for (i=0; i < pAddrTable->dwNumEntries; i++)
|
|
{
|
|
if (dwIndex == pAddrTable->table[i].dwIndex)
|
|
{
|
|
in_addr address;
|
|
|
|
address.s_addr = pAddrTable->table[i].dwAddr;
|
|
|
|
LogDl( "Throttling on interface with IP address - %s", inet_ntoa( address ));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= pAddrTable->dwNumEntries)
|
|
{
|
|
LogWarning( "can't find interface with index %d in the IP address table", dwIndex );
|
|
}
|
|
}
|
|
catch ( ComError err )
|
|
{
|
|
LogWarning("unable to print the local IP address due to exception %x", err.Error() );
|
|
}
|
|
#endif // DBG
|
|
|
|
//
|
|
// See if the adapter in question is the AOL adapter. If so, use the AOL dial-up adapter instead.
|
|
//
|
|
|
|
static MIB_IFROW s_TempRow;
|
|
s_TempRow.dwIndex = dwIndex;
|
|
|
|
DWORD dwEntryError = GetIfEntry( &s_TempRow );
|
|
if ( NO_ERROR != dwEntryError )
|
|
{
|
|
LogError( "GetIfEntry(%d) returned %!winerr!", dwIndex, dwEntryError );
|
|
return HRESULT_FROM_WIN32( dwEntryError );
|
|
}
|
|
|
|
if (lstrcmp( LPCWSTR(s_TempRow.bDescr), AOL_ADAPTER) == 0)
|
|
{
|
|
LogWarning( "found AOL adapter, searching for dial-up adapter...");
|
|
|
|
dwIndex = -1;
|
|
|
|
ULONG size = 0;
|
|
DWORD dwGetIfTableError = GetIfTable( NULL, &size, FALSE );
|
|
|
|
if (dwGetIfTableError != ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
LogError( "GetIfTable #2 returned %!winerr!", dwGetIfTableError );
|
|
return HRESULT_FROM_WIN32( dwGetIfTableError );
|
|
}
|
|
|
|
auto_ptr<MIB_IFTABLE> pIfTable( (PMIB_IFTABLE) new char[size] );
|
|
if ( !pIfTable.get() )
|
|
{
|
|
LogError( "out of memory getting %d bytes", size);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
dwGetIfTableError = GetIfTable( pIfTable.get(), &size, FALSE );
|
|
if ( NO_ERROR != dwGetIfTableError )
|
|
{
|
|
LogError( "GetIfTable #2 returned %!winerr!", dwGetIfTableError );
|
|
return HRESULT_FROM_WIN32( dwGetIfTableError );
|
|
}
|
|
|
|
for (i=0; i < pIfTable->dwNumEntries; ++i)
|
|
{
|
|
if (lstrcmp( LPCWSTR(pIfTable->table[i].bDescr), AOL_DIALUP_ADAPTER) == 0)
|
|
{
|
|
dwIndex = pIfTable->table[i].dwIndex;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ASSERT( dwIndex != -1 );
|
|
|
|
*pIndex = dwIndex;
|
|
|
|
LogDl( "using interface index %d", dwIndex );
|
|
return S_OK;
|
|
}
|
|
|