2009-02-10 18:37:48 +00:00
|
|
|
/*
|
|
|
|
Copyright (C) 2001 Kimmo Pekkola
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU General Public License
|
|
|
|
as published by the Free Software Foundation; either version 2
|
|
|
|
of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
2012-01-23 06:36:15 +00:00
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
2009-02-10 18:37:48 +00:00
|
|
|
*/
|
|
|
|
|
2009-10-07 16:45:14 +00:00
|
|
|
#include "StdAfx.h"
|
2009-02-10 18:37:48 +00:00
|
|
|
#include "MeasureNet.h"
|
|
|
|
#include "Rainmeter.h"
|
2010-09-11 19:39:45 +00:00
|
|
|
#include "System.h"
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-08-01 21:05:56 +00:00
|
|
|
BYTE* CMeasureNet::c_Table = NULL;
|
|
|
|
UINT CMeasureNet::c_NumOfTables = 0;
|
2011-08-02 01:20:05 +00:00
|
|
|
std::vector<ULONG64> CMeasureNet::c_StatValues;
|
|
|
|
std::vector<ULONG64> CMeasureNet::c_OldStatValues;
|
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
FPGETIFTABLE2 CMeasureNet::c_GetIfTable2 = NULL;
|
2011-08-02 01:20:05 +00:00
|
|
|
FPFREEMIBTABLE CMeasureNet::c_FreeMibTable = NULL;
|
2009-02-10 18:37:48 +00:00
|
|
|
|
|
|
|
extern CRainmeter* Rainmeter;
|
|
|
|
|
|
|
|
/*
|
|
|
|
** CMeasureNet
|
|
|
|
**
|
2011-03-29 19:21:57 +00:00
|
|
|
** The constructor. This is the base class for the net-meters.
|
2009-02-10 18:37:48 +00:00
|
|
|
**
|
|
|
|
*/
|
2011-02-15 16:26:54 +00:00
|
|
|
CMeasureNet::CMeasureNet(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
|
2011-01-29 00:11:01 +00:00
|
|
|
m_CurrentTraffic(),
|
|
|
|
m_TrafficValue(),
|
|
|
|
m_Interface(),
|
|
|
|
m_Cumulative(false)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** ~CMeasureNet
|
|
|
|
**
|
|
|
|
** The destructor
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
CMeasureNet::~CMeasureNet()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Update
|
|
|
|
**
|
|
|
|
** Checks if Action should be executed.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
bool CMeasureNet::Update()
|
|
|
|
{
|
|
|
|
if (!CMeasure::PreUpdate()) return false;
|
|
|
|
|
|
|
|
if (m_MeterWindow)
|
|
|
|
{
|
|
|
|
if (!m_TrafficAction.empty())
|
|
|
|
{
|
|
|
|
if (m_CurrentTraffic > m_TrafficValue)
|
|
|
|
{
|
|
|
|
m_CurrentTraffic = 0;
|
|
|
|
Rainmeter->ExecuteCommand(m_TrafficAction.c_str(), m_MeterWindow);
|
|
|
|
}
|
|
|
|
|
|
|
|
m_CurrentTraffic += m_Value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return PostUpdate();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** UpdateIFTable
|
|
|
|
**
|
|
|
|
** Reads the tables for all net interfaces
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void CMeasureNet::UpdateIFTable()
|
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
bool logging = false;
|
2011-08-01 21:05:56 +00:00
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_GetIfTable2)
|
2011-08-02 01:20:05 +00:00
|
|
|
{
|
|
|
|
if (c_Table)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
c_FreeMibTable(c_Table);
|
|
|
|
c_Table = NULL;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_GetIfTable2((MIB_IF_TABLE2**)&c_Table) == NO_ERROR)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
MIB_IF_TABLE2* ifTable = (MIB_IF_TABLE2*)c_Table;
|
|
|
|
|
|
|
|
if (c_NumOfTables != ifTable->NumEntries)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
c_NumOfTables = ifTable->NumEntries;
|
|
|
|
logging = true;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-09-28 18:28:35 +00:00
|
|
|
if (Rainmeter->GetDebug() && logging)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
Log(LOG_DEBUG, L"------------------------------");
|
|
|
|
LogWithArgs(LOG_DEBUG, L"* NETWORK-INTERFACE: Count=%i", c_NumOfTables);
|
2010-02-13 03:07:34 +00:00
|
|
|
|
2011-08-02 01:20:05 +00:00
|
|
|
for (size_t i = 0; i < c_NumOfTables; ++i)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
std::wstring type;
|
|
|
|
switch (ifTable->Table[i].Type)
|
|
|
|
{
|
|
|
|
case IF_TYPE_ETHERNET_CSMACD:
|
|
|
|
type += L"Ethernet";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_PPP:
|
|
|
|
type += L"PPP";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_SOFTWARE_LOOPBACK:
|
|
|
|
type += L"Loopback";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_IEEE80211:
|
|
|
|
type += L"IEEE802.11";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_TUNNEL:
|
|
|
|
type += L"Tunnel";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_IEEE1394:
|
|
|
|
type += L"IEEE1394";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
type += L"Other";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
LogWithArgs(LOG_DEBUG, L"%i: %s", (int)i + 1, ifTable->Table[i].Description);
|
|
|
|
LogWithArgs(LOG_DEBUG, L" Alias: %s", ifTable->Table[i].Alias);
|
|
|
|
LogWithArgs(LOG_DEBUG, L" Type=%s(%i), Hardware=%s, Filter=%s",
|
|
|
|
type.c_str(), ifTable->Table[i].Type,
|
|
|
|
(ifTable->Table[i].InterfaceAndOperStatusFlags.HardwareInterface == 1) ? L"Yes" : L"No",
|
|
|
|
(ifTable->Table[i].InterfaceAndOperStatusFlags.FilterInterface == 1) ? L"Yes" : L"No");
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
2011-08-02 01:20:05 +00:00
|
|
|
Log(LOG_DEBUG, L"------------------------------");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Something's wrong. Unable to get the table.
|
|
|
|
c_Table = NULL;
|
|
|
|
c_NumOfTables = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (c_Table == NULL)
|
|
|
|
{
|
|
|
|
// Gotta reserve few bytes for the tables
|
|
|
|
DWORD value = 0;
|
|
|
|
if (GetNumberOfInterfaces(&value) == NO_ERROR)
|
|
|
|
{
|
|
|
|
if (c_NumOfTables != value)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
c_NumOfTables = value;
|
|
|
|
logging = true;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
|
2011-08-02 01:20:05 +00:00
|
|
|
if (c_NumOfTables > 0)
|
|
|
|
{
|
|
|
|
DWORD size = sizeof(MIB_IFTABLE) + sizeof(MIB_IFROW) * c_NumOfTables;
|
|
|
|
c_Table = new BYTE[size];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c_Table)
|
|
|
|
{
|
|
|
|
DWORD ret, size = 0;
|
|
|
|
|
|
|
|
MIB_IFTABLE* ifTable = (MIB_IFTABLE*)c_Table;
|
|
|
|
|
|
|
|
if ((ret = GetIfTable(ifTable, &size, FALSE)) == ERROR_INSUFFICIENT_BUFFER)
|
|
|
|
{
|
|
|
|
delete [] c_Table;
|
|
|
|
c_Table = new BYTE[size];
|
|
|
|
|
|
|
|
ifTable = (MIB_IFTABLE*)c_Table;
|
|
|
|
|
|
|
|
ret = GetIfTable(ifTable, &size, FALSE);
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
|
2011-08-02 01:20:05 +00:00
|
|
|
if (ret == NO_ERROR)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
if (c_NumOfTables != ifTable->dwNumEntries)
|
|
|
|
{
|
|
|
|
c_NumOfTables = ifTable->dwNumEntries;
|
|
|
|
logging = true;
|
|
|
|
}
|
2010-02-13 03:07:34 +00:00
|
|
|
|
2011-09-28 18:28:35 +00:00
|
|
|
if (Rainmeter->GetDebug() && logging)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
Log(LOG_DEBUG, L"------------------------------");
|
|
|
|
LogWithArgs(LOG_DEBUG, L"* NETWORK-INTERFACE: Count=%i", c_NumOfTables);
|
|
|
|
|
|
|
|
for (size_t i = 0; i < c_NumOfTables; ++i)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
std::string desc((char*)ifTable->table[i].bDescr, ifTable->table[i].dwDescrLen);
|
|
|
|
|
2010-02-13 03:07:34 +00:00
|
|
|
std::wstring type;
|
2011-08-02 01:20:05 +00:00
|
|
|
switch (ifTable->table[i].dwType)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
|
|
|
case IF_TYPE_ETHERNET_CSMACD:
|
|
|
|
type += L"Ethernet";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_PPP:
|
|
|
|
type += L"PPP";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_SOFTWARE_LOOPBACK:
|
|
|
|
type += L"Loopback";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_IEEE80211:
|
|
|
|
type += L"IEEE802.11";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_TUNNEL:
|
|
|
|
type += L"Tunnel";
|
|
|
|
break;
|
|
|
|
case IF_TYPE_IEEE1394:
|
|
|
|
type += L"IEEE1394";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
type += L"Other";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-08-02 01:20:05 +00:00
|
|
|
LogWithArgs(LOG_DEBUG, L"%i: %s", (int)i + 1, ConvertToWide(desc.c_str()).c_str());
|
|
|
|
LogWithArgs(LOG_DEBUG, L" Type=%s(%i)",
|
|
|
|
type.c_str(), ifTable->table[i].dwType);
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
2011-08-02 01:20:05 +00:00
|
|
|
Log(LOG_DEBUG, L"------------------------------");
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
2011-08-01 21:05:56 +00:00
|
|
|
}
|
2011-08-02 01:20:05 +00:00
|
|
|
else
|
2011-08-01 21:05:56 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
// Something's wrong. Unable to get the table.
|
|
|
|
delete [] c_Table;
|
|
|
|
c_Table = NULL;
|
|
|
|
c_NumOfTables = 0;
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** GetNetOctets
|
|
|
|
**
|
|
|
|
** Reads the amount of octets. This is the same for in, out and total.
|
|
|
|
** the net-parameter informs which inherited class called this method.
|
|
|
|
**
|
|
|
|
*/
|
2010-02-13 03:07:34 +00:00
|
|
|
ULONG64 CMeasureNet::GetNetOctets(NET net)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
ULONG64 value = 0;
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_GetIfTable2)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
MIB_IF_ROW2* table = (MIB_IF_ROW2*)((MIB_IF_TABLE2*)c_Table)->Table;
|
2010-02-13 03:07:34 +00:00
|
|
|
|
|
|
|
if (m_Interface == 0)
|
|
|
|
{
|
|
|
|
// Get all interfaces
|
2010-03-30 22:37:05 +00:00
|
|
|
for (UINT i = 0; i < c_NumOfTables; ++i)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
// Ignore the loopback and filter interfaces
|
|
|
|
if (table[i].Type == IF_TYPE_SOFTWARE_LOOPBACK ||
|
|
|
|
table[i].InterfaceAndOperStatusFlags.FilterInterface == 1) continue;
|
2010-02-13 03:07:34 +00:00
|
|
|
|
|
|
|
switch (net)
|
|
|
|
{
|
|
|
|
case NET_IN:
|
|
|
|
value += table[i].InOctets;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_OUT:
|
|
|
|
value += table[i].OutOctets;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_TOTAL:
|
|
|
|
value += table[i].InOctets;
|
|
|
|
value += table[i].OutOctets;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
// Get the selected interface
|
|
|
|
if (m_Interface <= c_NumOfTables)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
|
|
|
switch (net)
|
|
|
|
{
|
|
|
|
case NET_IN:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += table[m_Interface - 1].InOctets;
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_OUT:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += table[m_Interface - 1].OutOctets;
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_TOTAL:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += table[m_Interface - 1].InOctets;
|
|
|
|
value += table[m_Interface - 1].OutOctets;
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
MIB_IFROW* table = (MIB_IFROW*)((MIB_IFTABLE*)c_Table)->table;
|
2010-02-13 03:07:34 +00:00
|
|
|
|
|
|
|
if (m_Interface == 0)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
// Get all interfaces
|
2010-03-30 22:37:05 +00:00
|
|
|
for (UINT i = 0; i < c_NumOfTables; ++i)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
// Ignore the loopback
|
2010-02-13 03:07:34 +00:00
|
|
|
if (table[i].dwType == IF_TYPE_SOFTWARE_LOOPBACK) continue;
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2010-02-13 03:07:34 +00:00
|
|
|
switch (net)
|
|
|
|
{
|
|
|
|
case NET_IN:
|
|
|
|
value += table[i].dwInOctets;
|
|
|
|
break;
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2010-02-13 03:07:34 +00:00
|
|
|
case NET_OUT:
|
|
|
|
value += table[i].dwOutOctets;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_TOTAL:
|
|
|
|
value += table[i].dwInOctets;
|
|
|
|
value += table[i].dwOutOctets;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Get the selected interface
|
|
|
|
if (m_Interface <= c_NumOfTables)
|
|
|
|
{
|
|
|
|
switch (net)
|
|
|
|
{
|
|
|
|
case NET_IN:
|
|
|
|
value += table[m_Interface - 1].dwInOctets;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_OUT:
|
|
|
|
value += table[m_Interface - 1].dwOutOctets;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_TOTAL:
|
|
|
|
value += table[m_Interface - 1].dwInOctets;
|
|
|
|
value += table[m_Interface - 1].dwOutOctets;
|
|
|
|
break;
|
|
|
|
}
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** GetNetStatsValue
|
|
|
|
**
|
|
|
|
** Returns the stats value of the interface
|
|
|
|
**
|
|
|
|
*/
|
2010-02-13 03:07:34 +00:00
|
|
|
ULONG64 CMeasureNet::GetNetStatsValue(NET net)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
ULONG64 value = 0;
|
2011-02-15 13:22:19 +00:00
|
|
|
size_t statsSize = c_StatValues.size() / 2;
|
2009-02-10 18:37:48 +00:00
|
|
|
|
|
|
|
if (m_Interface == 0)
|
|
|
|
{
|
|
|
|
// Get all interfaces
|
2011-03-29 19:21:57 +00:00
|
|
|
for (size_t i = 0; i < statsSize; ++i)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
// Ignore the loopback and filter interfaces
|
2011-02-15 13:22:19 +00:00
|
|
|
if (c_NumOfTables == statsSize)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_GetIfTable2)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
if (((MIB_IF_TABLE2*)c_Table)->Table[i].Type == IF_TYPE_SOFTWARE_LOOPBACK ||
|
|
|
|
((MIB_IF_TABLE2*)c_Table)->Table[i].InterfaceAndOperStatusFlags.FilterInterface == 1) continue;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
if (((MIB_IFTABLE*)c_Table)->table[i].dwType == IF_TYPE_SOFTWARE_LOOPBACK) continue;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-10 18:37:48 +00:00
|
|
|
switch (net)
|
|
|
|
{
|
|
|
|
case NET_IN:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += c_StatValues[i * 2 + 0];
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_OUT:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += c_StatValues[i * 2 + 1];
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_TOTAL:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += c_StatValues[i * 2 + 0];
|
|
|
|
value += c_StatValues[i * 2 + 1];
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Get the selected interface
|
2011-02-15 13:22:19 +00:00
|
|
|
if (m_Interface <= statsSize)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
|
|
|
switch (net)
|
|
|
|
{
|
|
|
|
case NET_IN:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += c_StatValues[(m_Interface - 1) * 2 + 0];
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_OUT:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += c_StatValues[(m_Interface - 1) * 2 + 1];
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_TOTAL:
|
2010-02-13 03:07:34 +00:00
|
|
|
value += c_StatValues[(m_Interface - 1) * 2 + 0];
|
|
|
|
value += c_StatValues[(m_Interface - 1) * 2 + 1];
|
2009-02-10 18:37:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** ReadConfig
|
|
|
|
**
|
|
|
|
** Reads the measure specific configs. This is the same for in, out and total.
|
|
|
|
** the net-parameter informs which inherited class called this method.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void CMeasureNet::ReadConfig(CConfigParser& parser, const WCHAR* section, NET net)
|
|
|
|
{
|
|
|
|
double value;
|
|
|
|
const WCHAR* netName = NULL;
|
|
|
|
|
|
|
|
if (net == NET_IN)
|
|
|
|
{
|
|
|
|
netName = L"NetInSpeed";
|
2011-09-28 18:28:35 +00:00
|
|
|
value = Rainmeter->GetGlobalConfig().netInSpeed;
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
else if (net == NET_OUT)
|
|
|
|
{
|
|
|
|
netName = L"NetOutSpeed";
|
2011-09-28 18:28:35 +00:00
|
|
|
value = Rainmeter->GetGlobalConfig().netOutSpeed;
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
netName = L"NetTotalSpeed";
|
2011-09-28 18:28:35 +00:00
|
|
|
value = Rainmeter->GetGlobalConfig().netInSpeed + Rainmeter->GetGlobalConfig().netOutSpeed;
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
double maxValue = parser.ReadFloat(section, L"MaxValue", -1);
|
2011-03-29 19:21:57 +00:00
|
|
|
if (maxValue == -1)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
|
|
|
maxValue = parser.ReadFloat(section, netName, -1);
|
2011-03-29 19:21:57 +00:00
|
|
|
if (maxValue == -1)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
|
|
|
maxValue = value;
|
|
|
|
}
|
|
|
|
}
|
2011-03-29 19:21:57 +00:00
|
|
|
|
2009-02-10 18:37:48 +00:00
|
|
|
m_Interface = parser.ReadInt(section, L"Interface", 0);
|
2012-01-28 19:55:38 +00:00
|
|
|
|
2009-02-10 18:37:48 +00:00
|
|
|
m_Cumulative = 0!=parser.ReadInt(section, L"Cumulative", 0);
|
2012-01-28 19:55:38 +00:00
|
|
|
if (m_Cumulative)
|
|
|
|
{
|
|
|
|
CSystem::SetNetworkStatisticsTimer();
|
|
|
|
}
|
2009-02-10 18:37:48 +00:00
|
|
|
|
|
|
|
m_TrafficValue = parser.ReadFloat(section, L"TrafficValue", 0.0);
|
2009-10-01 03:13:19 +00:00
|
|
|
m_TrafficAction = parser.ReadString(section, L"TrafficAction", L"", false);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
|
|
|
if (maxValue == 0)
|
|
|
|
{
|
|
|
|
m_MaxValue = 1;
|
|
|
|
m_LogMaxValue = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_MaxValue = maxValue / 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** UpdateStats
|
|
|
|
**
|
|
|
|
** Updates the statistics.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void CMeasureNet::UpdateStats()
|
|
|
|
{
|
|
|
|
if (c_Table)
|
|
|
|
{
|
2011-02-15 13:22:19 +00:00
|
|
|
size_t statsSize = c_NumOfTables * 2;
|
|
|
|
|
2009-02-10 18:37:48 +00:00
|
|
|
// Fill the vectors
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_StatValues.size() < statsSize)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2011-08-07 09:40:08 +00:00
|
|
|
c_StatValues.resize(statsSize, 0);
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_OldStatValues.size() < statsSize)
|
2011-03-29 19:21:57 +00:00
|
|
|
{
|
2011-08-07 09:40:08 +00:00
|
|
|
c_OldStatValues.resize(statsSize, 0);
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
|
2010-03-30 22:37:05 +00:00
|
|
|
for (UINT i = 0; i < c_NumOfTables; ++i)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
ULONG64 in, out;
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_GetIfTable2)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-07 09:40:08 +00:00
|
|
|
in = ((MIB_IF_TABLE2*)c_Table)->Table[i].InOctets;
|
|
|
|
out = ((MIB_IF_TABLE2*)c_Table)->Table[i].OutOctets;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
in = ((MIB_IFTABLE*)c_Table)->table[i].dwInOctets;
|
|
|
|
out = ((MIB_IFTABLE*)c_Table)->table[i].dwOutOctets;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_OldStatValues[i * 2 + 0] != 0)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
|
|
|
if (in > c_OldStatValues[i * 2 + 0])
|
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
c_StatValues[i * 2 + 0] += in - c_OldStatValues[i * 2 + 0];
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
2011-08-07 09:40:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (c_OldStatValues[i * 2 + 1] != 0)
|
|
|
|
{
|
2009-02-10 18:37:48 +00:00
|
|
|
if (out > c_OldStatValues[i * 2 + 1])
|
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
c_StatValues[i * 2 + 1] += out - c_OldStatValues[i * 2 + 1];
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
c_OldStatValues[i * 2 + 0] = in;
|
|
|
|
c_OldStatValues[i * 2 + 1] = out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** ResetStats
|
|
|
|
**
|
|
|
|
** Resets the statistics.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void CMeasureNet::ResetStats()
|
|
|
|
{
|
2010-11-06 23:13:12 +00:00
|
|
|
c_StatValues.clear();
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** ReadStats
|
|
|
|
**
|
|
|
|
** Reads statistics.
|
|
|
|
**
|
|
|
|
*/
|
2011-08-03 19:44:40 +00:00
|
|
|
void CMeasureNet::ReadStats(const WCHAR* iniFile, std::wstring& statsDate)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-09-13 20:06:52 +00:00
|
|
|
WCHAR buffer[64];
|
2011-07-08 22:50:02 +00:00
|
|
|
|
|
|
|
CConfigParser parser;
|
|
|
|
parser.Initialize(iniFile, NULL, NULL, L"Statistics");
|
|
|
|
|
2011-11-16 16:47:20 +00:00
|
|
|
const std::wstring& date = parser.ReadString(L"Statistics", L"Since", L"", false);
|
2011-08-03 19:44:40 +00:00
|
|
|
if (!date.empty())
|
|
|
|
{
|
|
|
|
statsDate = date;
|
|
|
|
}
|
|
|
|
|
2011-07-08 22:50:02 +00:00
|
|
|
int count = parser.ReadInt(L"Statistics", L"NetStatsCount", 0);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
|
|
|
c_StatValues.clear();
|
2011-08-07 09:40:08 +00:00
|
|
|
c_StatValues.reserve(count * 2);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2010-11-06 23:13:12 +00:00
|
|
|
for (int i = 1; i <= count; ++i)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
ULARGE_INTEGER value;
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2010-12-16 20:35:44 +00:00
|
|
|
_snwprintf_s(buffer, _TRUNCATE, L"NetStatsInHigh%i", i);
|
2011-08-07 09:40:08 +00:00
|
|
|
value.HighPart = parser.ReadUInt(L"Statistics", buffer, 0);
|
2010-02-13 03:07:34 +00:00
|
|
|
|
2010-12-16 20:35:44 +00:00
|
|
|
_snwprintf_s(buffer, _TRUNCATE, L"NetStatsInLow%i", i);
|
2011-08-07 09:40:08 +00:00
|
|
|
value.LowPart = parser.ReadUInt(L"Statistics", buffer, 0);
|
2010-02-13 03:07:34 +00:00
|
|
|
|
|
|
|
c_StatValues.push_back(value.QuadPart);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2010-12-16 20:35:44 +00:00
|
|
|
_snwprintf_s(buffer, _TRUNCATE, L"NetStatsOutHigh%i", i);
|
2011-08-07 09:40:08 +00:00
|
|
|
value.HighPart = parser.ReadUInt(L"Statistics", buffer, 0);
|
2010-02-13 03:07:34 +00:00
|
|
|
|
2010-12-16 20:35:44 +00:00
|
|
|
_snwprintf_s(buffer, _TRUNCATE, L"NetStatsOutLow%i", i);
|
2011-08-07 09:40:08 +00:00
|
|
|
value.LowPart = parser.ReadUInt(L"Statistics", buffer, 0);
|
2010-02-13 03:07:34 +00:00
|
|
|
|
|
|
|
c_StatValues.push_back(value.QuadPart);
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-09 19:49:06 +00:00
|
|
|
/*
|
|
|
|
** AppendStatsValue
|
|
|
|
**
|
|
|
|
** Appends "key=value\0" to given string.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
inline void AppendStatsValue(std::wstring& data, const WCHAR* key, size_t key_len, const WCHAR* value, size_t value_len)
|
|
|
|
{
|
|
|
|
data.append(key, key_len);
|
|
|
|
data += L'=';
|
|
|
|
data.append(value, value_len);
|
|
|
|
data += L'\0';
|
|
|
|
}
|
|
|
|
|
2009-02-10 18:37:48 +00:00
|
|
|
/*
|
|
|
|
** WriteStats
|
|
|
|
**
|
|
|
|
** Writes statistics.
|
|
|
|
**
|
|
|
|
*/
|
2011-12-09 19:49:06 +00:00
|
|
|
void CMeasureNet::WriteStats(const WCHAR* iniFile, const std::wstring& statsDate)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2011-12-09 19:49:06 +00:00
|
|
|
WCHAR buffer[64];
|
|
|
|
WCHAR buffer2[32];
|
|
|
|
size_t len, len2;
|
2011-02-15 13:22:19 +00:00
|
|
|
|
|
|
|
size_t statsSize = c_StatValues.size() / 2;
|
2011-03-29 19:21:57 +00:00
|
|
|
|
2011-08-03 19:44:40 +00:00
|
|
|
// Reserve sufficient buffer for statistics
|
|
|
|
std::wstring data;
|
|
|
|
data.reserve((64 * 2) + 128 * statsSize);
|
|
|
|
|
|
|
|
// Add date
|
2011-12-09 19:49:06 +00:00
|
|
|
AppendStatsValue(data, L"Since", 5, statsDate.c_str(), statsDate.size());
|
2011-08-03 19:44:40 +00:00
|
|
|
|
|
|
|
// Add stats count
|
2011-12-09 19:49:06 +00:00
|
|
|
len = _snwprintf_s(buffer, _TRUNCATE, L"%i", (int)statsSize);
|
|
|
|
AppendStatsValue(data, L"NetStatsCount", 13, buffer, len);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-08-03 19:44:40 +00:00
|
|
|
// Add stats
|
2011-02-15 13:22:19 +00:00
|
|
|
for (size_t i = 0; i < statsSize; ++i)
|
2009-02-10 18:37:48 +00:00
|
|
|
{
|
2010-02-13 03:07:34 +00:00
|
|
|
ULARGE_INTEGER value;
|
|
|
|
|
|
|
|
value.QuadPart = c_StatValues[i * 2];
|
|
|
|
|
2011-12-09 19:49:06 +00:00
|
|
|
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsInHigh%i", (int)i + 1);
|
|
|
|
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.HighPart);
|
|
|
|
AppendStatsValue(data, buffer, len, buffer2, len2);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-12-09 19:49:06 +00:00
|
|
|
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsInLow%i", (int)i + 1);
|
|
|
|
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.LowPart);
|
|
|
|
AppendStatsValue(data, buffer, len, buffer2, len2);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2010-02-13 03:07:34 +00:00
|
|
|
value.QuadPart = c_StatValues[i * 2 + 1];
|
|
|
|
|
2011-12-09 19:49:06 +00:00
|
|
|
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsOutHigh%i", (int)i + 1);
|
|
|
|
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.HighPart);
|
|
|
|
AppendStatsValue(data, buffer, len, buffer2, len2);
|
2009-02-10 18:37:48 +00:00
|
|
|
|
2011-12-09 19:49:06 +00:00
|
|
|
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsOutLow%i", (int)i + 1);
|
|
|
|
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.LowPart);
|
|
|
|
AppendStatsValue(data, buffer, len, buffer2, len2);
|
2009-02-10 18:37:48 +00:00
|
|
|
}
|
2011-08-03 19:44:40 +00:00
|
|
|
|
|
|
|
// Write statistics
|
|
|
|
WritePrivateProfileSection(L"Statistics", data.c_str(), iniFile);
|
|
|
|
}
|
|
|
|
|
2010-02-13 03:07:34 +00:00
|
|
|
/*
|
|
|
|
** InitializeNewApi
|
|
|
|
**
|
|
|
|
** Prepares in order to use the new APIs which are available on Vista or newer.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void CMeasureNet::InitializeNewApi()
|
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
if (CSystem::GetOSPlatform() >= OSPLATFORM_VISTA)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
HMODULE IpHlpApiLibrary = GetModuleHandle(L"IpHlpApi.dll");
|
|
|
|
if (IpHlpApiLibrary)
|
2011-08-01 21:05:56 +00:00
|
|
|
{
|
2011-08-07 09:40:08 +00:00
|
|
|
c_GetIfTable2 = (FPGETIFTABLE2)GetProcAddress(IpHlpApiLibrary, "GetIfTable2");
|
2011-08-02 01:20:05 +00:00
|
|
|
c_FreeMibTable = (FPFREEMIBTABLE)GetProcAddress(IpHlpApiLibrary, "FreeMibTable");
|
2011-08-01 21:05:56 +00:00
|
|
|
}
|
2011-08-02 01:20:05 +00:00
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
if (!c_GetIfTable2 || !c_FreeMibTable)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-07 09:40:08 +00:00
|
|
|
c_GetIfTable2 = NULL;
|
2011-08-02 01:20:05 +00:00
|
|
|
c_FreeMibTable = NULL;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
}
|
2010-03-20 19:40:30 +00:00
|
|
|
|
2011-09-28 18:28:35 +00:00
|
|
|
if (Rainmeter->GetDebug())
|
2010-03-20 19:40:30 +00:00
|
|
|
{
|
|
|
|
UpdateIFTable();
|
|
|
|
}
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** FinalizeNewApi
|
|
|
|
**
|
|
|
|
** Frees the resources.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void CMeasureNet::FinalizeNewApi()
|
|
|
|
{
|
2011-08-07 09:40:08 +00:00
|
|
|
if (c_GetIfTable2)
|
2010-02-13 03:07:34 +00:00
|
|
|
{
|
2011-08-02 01:20:05 +00:00
|
|
|
if (c_Table)
|
|
|
|
{
|
|
|
|
c_FreeMibTable(c_Table);
|
|
|
|
}
|
2011-08-01 21:05:56 +00:00
|
|
|
|
2011-08-07 09:40:08 +00:00
|
|
|
c_GetIfTable2 = NULL;
|
2011-08-02 01:20:05 +00:00
|
|
|
c_FreeMibTable = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
delete [] c_Table;
|
|
|
|
}
|
2010-02-13 03:07:34 +00:00
|
|
|
c_Table = NULL;
|
2011-08-01 21:05:56 +00:00
|
|
|
c_NumOfTables = 0;
|
2010-02-13 03:07:34 +00:00
|
|
|
}
|