icinga2/plugins/check_network.cpp

375 lines
12 KiB
C++
Raw Normal View History

2014-11-06 16:36:42 +01:00
/******************************************************************************
* Icinga 2 *
2016-01-12 08:29:59 +01:00
* Copyright (C) 2012-2016 Icinga Development Team (https://www.icinga.org/) *
2014-11-06 16:36:42 +01:00
* *
* 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 Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
2015-03-23 13:07:02 +01:00
#define WIN32_LEAN_AND_MEAN
2014-11-06 15:17:08 +01:00
#include <Windows.h>
#include <Pdh.h>
#include <Shlwapi.h>
#include <iostream>
#include <pdhmsg.h>
2015-03-23 13:07:02 +01:00
#include <WinSock2.h>
#include <map>
2014-11-06 15:17:08 +01:00
2015-03-23 13:07:02 +01:00
#include <IPHlpApi.h>
2014-11-06 15:17:08 +01:00
2015-03-23 13:07:02 +01:00
#include "check_network.h"
#include "boost/algorithm/string/replace.hpp"
2014-11-06 15:17:08 +01:00
2015-03-23 13:07:02 +01:00
#define VERSION 1.1
2014-11-06 15:17:08 +01:00
2015-03-23 13:07:02 +01:00
namespace po = boost::program_options;
static BOOL debug = FALSE;
2015-03-23 13:07:02 +01:00
INT wmain(INT argc, WCHAR **argv)
2014-11-06 16:36:42 +01:00
{
2015-03-23 13:07:02 +01:00
std::vector<nInterface> vInterfaces;
std::map<std::wstring, std::wstring> mapNames;
printInfoStruct printInfo{};
po::variables_map vm;
2014-11-06 15:17:08 +01:00
2015-03-23 13:07:02 +01:00
INT ret = parseArguments(argc, argv, vm, printInfo);
2014-11-06 15:17:08 +01:00
if (ret != -1)
return ret;
2015-03-23 13:07:02 +01:00
if (!mapSystemNamesToFamiliarNames(mapNames))
return 3;
2014-11-06 15:17:08 +01:00
ret = check_network(vInterfaces);
if (ret != -1)
return ret;
2015-03-23 13:07:02 +01:00
return printOutput(printInfo, vInterfaces, mapNames);
2014-11-06 15:17:08 +01:00
}
2015-03-23 13:07:02 +01:00
INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
2014-11-06 16:36:42 +01:00
{
2015-03-23 13:07:02 +01:00
WCHAR namePath[MAX_PATH];
2014-11-06 15:17:08 +01:00
GetModuleFileName(NULL, namePath, MAX_PATH);
2015-03-23 13:07:02 +01:00
WCHAR *progName = PathFindFileName(namePath);
2014-11-06 15:17:08 +01:00
po::options_description desc("Options");
desc.add_options()
("help,h", "print usage and exit")
("version,V", "print version and exit")
("debug,d", "Verbose/Debug output")
2015-03-23 13:07:02 +01:00
("warning,w", po::wvalue<std::wstring>(), "warning value")
("critical,c", po::wvalue<std::wstring>(), "critical value")
2014-11-06 15:17:08 +01:00
;
2015-03-23 13:07:02 +01:00
po::basic_command_line_parser<WCHAR> parser(ac, av);
2014-11-06 15:17:08 +01:00
try {
po::store(
parser
.options(desc)
.style(
po::command_line_style::unix_style |
po::command_line_style::allow_long_disguise)
.run(),
vm);
vm.notify();
2014-11-06 16:36:42 +01:00
} catch (std::exception& e) {
2015-03-23 13:07:02 +01:00
std::cout << e.what() << '\n' << desc << '\n';
2014-11-06 15:17:08 +01:00
return 3;
}
if (vm.count("help")) {
2015-03-23 13:07:02 +01:00
std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
2014-11-06 15:17:08 +01:00
wprintf(
L"%s is a simple program to check a machines network performance.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
2015-03-23 13:07:02 +01:00
std::cout << desc;
2014-11-06 15:17:08 +01:00
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tNETWORK WARNING 1131B/s | network=1131B;1000;7000;0\n\n"
2015-03-23 13:07:02 +01:00
L"\"NETWORK\" being the type of the check, \"WARNING\" the returned status\n"
2014-11-06 15:17:08 +01:00
L"and \"1131B/s\" is the returned value.\n"
L"The performance data is found behind the \"|\", in order:\n"
L"returned value, warning threshold, critical threshold, minimal value and,\n"
2014-11-06 16:36:42 +01:00
L"if applicable, the maximal value. Performance data will only be displayed when\n"
L"you set at least one threshold\n\n"
2014-11-06 15:17:08 +01:00
L"This program will also print out additional performance data interface\n"
L"by interface\n\n"
L"%s' exit codes denote the following:\n"
2014-11-06 16:36:42 +01:00
L" 0\tOK,\n\tNo Thresholds were broken or the programs check part was not executed\n"
2014-11-06 15:17:08 +01:00
L" 1\tWARNING,\n\tThe warning, but not the critical threshold was broken\n"
L" 2\tCRITICAL,\n\tThe critical threshold was broken\n"
2014-11-06 16:36:42 +01:00
L" 3\tUNKNOWN, \n\tThe program experienced an internal or input error\n\n"
2014-11-06 15:17:08 +01:00
L"Threshold syntax:\n\n"
L"-w THRESHOLD\n"
L"warn if threshold is broken, which means VALUE > THRESHOLD\n"
L"(unless stated differently)\n\n"
L"-w !THRESHOLD\n"
L"inverts threshold check, VALUE < THRESHOLD (analogous to above)\n\n"
L"-w [THR1-THR2]\n"
L"warn is VALUE is inside the range spanned by THR1 and THR2\n\n"
L"-w ![THR1-THR2]\n"
L"warn if VALUE is outside the range spanned by THR1 and THR2\n\n"
L"-w THRESHOLD%%\n"
L"if the plugin accepts percentage based thresholds those will be used.\n"
L"Does nothing if the plugin does not accept percentages, or only uses\n"
L"percentage thresholds. Ranges can be used with \"%%\", but both range values need\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too."
, progName);
2015-03-23 13:07:02 +01:00
std::cout << '\n';
2014-11-06 15:17:08 +01:00
return 0;
}
if (vm.count("version"))
2015-03-23 13:07:02 +01:00
std::cout << "Version: " << VERSION << '\n';
2014-11-06 15:17:08 +01:00
if (vm.count("warning")) {
try {
2015-03-23 13:07:02 +01:00
printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
2015-03-23 13:07:02 +01:00
std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
try {
2015-03-23 13:07:02 +01:00
printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
2015-03-23 13:07:02 +01:00
std::cout << e.what() << '\n';
return 3;
}
}
2014-11-06 15:17:08 +01:00
if (vm.count("debug"))
debug = TRUE;
2014-11-06 15:17:08 +01:00
return -1;
}
2015-03-23 13:07:02 +01:00
INT printOutput(printInfoStruct& printInfo, CONST std::vector<nInterface>& vInterfaces, CONST std::map<std::wstring, std::wstring>& mapNames)
2014-11-06 16:36:42 +01:00
{
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Constructing output string" << '\n';
2014-11-06 15:17:08 +01:00
long tIn = 0, tOut = 0;
std::wstringstream tss, perfDataFirst;
2014-11-06 15:17:08 +01:00
state state = OK;
2015-03-23 13:07:02 +01:00
std::map<std::wstring, std::wstring>::const_iterator mapIt;
std::wstring wsFriendlyName;
for (std::vector<nInterface>::const_iterator it = vInterfaces.begin(); it != vInterfaces.end(); ++it) {
2014-11-06 15:17:08 +01:00
tIn += it->BytesInSec;
tOut += it->BytesOutSec;
2015-03-23 13:07:02 +01:00
if (debug)
std::wcout << "Getting friendly name of " << it->name << '\n';
mapIt = mapNames.find(it->name);
if (mapIt != mapNames.end()) {
if (debug)
std::wcout << "\tIs " << mapIt->second << '\n';
wsFriendlyName = mapIt->second;
} else {
if (debug)
std::wcout << "\tNo friendly name found, using adapter name\n";
wsFriendlyName = it->name;
}
boost::algorithm::replace_all(wsFriendlyName, "'", "''");
tss << L"netI='" << wsFriendlyName << L"';in=" << it->BytesInSec << "B;out=" << it->BytesOutSec << L"B ";
2014-11-06 15:17:08 +01:00
}
if (printInfo.warn.rend(tIn + tOut))
state = WARNING;
if (printInfo.crit.rend(tIn + tOut))
state = CRITICAL;
2015-03-23 13:07:02 +01:00
perfDataFirst << L"network=" << tIn + tOut << L"B;" << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";" << L"0; ";
2014-11-06 15:17:08 +01:00
switch (state) {
case OK:
2015-03-23 13:07:02 +01:00
std::wcout << L"NETWORK OK " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << '\n';
2014-11-06 15:17:08 +01:00
break;
case WARNING:
2015-03-23 13:07:02 +01:00
std::wcout << L"NETWORK WARNING " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << '\n';
2014-11-06 15:17:08 +01:00
break;
case CRITICAL:
2015-03-23 13:07:02 +01:00
std::wcout << L"NETWORK CRITICAL " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << '\n';
2014-11-06 15:17:08 +01:00
break;
}
return state;
}
2015-03-23 13:07:02 +01:00
INT check_network(std::vector <nInterface>& vInterfaces)
2014-11-06 16:36:42 +01:00
{
2015-03-23 13:07:02 +01:00
CONST WCHAR *perfIn = L"\\Network Interface(*)\\Bytes Received/sec";
CONST WCHAR *perfOut = L"\\Network Interface(*)\\Bytes Sent/sec";
2014-11-06 15:17:08 +01:00
PDH_HQUERY phQuery = NULL;
PDH_HCOUNTER phCounterIn, phCounterOut;
DWORD dwBufferSizeIn = 0, dwBufferSizeOut = 0, dwItemCount = 0;
PDH_FMT_COUNTERVALUE_ITEM *pDisplayValuesIn = NULL, *pDisplayValuesOut = NULL;
PDH_STATUS err;
2014-11-06 15:17:08 +01:00
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Creating Query and adding counters" << '\n';
err = PdhOpenQuery(NULL, NULL, &phQuery);
if (!SUCCEEDED(err))
2014-11-06 15:17:08 +01:00
goto die;
err = PdhAddEnglishCounter(phQuery, perfIn, NULL, &phCounterIn);
if (!SUCCEEDED(err))
goto die;
err = PdhAddEnglishCounter(phQuery, perfOut, NULL, &phCounterOut);
if (!SUCCEEDED(err))
goto die;
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Collecting first batch of query data" << '\n';
err = PdhCollectQueryData(phQuery);
if (!SUCCEEDED(err))
goto die;
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Sleep for one second" << '\n';
Sleep(1000);
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Collecting second batch of query data" << '\n';
err = PdhCollectQueryData(phQuery);
if (!SUCCEEDED(err))
goto die;
2014-11-06 15:17:08 +01:00
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Creating formatted counter arrays" << '\n';
err = PdhGetFormattedCounterArray(phCounterIn, PDH_FMT_LONG, &dwBufferSizeIn, &dwItemCount, pDisplayValuesIn);
if (err == PDH_MORE_DATA || SUCCEEDED(err))
2014-11-14 16:26:30 +01:00
pDisplayValuesIn = reinterpret_cast<PDH_FMT_COUNTERVALUE_ITEM*>(new BYTE[dwItemCount*dwBufferSizeIn]);
else
goto die;
2014-11-06 15:17:08 +01:00
err = PdhGetFormattedCounterArray(phCounterOut, PDH_FMT_LONG, &dwBufferSizeOut, &dwItemCount, pDisplayValuesOut);
if (err == PDH_MORE_DATA || SUCCEEDED(err))
2014-11-14 16:26:30 +01:00
pDisplayValuesOut = reinterpret_cast<PDH_FMT_COUNTERVALUE_ITEM*>(new BYTE[dwItemCount*dwBufferSizeIn]);
else
goto die;
err = PdhGetFormattedCounterArray(phCounterIn, PDH_FMT_LONG, &dwBufferSizeIn, &dwItemCount, pDisplayValuesIn);
if (!SUCCEEDED(err))
goto die;
err = PdhGetFormattedCounterArray(phCounterOut, PDH_FMT_LONG, &dwBufferSizeOut, &dwItemCount, pDisplayValuesOut);
if (!SUCCEEDED(err))
goto die;
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Going over counter array" << '\n';
for (DWORD i = 0; i < dwItemCount; i++) {
2015-03-23 13:07:02 +01:00
nInterface *iface = new nInterface(std::wstring(pDisplayValuesIn[i].szName));
iface->BytesInSec = pDisplayValuesIn[i].FmtValue.longValue;
iface->BytesOutSec = pDisplayValuesOut[i].FmtValue.longValue;
vInterfaces.push_back(*iface);
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Collected interface " << pDisplayValuesIn[i].szName << '\n';
}
if (debug)
2015-03-23 13:07:02 +01:00
std::wcout << L"Finished collection. Cleaning up and returning" << '\n';
if (phQuery)
PdhCloseQuery(phQuery);
if (pDisplayValuesIn)
delete reinterpret_cast<PDH_FMT_COUNTERVALUE_ITEM*>(pDisplayValuesIn);
if (pDisplayValuesOut)
delete reinterpret_cast<PDH_FMT_COUNTERVALUE_ITEM*>(pDisplayValuesOut);
return -1;
2014-11-06 15:17:08 +01:00
die:
die(err);
2014-11-06 15:17:08 +01:00
if (phQuery)
PdhCloseQuery(phQuery);
if (pDisplayValuesIn)
2014-11-14 16:26:30 +01:00
delete reinterpret_cast<PDH_FMT_COUNTERVALUE_ITEM*>(pDisplayValuesIn);
if (pDisplayValuesOut)
2014-11-14 16:26:30 +01:00
delete reinterpret_cast<PDH_FMT_COUNTERVALUE_ITEM*>(pDisplayValuesOut);
2014-11-06 15:17:08 +01:00
return 3;
2015-03-23 13:07:02 +01:00
}
BOOL mapSystemNamesToFamiliarNames(std::map<std::wstring, std::wstring>& mapNames)
{
DWORD dwSize = 0, dwRetVal = 0;
ULONG family = AF_UNSPEC, flags = GAA_FLAG_INCLUDE_PREFIX,
outBufLen = 0, Iterations = 0;
LPVOID lpMsgBuf = NULL;
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
/*
PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
PIP_ADAPTER_DNS_SERVER_ADDRESS pDnsServer = NULL;
PIP_ADAPTER_PREFIX pPrefix = NULL;
*/
outBufLen = 15000; //15KB as suggestet by msdn of GetAdaptersAddresses
if (debug)
std::wcout << "Mapping adapter system names to friendly names\n";
do {
pAddresses = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(new BYTE[outBufLen]);
dwRetVal = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
delete[]pAddresses;
pAddresses = NULL;
} else
break;
} while (++Iterations < 3);
if (dwRetVal != NO_ERROR) {
std::wcout << "Failed to collect friendly adapter names\n";
delete[]pAddresses;
return FALSE;
}
pCurrAddresses = pAddresses;
std::wstringstream wssAdapterName;
std::wstringstream wssFriendlyName;
for (pCurrAddresses = pAddresses; pCurrAddresses; pCurrAddresses = pCurrAddresses->Next) {
wssAdapterName.str(std::wstring());
wssFriendlyName.str(std::wstring());
wssAdapterName << pCurrAddresses->Description;
wssFriendlyName << pCurrAddresses->FriendlyName;
if (debug)
std::wcout << "Got: " << wssAdapterName.str() << " -- " << wssFriendlyName.str() << '\n';
mapNames.insert(std::pair<std::wstring, std::wstring>(wssAdapterName.str(), wssFriendlyName.str()));
}
delete[]pAddresses;
return TRUE;
}