if ( WIN32 )
- add_definitions( -DUNICODE -D_UNICODE )
+ add_definitions ( -DUNICODE -D_UNICODE )
- add_library( thresholds thresholds )
+ add_library ( thresholds thresholds )
set_target_properties (
thresholds PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
FOLDER Plugins
)
- list( APPEND check_SOURCES
- check_disk.cpp check_load.cpp check_memory.cpp check_network.cpp check_ping.cpp check_perfmon.cpp
+ list ( APPEND check_SOURCES
+ check_disk.cpp check_load.cpp check_memory.cpp check_network.cpp check_ping.cpp
check_procs.cpp check_service.cpp check_swap.cpp check_update.cpp check_uptime.cpp check_users.cpp )
foreach ( source ${check_SOURCES} )
string ( REGEX REPLACE ".cpp\$" "" check_OUT "${source}" )
+ string ( REGEX REPLACE ".cpp\$" ".h" check_HEADER "${source}" )
- add_executable ( ${check_OUT} ${source} )
- target_link_libraries( ${check_OUT} thresholds Shlwapi.lib ${Boost_PROGRAM_OPTIONS_LIBRARY} )
+ add_executable ( ${check_OUT} ${source} ${check_HEADER} )
+ target_link_libraries ( ${check_OUT} thresholds Shlwapi.lib ${Boost_PROGRAM_OPTIONS_LIBRARY} )
set_target_properties (
${check_OUT} PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_PLUGINS_BUILD
- FOLDER Plugins)
- endforeach(source)
+ FOLDER Plugins )
+ endforeach ( source )
- target_link_libraries( check_load Pdh.lib )
- target_link_libraries( check_network Pdh.lib )
- target_link_libraries ( check_perfmon Pdh.lib )
- target_link_libraries( check_ping Ntdll.lib iphlpapi.lib Ws2_32.lib )
- target_link_libraries( check_procs Pdh.lib )
- target_link_libraries( check_uptime ${Boost_SYSTEM_LIBRARY} )
- target_link_libraries( check_users wtsapi32.lib )
+ target_link_libraries ( check_load Pdh.lib )
+ target_link_libraries ( check_network Pdh.lib Iphlpapi.lib)
+ target_link_libraries ( check_ping Ntdll.lib iphlpapi.lib Ws2_32.lib )
+ target_link_libraries ( check_procs Pdh.lib )
+ target_link_libraries ( check_uptime ${Boost_SYSTEM_LIBRARY} )
+ target_link_libraries ( check_users wtsapi32.lib )
install (
- TARGETS check_disk check_load check_memory check_network check_procs check_perfmon
+ TARGETS check_disk check_load check_memory check_network check_procs
check_ping check_service check_swap check_update check_uptime check_users
RUNTIME DESTINATION ${CMAKE_INSTALL_SBINDIR} )
-endif()
+endif ( )
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
-#include <Windows.h>
#include <set>
#include <Shlwapi.h>
-#include <vector>
#include <iostream>
#include <math.h>
-#include "thresholds.h"
-
-#include "boost/program_options.hpp"
+#include "check_disk.h"
#define VERSION 1.1
namespace po = boost::program_options;
-using std::cout; using std::endl; using std::set;
-using std::vector; using std::wstring; using std::wcout;
-
static BOOL debug = FALSE;
-struct drive
-{
- wstring name;
- double cap, free;
- drive(wstring p)
- : name(p)
- {}
-};
-
-struct printInfoStruct
-{
- threshold warn, crit;
- vector<wstring> drives;
- Bunit unit;
-};
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(printInfoStruct&, vector<drive>&);
-static int check_drives(vector<drive>&);
-static int check_drives(vector<drive>&, printInfoStruct&);
-static bool getFreeAndCap(drive&, const Bunit&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
- vector<drive> vDrives;
+ std::vector<drive> vDrives;
printInfoStruct printInfo{ };
po::variables_map vm;
- int ret;
+ INT ret;
ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
if (ret != -1)
return ret;
- for (vector<drive>::iterator it = vDrives.begin(); it != vDrives.end(); ++it) {
+ for (std::vector<drive>::iterator it = vDrives.begin(); it != vDrives.end(); ++it) {
if (!getFreeAndCap(*it, printInfo.unit)) {
- wcout << L"Failed to access drive at " << it->name << endl;
+ std::wcout << "Failed to access drive at " << it->name << '\n';
return 3;
}
}
return printOutput(printInfo, vDrives);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc("Options");
desc.add_options()
- ("help,h", "print usage message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print usage message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("warning,w", po::wvalue<wstring>(), "warning threshold")
- ("critical,c", po::wvalue<wstring>(), "critical threshold")
- ("path,p", po::wvalue<vector<std::wstring>>()->multitoken(), "declare explicitly which drives to check (default checks all)")
- ("unit,u", po::wvalue<wstring>(), "assign unit possible are: B, kB, MB, GB, TB")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning threshold")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical threshold")
+ ("path,p", po::wvalue<std::vector<std::wstring>>()->multitoken(), "Declare explicitly which drives to check (default checks all)")
+ ("unit,u", po::wvalue<std::wstring>(), "Assign unit possible are: B, kB, MB, GB, TB")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::options_description allDesc;
allDesc.add(desc);
allDesc.add_options()
- ("exclude-type,X", po::wvalue<vector<std::wstring>>()->multitoken(), "exclude partition types (ignored)")
+ ("exclude-type,X", po::wvalue<std::vector<std::wstring>>()->multitoken(), "exclude partition types (ignored)")
("megabytes,m", "use megabytes")
;
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines free disk space.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tDISK WARNING 29GB | disk=29GB;50%%;5;0;120\n\n"
L" 0\tOK,\n\tNo Thresholds were broken or the programs check part was not executed\n"
L" 1\tWARNING,\n\tThe warning, but not the critical threshold was broken\n"
L" 2\tCRITICAL,\n\tThe critical threshold was broken\n"
- L" 3\tUNKNOWN, \n\tThe program experienced an internal or input error\n\n"
+ L" 3\tUNKNOWN, \n\tThe program experienced an INTernal or input error\n\n"
L"Threshold syntax:\n\n"
L"-w THRESHOLD\n"
L"warn if threshold is broken, which means VALUE < THRESHOLD\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too."
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version"))
- cout << "Version: " << VERSION << endl;
+ std::cout << "Version: " << VERSION << '\n';
if (vm.count("warning")) {
try {
- printInfo.warn = threshold(vm["warning"].as<wstring>());
+ printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
try {
- printInfo.crit = threshold(vm["critical"].as<wstring>());
+ printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("path"))
- printInfo.drives = vm["path"].as<vector<wstring>>();
+ printInfo.drives = vm["path"].as<std::vector<std::wstring>>();
if (vm.count("unit")) {
try {
- printInfo.unit = parseBUnit(vm["unit"].as<wstring>());
+ printInfo.unit = parseBUnit(vm["unit"].as<std::wstring>());
} catch (std::invalid_argument) {
- wcout << L"Unknown unit Type " << vm["unit"].as<wstring>() << endl;
+ std::wcout << "Unknown unit Type " << vm["unit"].as<std::wstring>() << '\n';
return 3;
}
} else
return -1;
}
-int printOutput(printInfoStruct& printInfo, vector<drive>& vDrives)
+INT printOutput(printInfoStruct& printInfo, std::vector<drive>& vDrives)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << "Constructing output string\n";
- vector<wstring> wsDrives, wsPerf;
- wstring unit = BunitStr(printInfo.unit);
+ std::vector<std::wstring> wsDrives, wsPerf;
+ std::wstring unit = BunitStr(printInfo.unit);
state state = OK;
- wstring output = L"DISK OK - free space:";
+ std::wstring output = L"DISK OK - free space:";
double tCap = 0, tFree = 0;
- for (vector<drive>::iterator it = vDrives.begin(); it != vDrives.end(); it++) {
+ for (std::vector<drive>::iterator it = vDrives.begin(); it != vDrives.end(); it++) {
tCap += it->cap;
tFree += it->free;
wsDrives.push_back(it->name + L" " + removeZero(it->free) + L" " + unit + L" (" +
output = L"DISK CRITICAL - free space:";
}
- wcout << output;
+ std::wcout << output;
if (vDrives.size() > 1)
- wcout << L"Total " << tFree << unit << L" (" << removeZero(std::round(tFree/tCap * 100.0)) << L"%); ";
+ std::wcout << "Total " << tFree << unit << " (" << removeZero(std::round(tFree/tCap * 100.0)) << "%); ";
- for (vector<wstring>::const_iterator it = wsDrives.begin(); it != wsDrives.end(); it++)
- wcout << *it;
- wcout << L"|";
+ for (std::vector<std::wstring>::const_iterator it = wsDrives.begin(); it != wsDrives.end(); it++)
+ std::wcout << *it;
+ std::wcout << "|";
- for (vector<wstring>::const_iterator it = wsPerf.begin(); it != wsPerf.end(); it++)
- wcout << *it;
+ for (std::vector<std::wstring>::const_iterator it = wsPerf.begin(); it != wsPerf.end(); it++)
+ std::wcout << *it;
- wcout << endl;
+ std::wcout << '\n';
return state;
}
-int check_drives(vector<drive>& vDrives)
+INT check_drives(std::vector<drive>& vDrives)
{
DWORD dwResult, dwSize = 0, dwVolumePathNamesLen = MAX_PATH + 1;
- wchar_t szLogicalDrives[1024], szVolumeName[MAX_PATH], *szVolumePathNames = NULL;
+ WCHAR szLogicalDrives[1024], szVolumeName[MAX_PATH], *szVolumePathNames = NULL;
HANDLE hVolume = NULL;
- wstring wsLogicalDrives;
+ std::wstring wsLogicalDrives;
size_t volumeNameEnd = 0;
- set<wstring> sDrives;
+ std::set<std::wstring> sDrives;
if (debug)
- wcout << L"Getting logic drive string (includes network drives)" << endl;
+ std::wcout << "Getting logic drive string (includes network drives)\n";
dwResult = GetLogicalDriveStrings(MAX_PATH, szLogicalDrives);
if (dwResult > MAX_PATH)
goto die;
if (debug)
- wcout << L"Splitting string into single drive names" << endl;
+ std::wcout << "Splitting string INTo single drive names\n";
LPTSTR szSingleDrive = szLogicalDrives;
while (*szSingleDrive) {
- wstring drname = szSingleDrive;
+ std::wstring drname = szSingleDrive;
sDrives.insert(drname);
szSingleDrive += wcslen(szSingleDrive) + 1;
if (debug)
- wcout << "Got: " << drname << endl;
+ std::wcout << "Got: " << drname << '\n';
}
if (debug)
- wcout << L"Getting volume mountpoints (includes NTFS folders)" << endl
- << L"Getting first volume" << endl;
+ std::wcout << "Getting volume mountpoINTs (includes NTFS folders)\n"
+ << "Getting first volume\n";
hVolume = FindFirstVolume(szVolumeName, MAX_PATH);
if (hVolume == INVALID_HANDLE_VALUE)
goto die;
if (debug)
- wcout << L"Traversing through list of drives" << endl;
+ std::wcout << "Traversing through list of drives\n";
while (GetLastError() != ERROR_NO_MORE_FILES) {
if (debug)
- wcout << L"Path name for " << szVolumeName << L"= \"";
+ std::wcout << "Path name for " << szVolumeName << "= \"";
volumeNameEnd = wcslen(szVolumeName) - 1;
- szVolumePathNames = reinterpret_cast<wchar_t*>(new WCHAR[dwVolumePathNamesLen]);
+ szVolumePathNames = reinterpret_cast<WCHAR*>(new WCHAR[dwVolumePathNamesLen]);
while (!GetVolumePathNamesForVolumeName(szVolumeName, szVolumePathNames, dwVolumePathNamesLen, &dwVolumePathNamesLen)) {
if (GetLastError() != ERROR_MORE_DATA)
break;
- delete[] reinterpret_cast<wchar_t*>(szVolumePathNames);
- szVolumePathNames = reinterpret_cast<wchar_t*>(new WCHAR[dwVolumePathNamesLen]);
+ delete[] reinterpret_cast<WCHAR*>(szVolumePathNames);
+ szVolumePathNames = reinterpret_cast<WCHAR*>(new WCHAR[dwVolumePathNamesLen]);
}
if (debug)
- wcout << szVolumePathNames << L"\"" << endl;
+ std::wcout << szVolumePathNames << "\"\n";
- //.insert() does the dublicate checking
- sDrives.insert(wstring(szVolumePathNames));
+ sDrives.insert(std::wstring(szVolumePathNames));
FindNextVolume(hVolume, szVolumeName, MAX_PATH);
}
if (debug)
- wcout << L"Creating vector from found volumes, ignoring cd drives etc.:" << endl;
- for (set<wstring>::iterator it = sDrives.begin(); it != sDrives.end(); ++it) {
+ std::wcout << "Creating vector from found volumes, ignoring cd drives etc.:\n";
+ for (std::set<std::wstring>::iterator it = sDrives.begin(); it != sDrives.end(); ++it) {
UINT type = GetDriveType(it->c_str());
if (type == DRIVE_FIXED || type == DRIVE_REMOTE) {
if (debug)
- wcout << L"\t" << *it << endl;
+ std::wcout << "\t" << *it << '\n';
vDrives.push_back(drive(*it));
}
}
FindVolumeClose(hVolume);
if (szVolumePathNames)
- delete[] reinterpret_cast<wchar_t*>(szVolumePathNames);
+ delete[] reinterpret_cast<WCHAR*>(szVolumePathNames);
return -1;
die:
return 3;
}
-int check_drives(vector<drive>& vDrives, printInfoStruct& printInfo)
+INT check_drives(std::vector<drive>& vDrives, printInfoStruct& printInfo)
{
- wchar_t *slash = L"\\";
+ WCHAR *slash = L"\\";
if (debug)
- wcout << L"Parsing user input drive names" << endl;
+ std::wcout << "Parsing user input drive names\n";
- for (vector<wstring>::iterator it = printInfo.drives.begin();
+ for (std::vector<std::wstring>::iterator it = printInfo.drives.begin();
it != printInfo.drives.end(); ++it) {
if (it->at(it->length() - 1) != *slash)
it->append(slash);
if (std::wstring::npos == it->find(L":\\")) {
- wcout << "A \":\" is required after the drive name of " << *it << endl;
+ std::wcout << "A \":\" is required after the drive name of " << *it << '\n';
return 3;
}
if (debug)
- wcout << L"Added " << *it << endl;
+ std::wcout << "Added " << *it << '\n';
vDrives.push_back(drive(*it));
}
return -1;
}
-bool getFreeAndCap(drive& drive, const Bunit& unit)
+BOOL getFreeAndCap(drive& drive, const Bunit& unit)
{
if (debug)
- wcout << L"Getting free disk space for drive " << drive.name << endl;
+ std::wcout << "Getting free disk space for drive " << drive.name << '\n';
ULARGE_INTEGER tempFree, tempTotal;
if (!GetDiskFreeSpaceEx(drive.name.c_str(), NULL, &tempTotal, &tempFree)) {
return FALSE;
}
if (debug)
- wcout << L"\tcap: " << tempFree.QuadPart << endl;
+ std::wcout << "\tcap: " << tempFree.QuadPart << '\n';
drive.cap = round((tempTotal.QuadPart / pow(1024.0, unit)));
if (debug)
- wcout << L"\tAfter conversion: " << drive.cap << endl
- << L"\tfree: " << tempFree.QuadPart << endl;
+ std::wcout << "\tAfter conversion: " << drive.cap << '\n'
+ << "\tfree: " << tempFree.QuadPart << '\n';
drive.free = round((tempFree.QuadPart / pow(1024.0, unit)));
if (debug)
- wcout << L"\tAfter conversion: " << drive.free << endl << endl;
+ std::wcout << "\tAfter conversion: " << drive.free << '\n' << '\n';
return TRUE;
}
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_DISK_H
+#define CHECK_DISK_H
+
+#include <Windows.h>
+#include <vector>
+
+#include "boost/program_options.hpp"
+#include "thresholds.h"
+
+struct drive
+{
+ std::wstring name;
+ double cap, free;
+ drive(std::wstring p)
+ : name(p)
+ {
+ }
+};
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+ std::vector<std::wstring> drives;
+ Bunit unit;
+};
+
+INT parseArguments(int, wchar_t **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(printInfoStruct&, std::vector<drive>&);
+INT check_drives(std::vector<drive>&);
+INT check_drives(std::vector<drive>&, printInfoStruct&);
+BOOL getFreeAndCap(drive&, const Bunit&);
+#endif /*CHECK_DISK_H*/
\ No newline at end of file
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
-#include "thresholds.h"
-#include <boost/program_options.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/classification.hpp>
#include <Pdh.h>
#include <Shlwapi.h>
#include <pdhmsg.h>
#include <iostream>
+#include "check_load.h"
+
+#include "boost/algorithm/string/split.hpp"
+#include "boost/algorithm/string/classification.hpp"
+
#define VERSION 1.0
namespace po = boost::program_options;
-using std::endl; using std::cout; using std::wstring;
-using std::wcout;
-
static BOOL debug = FALSE;
-struct printInfoStruct
-{
- threshold warn, crit;
- double load;
-};
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(printInfoStruct&);
-static int check_load(printInfoStruct&);
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
printInfoStruct printInfo{ };
po::variables_map vm;
- int ret = parseArguments(argc, argv, vm, printInfo);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo) {
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo) {
wchar_t namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
wchar_t *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print usage message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print usage message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("warning,w", po::wvalue<wstring>(), "warning value (in percent)")
- ("critical,c", po::wvalue<wstring>(), "critical value (in percent)")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning value (in percent)")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical value (in percent)")
;
po::basic_command_line_parser<wchar_t> parser(ac, av);
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines CPU load.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tLOAD WARNING 67%% | load=67%%;50%%;90%%;0;100\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too."
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version"))
- cout << "Version: " << VERSION << endl;
+ std::cout << "Version: " << VERSION << '\n';
if (vm.count("warning")) {
try {
- std::wstring wthreshold = vm["warning"].as<wstring>();
+ std::wstring wthreshold = vm["warning"].as<std::wstring>();
std::vector<std::wstring> tokens;
boost::algorithm::split(tokens, wthreshold, boost::algorithm::is_any_of(","));
printInfo.warn = threshold(tokens[0]);
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
try {
- std::wstring cthreshold = vm["critical"].as<wstring>();
+ std::wstring cthreshold = vm["critical"].as<std::wstring>();
std::vector<std::wstring> tokens;
boost::algorithm::split(tokens, cthreshold, boost::algorithm::is_any_of(","));
printInfo.crit = threshold(tokens[0]);
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
return -1;
}
-int printOutput(printInfoStruct& printInfo)
+INT printOutput(printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
std::wstringstream perf;
perf << L"% | load=" << printInfo.load << L"%;" << printInfo.warn.pString() << L";"
- << printInfo.crit.pString() << L";0;100" << endl;
+ << printInfo.crit.pString() << L";0;100" << '\n';
switch (state) {
case OK:
- wcout << L"LOAD OK " << printInfo.load << perf.str();
+ std::wcout << L"LOAD OK " << printInfo.load << perf.str();
break;
case WARNING:
- wcout << L"LOAD WARNING " << printInfo.load << perf.str();
+ std::wcout << L"LOAD WARNING " << printInfo.load << perf.str();
break;
case CRITICAL:
- wcout << L"LOAD CRITICAL " << printInfo.load << perf.str();
+ std::wcout << L"LOAD CRITICAL " << printInfo.load << perf.str();
break;
}
return state;
}
-int check_load(printInfoStruct& printInfo)
+INT check_load(printInfoStruct& printInfo)
{
PDH_HQUERY phQuery = NULL;
PDH_HCOUNTER phCounter;
LPCWSTR path = L"\\Processor(_Total)\\% Idle Time";
if (debug)
- wcout << L"Creating query and adding counter" << endl;
+ std::wcout << L"Creating query and adding counter" << '\n';
err = PdhOpenQuery(NULL, NULL, &phQuery);
if (!SUCCEEDED(err))
goto die;
if (debug)
- wcout << L"Collecting first batch of query data" << endl;
+ std::wcout << L"Collecting first batch of query data" << '\n';
err = PdhCollectQueryData(phQuery);
if (!SUCCEEDED(err))
goto die;
if (debug)
- wcout << L"Sleep for one second" << endl;
+ std::wcout << L"Sleep for one second" << '\n';
Sleep(1000);
if (debug)
- wcout << L"Collecting second batch of query data" << endl;
+ std::wcout << L"Collecting second batch of query data" << '\n';
err = PdhCollectQueryData(phQuery);
if (!SUCCEEDED(err))
goto die;
if (debug)
- wcout << L"Creating formatted counter array" << endl;
+ std::wcout << L"Creating formatted counter array" << '\n';
err = PdhGetFormattedCounterValue(phCounter, PDH_FMT_DOUBLE, &CounterType, &DisplayValue);
if (SUCCEEDED(err)) {
if (DisplayValue.CStatus == PDH_CSTATUS_VALID_DATA) {
if (debug)
- wcout << L"Recieved Value of " << DisplayValue.doubleValue << L" (idle)" << endl;
+ std::wcout << L"Recieved Value of " << DisplayValue.doubleValue << L" (idle)" << '\n';
printInfo.load = 100.0 - DisplayValue.doubleValue;
}
if (debug)
- wcout << L"Finished collection. Cleaning up and returning" << endl;
+ std::wcout << L"Finished collection. Cleaning up and returning" << '\n';
PdhCloseQuery(phQuery);
return -1;
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_LOAD_H
+#define CHECK_LOAD_H
+
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+ DOUBLE load;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(printInfoStruct&);
+INT check_load(printInfoStruct&);
+#endif // !CHECK_LOAD_H
#include <iostream>
#include <WinBase.h>
-#include "thresholds.h"
-
-#include "boost/program_options.hpp"
+#include "check_memory.h"
#define VERSION 1.0
namespace po = boost::program_options;
-using std::endl; using std::wcout; using std::wstring;
-using std::cout;
-
static BOOL debug = FALSE;
-struct printInfoStruct
-{
- threshold warn, crit;
- DWORDLONG tRam, aRam;
- Bunit unit = BunitMB;
-};
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(printInfoStruct&);
-static int check_memory(printInfoStruct&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
printInfoStruct printInfo = {};
po::variables_map vm;
- int ret = parseArguments(argc, argv, vm, printInfo);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
-int parseArguments(int ac, wchar_t ** av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR ** av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print help message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print help message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("warning,w", po::wvalue<wstring>(), "warning threshold")
- ("critical,c", po::wvalue<wstring>(), "critical threshold")
- ("unit,u", po::wvalue<wstring>(), "the unit to use for display (default MB)")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning threshold")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical threshold")
+ ("unit,u", po::wvalue<std::wstring>(), "The unit to use for display (default MB)")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines physical memory.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tMEMORY WARNING - 50%% free | memory=2024MB;3000;500;0;4096\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too.\n"
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version"))
- wcout << L"Version: " << VERSION << endl;
+ std::wcout << L"Version: " << VERSION << '\n';
if (vm.count("warning")) {
try {
- printInfo.warn = threshold(vm["warning"].as<wstring>());
+ printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
printInfo.warn.legal = !printInfo.warn.legal;
if (vm.count("critical")) {
try {
- printInfo.crit = threshold(vm["critical"].as<wstring>());
+ printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
printInfo.crit.legal = !printInfo.crit.legal;
if (vm.count("unit")) {
try {
- printInfo.unit = parseBUnit(vm["unit"].as<wstring>());
+ printInfo.unit = parseBUnit(vm["unit"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
return -1;
}
-int printOutput(printInfoStruct& printInfo)
+INT printOutput(printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
double fswap = ((double)printInfo.aRam / (double)printInfo.tRam) * 100.0;
switch (state) {
case OK:
- wcout << L"MEMORY OK - " << fswap << L"% free | memory=" << printInfo.aRam << BunitStr(printInfo.unit) << L";"
+ std::wcout << L"MEMORY OK - " << fswap << L"% free | memory=" << printInfo.aRam << BunitStr(printInfo.unit) << L";"
<< printInfo.warn.pString(printInfo.tRam) << L";" << printInfo.crit.pString(printInfo.tRam)
- << L";0;" << printInfo.tRam << endl;
+ << L";0;" << printInfo.tRam << '\n';
break;
case WARNING:
- wcout << L"MEMORY WARNING - " << fswap << L"% free | memory=" << printInfo.aRam << BunitStr(printInfo.unit) << L";"
+ std::wcout << L"MEMORY WARNING - " << fswap << L"% free | memory=" << printInfo.aRam << BunitStr(printInfo.unit) << L";"
<< printInfo.warn.pString(printInfo.tRam) << L";" << printInfo.crit.pString(printInfo.tRam)
- << L";0;" << printInfo.tRam << endl;
+ << L";0;" << printInfo.tRam << '\n';
break;
case CRITICAL:
- wcout << L"MEMORY CRITICAL - " << fswap << L"% free | memory=" << printInfo.aRam << BunitStr(printInfo.unit) << L";"
+ std::wcout << L"MEMORY CRITICAL - " << fswap << L"% free | memory=" << printInfo.aRam << BunitStr(printInfo.unit) << L";"
<< printInfo.warn.pString(printInfo.tRam) << L";" << printInfo.crit.pString(printInfo.tRam)
- << L";0;" << printInfo.tRam << endl;
+ << L";0;" << printInfo.tRam << '\n';
break;
}
return state;
}
-int check_memory(printInfoStruct& printInfo)
+INT check_memory(printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Accessing memory statistics via MemoryStatus" << endl;
+ std::wcout << L"Accessing memory statistics via MemoryStatus" << '\n';
_MEMORYSTATUSEX *pMemBuf = new _MEMORYSTATUSEX;
printInfo.aRam = round(pMemBuf->ullAvailPhys / pow(1024.0, printInfo.unit));
if (debug)
- wcout << L"Found pMemBuf->dwTotalPhys: " << pMemBuf->ullTotalPhys << endl
- << L"Found pMemBuf->dwAvailPhys: " << pMemBuf->ullAvailPhys << endl;
+ std::wcout << L"Found pMemBuf->dwTotalPhys: " << pMemBuf->ullTotalPhys << '\n'
+ << L"Found pMemBuf->dwAvailPhys: " << pMemBuf->ullAvailPhys << '\n';
delete pMemBuf;
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_MEMORY_H
+#define CHECK_MEMORY_H
+
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+ DWORDLONG tRam, aRam;
+ Bunit unit = BunitMB;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(printInfoStruct&);
+INT check_memory(printInfoStruct&);
+
+#endif // !CHECK_MEMORY_H
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
+
+#define WIN32_LEAN_AND_MEAN
+
#include <Windows.h>
#include <Pdh.h>
#include <Shlwapi.h>
#include <iostream>
#include <pdhmsg.h>
+#include <WinSock2.h>
+#include <map>
-#include "thresholds.h"
+#include <IPHlpApi.h>
-#include "boost/program_options.hpp"
+#include "check_network.h"
-#define VERSION 1.0
-namespace po = boost::program_options;
+#define VERSION 1.1
-using std::endl; using std::vector; using std::wstring;
-using std::wcout; using std::cout;
+namespace po = boost::program_options;
static BOOL debug = FALSE;
-struct nInterface
+INT wmain(INT argc, WCHAR **argv)
{
- wstring name;
- long BytesInSec, BytesOutSec;
- nInterface(wstring p)
- : name(p)
- {}
-};
-
-struct printInfoStruct
-{
- threshold warn, crit;
-};
+ std::vector<nInterface> vInterfaces;
+ std::map<std::wstring, std::wstring> mapNames;
+ printInfoStruct printInfo{};
+ po::variables_map vm;
-static int parseArguments(int, TCHAR **, po::variables_map&, printInfoStruct&);
-static int printOutput(printInfoStruct&, const vector<nInterface>&);
-static int check_network(vector<nInterface>&);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
-int wmain(int argc, wchar_t **argv)
-{
- vector<nInterface> vInterfaces;
- printInfoStruct printInfo{ };
- po::variables_map vm;
- int ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
+ if (!mapSystemNamesToFamiliarNames(mapNames))
+ return 3;
+
ret = check_network(vInterfaces);
if (ret != -1)
return ret;
- return printOutput(printInfo, vInterfaces);
+ return printOutput(printInfo, vInterfaces, mapNames);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc("Options");
("help,h", "print usage and exit")
("version,V", "print version and exit")
("debug,d", "Verbose/Debug output")
- ("warning,w", po::wvalue<wstring>(), "warning value")
- ("critical,c", po::wvalue<wstring>(), "critical value")
+ ("warning,w", po::wvalue<std::wstring>(), "warning value")
+ ("critical,c", po::wvalue<std::wstring>(), "critical value")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
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);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tNETWORK WARNING 1131B/s | network=1131B/s;1000;7000;0\n\n"
- L"\"DISK\" being the type of the check, \"WARNING\" the returned status\n"
+ L"\"NETWORK\" being the type of the check, \"WARNING\" the returned status\n"
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"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too."
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version"))
- cout << "Version: " << VERSION << endl;
+ std::cout << "Version: " << VERSION << '\n';
if (vm.count("warning")) {
try {
- printInfo.warn = threshold(vm["warning"].as<wstring>());
+ printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
try {
- printInfo.crit = threshold(vm["critical"].as<wstring>());
+ printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
return -1;
}
-int printOutput(printInfoStruct& printInfo, const vector<nInterface>& vInterfaces)
+INT printOutput(printInfoStruct& printInfo, CONST std::vector<nInterface>& vInterfaces, CONST std::map<std::wstring, std::wstring>& mapNames)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
long tIn = 0, tOut = 0;
std::wstringstream tss, perfDataFirst;
state state = OK;
- for (vector<nInterface>::const_iterator it = vInterfaces.begin(); it != vInterfaces.end(); ++it) {
+ 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) {
tIn += it->BytesInSec;
tOut += it->BytesOutSec;
- tss << L"netI=\"" << it->name << L"\";in=" << it->BytesInSec << L"B/s;out=" << it->BytesOutSec << L"B/s ";
+ 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;
+ }
+ tss << L"netI=\"" << wsFriendlyName << L"\";in=" << it->BytesInSec << "B/s;out=" << it->BytesOutSec << L"B/s ";
}
if (printInfo.warn.rend(tIn + tOut))
state = WARNING;
if (printInfo.crit.rend(tIn + tOut))
state = CRITICAL;
-
+
perfDataFirst << L"network=" << tIn + tOut << L"B/s;" << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";" << L"0; ";
switch (state) {
case OK:
- wcout << L"NETWORK OK " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << endl;
+ std::wcout << L"NETWORK OK " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << '\n';
break;
case WARNING:
- wcout << L"NETWORK WARNING " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << endl;
+ std::wcout << L"NETWORK WARNING " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << '\n';
break;
case CRITICAL:
- wcout << L"NETWORK CRITICAL " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << endl;
+ std::wcout << L"NETWORK CRITICAL " << tIn + tOut << L"B/s | " << perfDataFirst.str() << tss.str() << '\n';
break;
}
return state;
}
-int check_network(vector <nInterface>& vInterfaces)
+INT check_network(std::vector <nInterface>& vInterfaces)
{
- const wchar_t *perfIn = L"\\Network Interface(*)\\Bytes Received/sec";
- const wchar_t *perfOut = L"\\Network Interface(*)\\Bytes Sent/sec";
+ CONST WCHAR *perfIn = L"\\Network Interface(*)\\Bytes Received/sec";
+ CONST WCHAR *perfOut = L"\\Network Interface(*)\\Bytes Sent/sec";
PDH_HQUERY phQuery = NULL;
PDH_HCOUNTER phCounterIn, phCounterOut;
PDH_STATUS err;
if (debug)
- wcout << L"Creating Query and adding counters" << endl;
+ std::wcout << L"Creating Query and adding counters" << '\n';
err = PdhOpenQuery(NULL, NULL, &phQuery);
if (!SUCCEEDED(err))
goto die;
if (debug)
- wcout << L"Collecting first batch of query data" << endl;
+ std::wcout << L"Collecting first batch of query data" << '\n';
err = PdhCollectQueryData(phQuery);
if (!SUCCEEDED(err))
goto die;
if (debug)
- wcout << L"Sleep for one second" << endl;
+ std::wcout << L"Sleep for one second" << '\n';
Sleep(1000);
if (debug)
- wcout << L"Collecting second batch of query data" << endl;
+ std::wcout << L"Collecting second batch of query data" << '\n';
err = PdhCollectQueryData(phQuery);
if (!SUCCEEDED(err))
goto die;
if (debug)
- wcout << L"Creating formatted counter arrays" << endl;
+ std::wcout << L"Creating formatted counter arrays" << '\n';
err = PdhGetFormattedCounterArray(phCounterIn, PDH_FMT_LONG, &dwBufferSizeIn, &dwItemCount, pDisplayValuesIn);
if (err == PDH_MORE_DATA || SUCCEEDED(err))
goto die;
if (debug)
- wcout << L"Going over counter array" << endl;
+ std::wcout << L"Going over counter array" << '\n';
for (DWORD i = 0; i < dwItemCount; i++) {
- nInterface *iface = new nInterface(wstring(pDisplayValuesIn[i].szName));
+ 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)
- wcout << L"Collected interface " << pDisplayValuesIn[i].szName << endl;
+ std::wcout << L"Collected interface " << pDisplayValuesIn[i].szName << '\n';
}
if (debug)
- wcout << L"Finished collection. Cleaning up and returning" << endl;
+ std::wcout << L"Finished collection. Cleaning up and returning" << '\n';
if (phQuery)
PdhCloseQuery(phQuery);
if (pDisplayValuesOut)
delete reinterpret_cast<PDH_FMT_COUNTERVALUE_ITEM*>(pDisplayValuesOut);
return 3;
-}
\ No newline at end of file
+}
+
+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;
+}
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_NETWORK_H
+#define CHECK_NETWORK_H
+#include <vector>
+
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct nInterface
+{
+ std::wstring name;
+ LONG BytesInSec, BytesOutSec;
+ nInterface(std::wstring p)
+ : name(p)
+ {
+ }
+};
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(printInfoStruct&, CONST std::vector<nInterface>&, CONST std::map<std::wstring, std::wstring>&);
+INT check_network(std::vector<nInterface>&);
+BOOL mapSystemNamesToFamiliarNames(std::map<std::wstring, std::wstring>&);
+
+#endif // !CHECK_NETWORK_H
#include <iostream>
-#include "thresholds.h"
-#include "boost/program_options.hpp"
+#include "check_ping.h"
#define VERSION 1.0
namespace po = boost::program_options;
-using std::cout; using std::endl; using std::wcout;
-using std::wstring; using std::string;
static BOOL debug = FALSE;
-struct response
-{
- double avg;
- UINT pMin = 0, pMax = 0, dropped = 0;
-};
-
-struct printInfoStruct
-{
- threshold warn, crit;
- threshold wpl, cpl;
- wstring host;
- BOOL ipv4 = TRUE;
- DWORD timeout = 1000;
- int num = 5;
-};
-
-static int printOutput(printInfoStruct&, response&);
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int check_ping4(const printInfoStruct&, response&);
-static int check_ping6(const printInfoStruct&, response&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
po::variables_map vm;
printInfoStruct printInfo;
return printOutput(printInfo, response);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print usage message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print usage message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("host,H", po::wvalue<wstring>()->required(), "host ip to ping")
- (",4", "--host is an ipv4 address (default)")
- (",6", "--host is an ipv6 address")
- ("timeout,T", po::value<int>(), "specify timeout for requests in ms (default=1000)")
- ("ncount,n", po::value<int>(), "declare ping count (default=5)")
- ("warning,w", po::wvalue<wstring>(), "warning values: rtt,package loss")
- ("critical,c", po::wvalue<wstring>(), "critical values: rtt,package loss")
+ ("host,H", po::wvalue<std::wstring>()->required(), "Host ip to ping")
+ (",4", "--Host is an ipv4 address (default)")
+ (",6", "--Host is an ipv6 address")
+ ("timeout,t", po::value<INT>(), "Specify timeout for requests in ms (default=1000)")
+ ("packets,p", po::value<INT>(), "Declare ping count (default=5)")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning values: rtt,package loss")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical values: rtt,package loss")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to ping an ip4 address.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will take at least timeout times number of pings to run\n"
L"Then it will output a string looking something like this:\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too."
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version")) {
- cout << progName << " Version: " << VERSION << endl;
+ std::cout << progName << " Version: " << VERSION << '\n';
return 0;
}
if (vm.count("-4") && vm.count("-6")) {
- cout << "Conflicting options \"4\" and \"6\"" << endl;
+ std::cout << "Conflicting options \"4\" and \"6\"" << '\n';
return 3;
}
if (vm.count("warning")) {
- std::vector<wstring> sVec = splitMultiOptions(vm["warning"].as<wstring>());
+ std::vector<std::wstring> sVec = splitMultiOptions(vm["warning"].as<std::wstring>());
if (sVec.size() != 2) {
- cout << "Wrong format for warning thresholds" << endl;
+ std::cout << "Wrong format for warning thresholds" << '\n';
return 3;
}
try {
printInfo.warn = threshold(*sVec.begin());
printInfo.wpl = threshold(sVec.back());
if (!printInfo.wpl.perc) {
- cout << "Packet loss must be percentage" << endl;
+ std::cout << "Packet loss must be percentage" << '\n';
return 3;
}
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
- std::vector<wstring> sVec = splitMultiOptions(vm["critical"].as<wstring>());
+ std::vector<std::wstring> sVec = splitMultiOptions(vm["critical"].as<std::wstring>());
if (sVec.size() != 2) {
- cout << "Wrong format for critical thresholds" << endl;
+ std::cout << "Wrong format for critical thresholds" << '\n';
return 3;
}
try {
printInfo.crit = threshold(*sVec.begin());
printInfo.cpl = threshold(sVec.back());
if (!printInfo.wpl.perc) {
- cout << "Packet loss must be percentage" << endl;
+ std::cout << "Packet loss must be percentage" << '\n';
return 3;
}
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("timeout"))
- printInfo.timeout = vm["timeout"].as<int>();
+ printInfo.timeout = vm["timeout"].as<INT>();
if (vm.count("count"))
- printInfo.num = vm["count"].as<int>();
+ printInfo.num = vm["count"].as<INT>();
if (vm.count("-6"))
printInfo.ipv4 = FALSE;
- printInfo.host = vm["host"].as<wstring>();
+ printInfo.host = vm["host"].as<std::wstring>();
if (vm.count("debug"))
debug = TRUE;
return -1;
}
-int printOutput(printInfoStruct& printInfo, response& response)
+INT printOutput(printInfoStruct& printInfo, response& response)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
<< printInfo.wpl.pString() << ";" << printInfo.cpl.pString() << ";0;100";
if (response.dropped == printInfo.num) {
- wcout << L"PING CRITICAL ALL CONNECTIONS DROPPED | " << perf.str() << endl;
+ std::wcout << L"PING CRITICAL ALL CONNECTIONS DROPPED | " << perf.str() << '\n';
return 3;
}
switch (state) {
case OK:
- wcout << L"PING OK RTA: " << response.avg << L"ms Packet loss: " << removeZero(plp) << "% | " << perf.str() << endl;
+ std::wcout << L"PING OK RTA: " << response.avg << L"ms Packet loss: " << removeZero(plp) << "% | " << perf.str() << '\n';
break;
case WARNING:
- wcout << L"PING WARNING RTA: " << response.avg << L"ms Packet loss: " << removeZero(plp) << "% | " << perf.str() << endl;
+ std::wcout << L"PING WARNING RTA: " << response.avg << L"ms Packet loss: " << removeZero(plp) << "% | " << perf.str() << '\n';
break;
case CRITICAL:
- wcout << L"PING CRITICAL RTA: " << response.avg << L"ms Packet loss: " << removeZero(plp) << "% | " << perf.str() << endl;
+ std::wcout << L"PING CRITICAL RTA: " << response.avg << L"ms Packet loss: " << removeZero(plp) << "% | " << perf.str() << '\n';
break;
}
return state;
}
-int check_ping4(const printInfoStruct& pi, response& response)
+INT check_ping4(const printInfoStruct& pi, response& response)
{
in_addr ipDest4;
HANDLE hIcmp;
DWORD dwRet = 0, dwRepSize = 0;
LPVOID repBuf = NULL;
UINT rtt = 0;
- int num = pi.num;
+ INT num = pi.num;
LARGE_INTEGER frequency, timer1, timer2;
LPCWSTR term;
if (debug)
- wcout << L"Parsing ip address" << endl;
+ std::wcout << L"Parsing ip address" << '\n';
if (RtlIpv4StringToAddress(pi.host.c_str(), TRUE, &term, &ipDest4) == STATUS_INVALID_PARAMETER) {
- std::wcout << pi.host << " is not a valid ip address" << std::endl;
+ std::wcout << pi.host << " is not a valid ip address\n";
return 3;
}
if (*term != L'\0') {
- std::wcout << pi.host << " is not a valid ip address" << std::endl;
+ std::wcout << pi.host << " is not a valid ip address\n";
return 3;
}
if (debug)
- wcout << L"Creating Icmp File" << endl;
+ std::wcout << L"Creating Icmp File\n";
if ((hIcmp = IcmpCreateFile()) == INVALID_HANDLE_VALUE)
goto die;
QueryPerformanceCounter(&timer1);
if (debug)
- wcout << L"Sending Icmp echo" << endl;
+ std::wcout << L"Sending Icmp echo\n";
if (!IcmpSendEcho2(hIcmp, NULL, NULL, NULL, ipDest4.S_un.S_addr,
NULL, 0, NULL, repBuf, dwRepSize, pi.timeout)) {
response.dropped++;
if (debug)
- wcout << L"Dropped: Response was 0" << endl;
+ std::wcout << L"Dropped: Response was 0" << '\n';
continue;
}
if (debug)
- wcout << "Ping recieved" << endl;
+ std::wcout << "Ping recieved" << '\n';
PICMP_ECHO_REPLY pEchoReply = static_cast<PICMP_ECHO_REPLY>(repBuf);
if (pEchoReply->Status != IP_SUCCESS) {
response.dropped++;
if (debug)
- wcout << L"Dropped: echo reply status " << pEchoReply->Status << endl;
+ std::wcout << L"Dropped: echo reply status " << pEchoReply->Status << '\n';
continue;
}
if (debug)
- wcout << L"Recorded rtt of " << pEchoReply->RoundTripTime << endl;
+ std::wcout << L"Recorded rtt of " << pEchoReply->RoundTripTime << '\n';
rtt += pEchoReply->RoundTripTime;
if (response.pMin == 0 || pEchoReply->RoundTripTime < response.pMin)
} while (--num);
if (debug)
- wcout << L"All pings sent. Cleaning up and returning" << endl;
+ std::wcout << L"All pings sent. Cleaning up and returning" << '\n';
if (hIcmp)
IcmpCloseHandle(hIcmp);
return 3;
}
-int check_ping6(const printInfoStruct& pi, response& response)
+INT check_ping6(const printInfoStruct& pi, response& response)
{
- PCWSTR term;
sockaddr_in6 ipDest6, ipSource6;
IP_OPTION_INFORMATION ipInfo = { 30, 0, 0, 0, NULL };
DWORD dwRepSize = sizeof(ICMPV6_ECHO_REPLY) + 8;
HANDLE hIcmp = NULL;
LARGE_INTEGER frequency, timer1, timer2;
- int num = pi.num;
+ INT num = pi.num;
UINT rtt = 0;
if (debug)
- wcout << L"Parsing ip address" << endl;
+ std::wcout << L"Parsing ip address" << '\n';
if (RtlIpv6StringToAddressEx(pi.host.c_str(), &ipDest6.sin6_addr, &ipDest6.sin6_scope_id, &ipDest6.sin6_port)) {
- std::wcout << pi.host << " is not a valid ipv6 address" << std::endl;
+ std::wcout << pi.host << " is not a valid ipv6 address" << '\n';
return 3;
}
ipSource6.sin6_port = 0;
if (debug)
- wcout << L"Creating Icmp File" << endl;
+ std::wcout << L"Creating Icmp File" << '\n';
hIcmp = Icmp6CreateFile();
if (hIcmp == INVALID_HANDLE_VALUE) {
QueryPerformanceCounter(&timer1);
if (debug)
- wcout << L"Sending Icmp echo" << endl;
+ std::wcout << L"Sending Icmp echo" << '\n';
if (!Icmp6SendEcho2(hIcmp, NULL, NULL, NULL, &ipSource6, &ipDest6,
NULL, 0, &ipInfo, repBuf, dwRepSize, pi.timeout)) {
response.dropped++;
if (debug)
- wcout << L"Dropped: Response was 0" << endl;
+ std::wcout << L"Dropped: Response was 0" << '\n';
continue;
}
if (debug)
- wcout << "Ping recieved" << endl;
+ std::wcout << "Ping recieved" << '\n';
Icmp6ParseReplies(repBuf, dwRepSize);
if (pEchoReply->Status != IP_SUCCESS) {
response.dropped++;
if (debug)
- wcout << L"Dropped: echo reply status " << pEchoReply->Status << endl;
+ std::wcout << L"Dropped: echo reply status " << pEchoReply->Status << '\n';
continue;
}
rtt += pEchoReply->RoundTripTime;
if (debug)
- wcout << L"Recorded rtt of " << pEchoReply->RoundTripTime << endl;
+ std::wcout << L"Recorded rtt of " << pEchoReply->RoundTripTime << '\n';
if (response.pMin == 0 || pEchoReply->RoundTripTime < response.pMin)
response.pMin = pEchoReply->RoundTripTime;
} while (--num);
if (debug)
- wcout << L"All pings sent. Cleaning up and returning" << endl;
+ std::wcout << L"All pings sent. Cleaning up and returning" << '\n';
if (hIcmp)
IcmpCloseHandle(hIcmp);
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_PING_H
+#define CHECK_PING_H
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct response
+{
+ DOUBLE avg;
+ UINT pMin = 0, pMax = 0, dropped = 0;
+};
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+ threshold wpl, cpl;
+ std::wstring host;
+ BOOL ipv4 = TRUE;
+ DWORD timeout = 1000;
+ INT num = 5;
+};
+
+INT printOutput(printInfoStruct&, response&);
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT check_ping4(CONST printInfoStruct&, response&);
+INT check_ping6(CONST printInfoStruct&, response&);
+
+#endif // !CHECK_PING_H
#include <tlhelp32.h>
#include <iostream>
-#include "thresholds.h"
-
-#include "boost/program_options.hpp"
+#include "check_procs.h"
#define VERSION 1.0
namespace po = boost::program_options;
-using std::endl; using std::wstring; using std::wcout;
-using std::cout;
-
static BOOL debug = FALSE;
-struct printInfoStruct
-{
- threshold warn, crit;
- wstring user;
-};
-
-static int countProcs();
-static int countProcs(const wstring);
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(const int, printInfoStruct&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
po::variables_map vm;
printInfoStruct printInfo = { };
- int r = parseArguments(argc, argv, vm, printInfo);
+ INT r = parseArguments(argc, argv, vm, printInfo);
if (r != -1)
return r;
return printOutput(countProcs(), printInfo);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print help message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print help message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("user,u", po::wvalue<wstring>(), "count only processes by user [arg]")
- ("warning,w", po::wvalue<wstring>(), "warning threshold")
- ("critical,c", po::wvalue<wstring>(), "critical threshold")
+ ("user,u", po::wvalue<std::wstring>(), "Count only processes of user")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning threshold")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical threshold")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- std::cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines processes.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tPROCS WARNING 67 | load=67;50;90;0\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too."
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version")) {
- std::cout << "Version: " << VERSION << endl;
+ std::wcout << "Version: " << VERSION << '\n';
return 0;
}
if (vm.count("warning")) {
try {
- printInfo.warn = threshold(vm["warning"].as<wstring>());
+ printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
try {
- printInfo.crit = threshold(vm["critical"].as<wstring>());
+ printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("user"))
- printInfo.user = vm["user"].as<wstring>();
+ printInfo.user = vm["user"].as<std::wstring>();
if (vm.count("debug"))
debug = TRUE;
return -1;
}
-int printOutput(const int numProcs, printInfoStruct& printInfo)
+INT printOutput(CONST INT numProcs, printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
if (printInfo.crit.rend(numProcs))
state = CRITICAL;
- wstring user = L"";
+ std::wstring user = L"";
if (!printInfo.user.empty())
user.append(L" processes of user ").append(printInfo.user);
switch (state) {
case OK:
- wcout << L"PROCS OK " << numProcs << user << L" | procs=" << numProcs << L";"
- << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << endl;
+ std::wcout << L"PROCS OK " << numProcs << user << L" | procs=" << numProcs << L";"
+ << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << '\n';
break;
case WARNING:
- wcout << L"PROCS WARNING " << numProcs << user << L" | procs=" << numProcs << L";"
- << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << endl;
+ std::wcout << L"PROCS WARNING " << numProcs << user << L" | procs=" << numProcs << L";"
+ << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << '\n';
break;
case CRITICAL:
- wcout << L"PROCS CRITICAL " << numProcs << user << L" | procs=" << numProcs << L";"
- << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << endl;
+ std::wcout << L"PROCS CRITICAL " << numProcs << user << L" | procs=" << numProcs << L";"
+ << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << '\n';
break;
}
return state;
}
-int countProcs()
+INT countProcs()
{
if (debug)
- wcout << L"Counting all processes" << endl;
+ std::wcout << L"Counting all processes" << '\n';
HANDLE hProcessSnap = NULL;
PROCESSENTRY32 pe32;
if (debug)
- wcout << L"Creating snapshot" << endl;
+ std::wcout << L"Creating snapshot" << '\n';
hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE)
pe32.dwSize = sizeof(PROCESSENTRY32);
if (debug)
- wcout << L"Grabbing first proccess" << endl;
+ std::wcout << L"Grabbing first proccess" << '\n';
if (!Process32First(hProcessSnap, &pe32)) {
CloseHandle(hProcessSnap);
return -1;
}
- int numProcs = 0;
+ INT numProcs = 0;
if (debug)
- wcout << L"Counting processes..." << endl;
+ std::wcout << L"Counting processes..." << '\n';
do {
++numProcs;
} while (Process32Next(hProcessSnap, &pe32));
if (debug)
- wcout << L"Found " << numProcs << L" processes. Cleaning up udn returning" << endl;
+ std::wcout << L"Found " << numProcs << L" processes. Cleaning up udn returning" << '\n';
if (hProcessSnap)
CloseHandle(hProcessSnap);
return numProcs;
}
-int countProcs(const wstring user)
+INT countProcs(CONST std::wstring user)
{
if (debug)
- wcout << L"Counting all processes of user" << user << endl;
+ std::wcout << L"Counting all processes of user" << user << '\n';
- const wchar_t *wuser = user.c_str();
- int numProcs = 0;
+ CONST WCHAR *wuser = user.c_str();
+ INT numProcs = 0;
HANDLE hProcessSnap, hProcess = NULL, hToken = NULL;
PROCESSENTRY32 pe32;
LPWSTR AcctName, DomainName;
if (debug)
- wcout << L"Creating snapshot" << endl;
+ std::wcout << L"Creating snapshot" << '\n';
hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE)
pe32.dwSize = sizeof(PROCESSENTRY32);
if (debug)
- wcout << L"Grabbing first proccess" << endl;
+ std::wcout << L"Grabbing first proccess" << '\n';
if (!Process32First(hProcessSnap, &pe32))
goto die;
if (debug)
- wcout << L"Counting processes..." << endl;
+ std::wcout << L"Counting processes..." << '\n';
do {
if (debug)
- wcout << L"Getting process token" << endl;
+ std::wcout << L"Getting process token" << '\n';
//get ProcessToken
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pe32.th32ProcessID);
memset(pSIDTokenUser, 0, dwReturnLength);
if (debug)
- wcout << L"Received token, saving information" << endl;
+ std::wcout << L"Received token, saving information" << '\n';
//write Info in pSIDTokenUser
if (!GetTokenInformation(hToken, TokenUser, pSIDTokenUser, dwReturnLength, NULL))
dwDomainName = 1;
if (debug)
- wcout << L"Looking up SID" << endl;
+ std::wcout << L"Looking up SID" << '\n';
//get dwAcctName and dwDomainName size
if (!LookupAccountSid(NULL, pSIDTokenUser->User.Sid, AcctName,
continue;
if (debug)
- wcout << L"Comparing " << AcctName << L" to " << wuser << endl;
+ std::wcout << L"Comparing " << AcctName << L" to " << wuser << '\n';
if (!wcscmp(AcctName, wuser)) {
++numProcs;
if (debug)
- wcout << L"Is process of " << wuser << L" (" << numProcs << L")" << endl;
+ std::wcout << L"Is process of " << wuser << L" (" << numProcs << L")" << '\n';
}
delete[] reinterpret_cast<LPWSTR>(AcctName);
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_PROCS_H
+#define CHECK_PROCS_H
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+ std::wstring user;
+};
+
+INT countProcs();
+INT countProcs(CONST std::wstring);
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(CONST INT, printInfoStruct&);
+
+#endif // !CHECK_PROCS_H
#include <Shlwapi.h>
#include <iostream>
-#include "thresholds.h"
+#include "check_service.h"
-#include "boost/program_options.hpp"
#define VERSION 1.1
namespace po = boost::program_options;
-using std::wcout; using std::endl;
-using std::cout; using std::wstring;
-
static BOOL debug;
-struct printInfoStruct
-{
- bool warn;
- DWORD ServiceState;
- wstring service;
-};
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(const printInfoStruct&);
-static DWORD ServiceStatus(const printInfoStruct&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
po::variables_map vm;
printInfoStruct printInfo = { false, 0, L"" };
- int ret = parseArguments(argc, argv, vm, printInfo);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print help message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print help message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("service,s", po::wvalue<wstring>(), "service to check (required)")
- ("warn,w", "return warning (1) instead of critical (2),\n when service is not running")
+ ("service,s", po::wvalue<std::wstring>(), "Service to check (required)")
+ ("warn,w", "Return warning (1) instead of critical (2),\n when service is not running")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check the status of a service.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tSERVICE CRITICAL NOT_RUNNING | service=4;!4;!4;1;7\n\n"
L"all \"-w\" and \"-c\" do is say whether a not running service is a warning\n"
L"or critical state respectively.\n\n"
, progName, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version")) {
- cout << "Version: " << VERSION << endl;
+ std::cout << "Version: " << VERSION << '\n';
return 0;
}
if (!vm.count("service")) {
- cout << "Missing argument: service" << endl << desc << endl;
+ std::cout << "Missing argument: service" << '\n' << desc << '\n';
return 3;
}
if (vm.count("warn"))
printInfo.warn = true;
- printInfo.service = vm["service"].as<wstring>();
+ printInfo.service = vm["service"].as<std::wstring>();
if (vm.count("debug"))
debug = TRUE;
return -1;
}
-int printOutput(const printInfoStruct& printInfo)
+INT printOutput(CONST printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
- wstring perf;
+ std::wstring perf;
state state = OK;
if (!printInfo.ServiceState) {
- wcout << L"SERVICE CRITICAL NOTFOUND | service=" << printInfo.ServiceState << ";!4;!4;1;7" << endl;
+ std::wcout << L"SERVICE CRITICAL NOTFOUND | service=" << printInfo.ServiceState << ";!4;!4;1;7" << '\n';
return 3;
}
switch (state) {
case OK:
- wcout << L"SERVICE OK RUNNING | service=4;!4;!4;1;7" << endl;
+ std::wcout << L"SERVICE OK RUNNING | service=4;!4;!4;1;7" << '\n';
break;
case WARNING:
- wcout << L"SERVICE WARNING NOT RUNNING | service=" << printInfo.ServiceState << ";!4;!4;1;7" << endl;
+ std::wcout << L"SERVICE WARNING NOT RUNNING | service=" << printInfo.ServiceState << ";!4;!4;1;7" << '\n';
break;
case CRITICAL:
- wcout << L"SERVICE CRITICAL NOT RUNNING | service=" << printInfo.ServiceState << ";!4;!4;1;7" << endl;
+ std::wcout << L"SERVICE CRITICAL NOT RUNNING | service=" << printInfo.ServiceState << ";!4;!4;1;7" << '\n';
break;
}
return state;
}
-DWORD ServiceStatus(const printInfoStruct& printInfo)
+DWORD ServiceStatus(CONST printInfoStruct& printInfo)
{
SC_HANDLE hSCM;
SC_HANDLE hService;
LPBYTE lpBuf = NULL;
if (debug)
- wcout << L"Opening SC Manager" << endl;
+ std::wcout << L"Opening SC Manager" << '\n';
hSCM = OpenSCManager(NULL, NULL, GENERIC_READ);
if (hSCM == NULL)
goto die;
if (debug)
- wcout << L"Getting Service Information" << endl;
+ std::wcout << L"Getting Service Information" << '\n';
hService = OpenService(hSCM, printInfo.service.c_str(), SERVICE_QUERY_STATUS);
if (hService == NULL)
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_SERVICE_H
+#define CHECK_SERVICE_H
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct printInfoStruct
+{
+ BOOL warn;
+ DWORD ServiceState;
+ std::wstring service;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(CONST printInfoStruct&);
+DWORD ServiceStatus(CONST printInfoStruct&);
+
+#endif // !CHECK_SERVICE_H
#include <iostream>
#include <WinBase.h>
-#include "thresholds.h"
-
-#include "boost/program_options.hpp"
+#include "check_swap.h"
#define VERSION 1.0
namespace po = boost::program_options;
-using std::endl; using std::wcout; using std::wstring;
-using std::cout;
-
static BOOL debug = FALSE;
-struct printInfoStruct
-{
- threshold warn, crit;
- double tSwap, aSwap;
- Bunit unit = BunitMB;
-};
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(printInfoStruct&);
-static int check_swap(printInfoStruct&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
printInfoStruct printInfo = { };
po::variables_map vm;
- int ret = parseArguments(argc, argv, vm, printInfo);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print help message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print help message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("warning,w", po::wvalue<wstring>(), "warning threshold")
- ("critical,c", po::wvalue<wstring>(), "critical threshold")
- ("unit,u", po::wvalue<wstring>(), "the unit to use for display (default MB)")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning threshold")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical threshold")
+ ("unit,u", po::wvalue<std::wstring>(), "The unit to use for display (default MB)")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines swap in percent.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tSWAP WARNING - 20%% free | swap=2000B;3000;500;0;10000\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too.\n"
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version"))
- wcout << L"Version: " << VERSION << endl;
+ std::wcout << L"Version: " << VERSION << '\n';
if (vm.count("warning")) {
try {
- printInfo.warn = threshold(vm["warning"].as<wstring>());
+ printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
printInfo.warn.legal = !printInfo.warn.legal;
if (vm.count("critical")) {
try {
- printInfo.crit = threshold(vm["critical"].as<wstring>());
+ printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
printInfo.crit.legal = !printInfo.crit.legal;
if (vm.count("unit")) {
try {
- printInfo.unit = parseBUnit(vm["unit"].as<wstring>());
+ printInfo.unit = parseBUnit(vm["unit"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
return -1;
}
-int printOutput(printInfoStruct& printInfo)
+INT printOutput(printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
double fswap = ((double)printInfo.aSwap / (double)printInfo.tSwap) * 100.0;
switch (state) {
case OK:
- wcout << L"SWAP OK - " << fswap << L"% free | swap=" << printInfo.aSwap << BunitStr(printInfo.unit) << L";"
+ std::wcout << L"SWAP OK - " << fswap << L"% free | swap=" << printInfo.aSwap << BunitStr(printInfo.unit) << L";"
<< printInfo.warn.pString(printInfo.tSwap) << L";" << printInfo.crit.pString(printInfo.tSwap)
- << L";0;" << printInfo.tSwap << endl;
+ << L";0;" << printInfo.tSwap << '\n';
break;
case WARNING:
- wcout << L"SWAP WARNING - " << fswap << L"% free | swap=" << printInfo.aSwap << BunitStr(printInfo.unit) << L";"
+ std::wcout << L"SWAP WARNING - " << fswap << L"% free | swap=" << printInfo.aSwap << BunitStr(printInfo.unit) << L";"
<< printInfo.warn.pString(printInfo.tSwap) << L";" << printInfo.crit.pString(printInfo.tSwap)
- << L";0;" << printInfo.tSwap << endl;
+ << L";0;" << printInfo.tSwap << '\n';
break;
case CRITICAL:
- wcout << L"SWAP CRITICAL - " << fswap << L"% free | swap=" << printInfo.aSwap << BunitStr(printInfo.unit) << L";"
+ std::wcout << L"SWAP CRITICAL - " << fswap << L"% free | swap=" << printInfo.aSwap << BunitStr(printInfo.unit) << L";"
<< printInfo.warn.pString(printInfo.tSwap) << L";" << printInfo.crit.pString(printInfo.tSwap)
- << L";0;" << printInfo.tSwap << endl;
+ << L";0;" << printInfo.tSwap << '\n';
break;
}
return state;
}
-int check_swap(printInfoStruct& printInfo)
+INT check_swap(printInfoStruct& printInfo)
{
MEMORYSTATUSEX MemBuf;
MemBuf.dwLength = sizeof(MemBuf);
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_SWAP_H
+#define CHECK_SWAP_H
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+ DOUBLE tSwap, aSwap;
+ Bunit unit = BunitMB;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(printInfoStruct&);
+INT check_swap(printInfoStruct&);
+
+#endif // !CHECK_SWAP_H
#include <wuapi.h>
#include <wuerror.h>
-#include "thresholds.h"
-
-#include "boost/program_options.hpp"
+#include "check_update.h"
#define VERSION 1.0
namespace po = boost::program_options;
-using std::wcout; using std::endl;
-using std::wstring; using std::cout;
-
static BOOL debug = FALSE;
-struct printInfoStruct
-{
- BOOL warn, crit;
- LONG numUpdates;
- BOOL important, reboot, careForCanRequest;
-};
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(const printInfoStruct&);
-static int check_update(printInfoStruct&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
printInfoStruct printInfo = { FALSE, FALSE, 0, FALSE, FALSE, FALSE };
po::variables_map vm;
- int ret = parseArguments(argc, argv, vm, printInfo);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print help message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print help message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("warning,w", "warn if there are important updates available")
- ("critical,c", "critical if there are important updates that require a reboot")
- ("possible-reboot", "treat \"update may need reboot\" as \"update needs reboot\"")
+ ("warning,w", "Warn if there are important updates available")
+ ("critical,c", "Critical if there are important updates that require a reboot")
+ ("possible-reboot", "Treat \"update may need reboot\" as \"update needs reboot\"")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines required updates.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nAfter some time, it will then output a string like this one:\n\n"
L"\tUPDATE WARNING 8 | updates=8;1;1;0\n\n"
L"The \"possible-reboot\" option is not recommended since this true for nearly\n"
L"every update."
, progName, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
} if (vm.count("version")) {
- cout << "Version: " << VERSION << endl;
+ std::cout << "Version: " << VERSION << '\n';
return 0;
}
return -1;
}
-int printOutput(const printInfoStruct& printInfo)
+INT printOutput(const printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
- wstring output = L"UPDATE ";
+ std::wstring output = L"UPDATE ";
if (printInfo.important)
state = WARNING;
break;
}
- wcout << output << printInfo.numUpdates << L" | update=" << printInfo.numUpdates << L";"
- << printInfo.warn << L";" << printInfo.crit << L";0;" << endl;
+ std::wcout << output << printInfo.numUpdates << L" | update=" << printInfo.numUpdates << L";"
+ << printInfo.warn << L";" << printInfo.crit << L";0;" << '\n';
return state;
}
-int check_update(printInfoStruct& printInfo)
+INT check_update(printInfoStruct& printInfo)
{
if (debug)
- wcout << "Initializing COM library" << endl;
+ std::wcout << "Initializing COM library" << '\n';
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
ISearchResult *pResult;
IUpdateSession *pSession;
HRESULT err;
if (debug)
- wcout << "Creating UpdateSession and UpdateSearcher" << endl;
+ std::wcout << "Creating UpdateSession and UpdateSearcher" << '\n';
CoCreateInstance(CLSID_UpdateSession, NULL, CLSCTX_INPROC_SERVER, IID_IUpdateSession, (LPVOID*)&pSession);
pSession->CreateUpdateSearcher(&pSearcher);
// http://msdn.microsoft.com/en-us/library/ff357803%28v=vs.85%29.aspx
if (debug)
- wcout << L"Querrying updates from server" << endl;
+ std::wcout << L"Querrying updates from server" << '\n';
err = pSearcher->Search(criteria, &pResult);
if (!SUCCEEDED(err))
for (LONG i = 0; i < updateSize; i++) {
pCollection->get_Item(i, &pUpdate);
if (debug) {
- wcout << L"Checking reboot behaviour of update number " << i << endl;
+ std::wcout << L"Checking reboot behaviour of update number " << i << '\n';
}
pUpdate->get_InstallationBehavior(&pIbehav);
pIbehav->get_RebootBehavior(&updateReboot);
if (updateReboot == irbAlwaysRequiresReboot) {
printInfo.reboot = TRUE;
if (debug)
- wcout << L"It requires reboot" << endl;
+ std::wcout << L"It requires reboot" << '\n';
continue;
}
if (printInfo.careForCanRequest && updateReboot == irbCanRequestReboot)
if (debug)
- wcout << L"It requires reboot" << endl;
+ std::wcout << L"It requires reboot" << '\n';
printInfo.reboot = TRUE;
}
if (debug)
- wcout << L"Cleaning up and returning" << endl;
+ std::wcout << L"Cleaning up and returning" << '\n';
SysFreeString(criteria);
CoUninitialize();
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_UPDATE_H
+#define CHECK_UPDATE_H
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct printInfoStruct
+{
+ BOOL warn, crit;
+ LONG numUpdates;
+ BOOL important, reboot, careForCanRequest;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(CONST printInfoStruct&);
+INT check_update(printInfoStruct&);
+
+#endif // !CHECK_UPDATE_H
#include <Shlwapi.h>
#include <iostream>
-#include "thresholds.h"
+#include "check_uptime.h"
#include "boost/chrono.hpp"
-#include "boost/program_options.hpp"
#define VERSION 1.0
namespace po = boost::program_options;
-using std::cout; using std::endl;
-using std::wcout; using std::wstring;
-
static BOOL debug;
-struct printInfoStruct
-{
- threshold warn, crit;
- long long time;
- Tunit unit;
-};
-
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(printInfoStruct&);
-static void getUptime(printInfoStruct&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
po::variables_map vm;
printInfoStruct printInfo = { };
- int ret = parseArguments(argc, argv, vm, printInfo);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print help message and exit")
- ("version,V", "print version and exit")
- ("warning,w", po::wvalue<wstring>(), "warning threshold (Uses -unit)")
+ ("help,h", "Print help message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("critical,c", po::wvalue<wstring>(), "critical threshold (Uses -unit)")
- ("unit,u", po::wvalue<wstring>(), "desired unit of output\nh\t- hours\nm\t- minutes\ns\t- seconds (default)\nms\t- milliseconds")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning threshold (Uses -unit)")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical threshold (Uses -unit)")
+ ("unit,u", po::wvalue<std::wstring>(), "Unit to use:\nh\t- hours\nm\t- minutes\ns\t- seconds (default)\nms\t- milliseconds")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines uptime.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tUPTIME WARNING 712h | uptime=712h;700;1800;0\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too.\n"
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version")) {
- cout << VERSION << endl;
+ std::cout << VERSION << '\n';
return 0;
}
if (vm.count("warning")) {
try {
- printInfo.warn = threshold(vm["warning"].as<wstring>());
+ printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
try {
- printInfo.crit = threshold(vm["critical"].as<wstring>());
+ printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("unit")) {
try{
- printInfo.unit = parseTUnit(vm["unit"].as<wstring>());
+ printInfo.unit = parseTUnit(vm["unit"].as<std::wstring>());
} catch (std::invalid_argument) {
- wcout << L"Unknown unit type " << vm["unit"].as<wstring>() << endl;
+ std::wcout << L"Unknown unit type " << vm["unit"].as<std::wstring>() << '\n';
return 3;
}
} else
return -1;
}
-static int printOutput(printInfoStruct& printInfo)
+INT printOutput(printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
switch (state) {
case OK:
- wcout << L"UPTIME OK " << printInfo.time << TunitStr(printInfo.unit) << L" | uptime=" << printInfo.time
+ std::wcout << L"UPTIME OK " << printInfo.time << TunitStr(printInfo.unit) << L" | uptime=" << printInfo.time
<< TunitStr(printInfo.unit) << L";" << printInfo.warn.pString() << L";"
- << printInfo.crit.pString() << L";0;" << endl;
+ << printInfo.crit.pString() << L";0;" << '\n';
break;
case WARNING:
- wcout << L"UPTIME WARNING " << printInfo.time << TunitStr(printInfo.unit) << L" | uptime=" << printInfo.time
+ std::wcout << L"UPTIME WARNING " << printInfo.time << TunitStr(printInfo.unit) << L" | uptime=" << printInfo.time
<< TunitStr(printInfo.unit) << L";" << printInfo.warn.pString() << L";"
- << printInfo.crit.pString() << L";0;" << endl;
+ << printInfo.crit.pString() << L";0;" << '\n';
break;
case CRITICAL:
- wcout << L"UPTIME CRITICAL " << printInfo.time << TunitStr(printInfo.unit) << L" | uptime=" << printInfo.time
+ std::wcout << L"UPTIME CRITICAL " << printInfo.time << TunitStr(printInfo.unit) << L" | uptime=" << printInfo.time
<< TunitStr(printInfo.unit) << L";" << printInfo.warn.pString() << L";"
- << printInfo.crit.pString() << L";0;" << endl;
+ << printInfo.crit.pString() << L";0;" << '\n';
break;
}
return state;
}
-void getUptime(printInfoStruct& printInfo)
+VOID getUptime(printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Getting uptime in milliseconds" << endl;
+ std::wcout << L"Getting uptime in milliseconds" << '\n';
boost::chrono::milliseconds uptime = boost::chrono::milliseconds(GetTickCount64());
if (debug)
- wcout << L"Converting requested unit (default: seconds)" << endl;
+ std::wcout << L"Converting requested unit (default: seconds)" << '\n';
switch (printInfo.unit) {
case TunitH:
--- /dev/null
+/******************************************************************************
+ * Icinga 2 *
+ * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+ * *
+ * 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. *
+ ******************************************************************************/
+
+#ifndef CHECK_UPTIME_H
+#define CHECK_UPTIME_H
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+
+struct printInfoStruct
+{
+ threshold warn, crit;
+ long long time;
+ Tunit unit;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(printInfoStruct&);
+VOID getUptime(printInfoStruct&);
+
+#endif // !CHECK_UPTIME_H
#include <wtsapi32.h>
#include <iostream>
-#include "thresholds.h"
-
-#include "boost/program_options.hpp"
+#include "check_users.h"
#define VERSION 1.0
namespace po = boost::program_options;
-using std::endl; using std::wcout;
-using std::cout; using std::wstring;
-
static BOOL debug = FALSE;
-struct printInfoStruct
-{
- threshold warn, crit;
- double users;
-};
-
-static int parseArguments(int, wchar_t **, po::variables_map&, printInfoStruct&);
-static int printOutput(printInfoStruct&);
-static int check_users(printInfoStruct&);
-
-int wmain(int argc, wchar_t **argv)
+INT wmain(INT argc, WCHAR **argv)
{
printInfoStruct printInfo = { };
po::variables_map vm;
- int ret = parseArguments(argc, argv, vm, printInfo);
+ INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
-int parseArguments(int ac, wchar_t **av, po::variables_map& vm, printInfoStruct& printInfo)
+INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
{
- wchar_t namePath[MAX_PATH];
+ WCHAR namePath[MAX_PATH];
GetModuleFileName(NULL, namePath, MAX_PATH);
- wchar_t *progName = PathFindFileName(namePath);
+ WCHAR *progName = PathFindFileName(namePath);
po::options_description desc;
desc.add_options()
- ("help,h", "print help message and exit")
- ("version,V", "print version and exit")
+ ("help,h", "Print help message and exit")
+ ("version,V", "Print version and exit")
("debug,d", "Verbose/Debug output")
- ("warning,w", po::wvalue<wstring>(), "warning threshold")
- ("critical,c", po::wvalue<wstring>(), "critical threshold")
+ ("warning,w", po::wvalue<std::wstring>(), "Warning threshold")
+ ("critical,c", po::wvalue<std::wstring>(), "Critical threshold")
;
- po::basic_command_line_parser<wchar_t> parser(ac, av);
+ po::basic_command_line_parser<WCHAR> parser(ac, av);
try {
po::store(
vm);
vm.notify();
} catch (std::exception& e) {
- cout << e.what() << endl << desc << endl;
+ std::cout << e.what() << '\n' << desc << '\n';
return 3;
}
if (vm.count("help")) {
- wcout << progName << " Help\n\tVersion: " << VERSION << endl;
+ std::wcout << progName << " Help\n\tVersion: " << VERSION << '\n';
wprintf(
L"%s is a simple program to check a machines logged in users.\n"
L"You can use the following options to define its behaviour:\n\n", progName);
- cout << desc;
+ std::cout << desc;
wprintf(
L"\nIt will then output a string looking something like this:\n\n"
L"\tUSERS WARNING 48 | users=48;10;50;0\n\n"
L"to end with a percentage sign.\n\n"
L"All of these options work with the critical threshold \"-c\" too."
, progName);
- cout << endl;
+ std::cout << '\n';
return 0;
}
if (vm.count("version"))
- wcout << L"Version: " << VERSION << endl;
+ std::wcout << L"Version: " << VERSION << '\n';
if (vm.count("warning")) {
try {
- printInfo.warn = threshold(vm["warning"].as<wstring>());
+ printInfo.warn = threshold(vm["warning"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
if (vm.count("critical")) {
try {
- printInfo.crit = threshold(vm["critical"].as<wstring>());
+ printInfo.crit = threshold(vm["critical"].as<std::wstring>());
} catch (std::invalid_argument& e) {
- cout << e.what() << endl;
+ std::cout << e.what() << '\n';
return 3;
}
}
return -1;
}
-int printOutput(printInfoStruct& printInfo)
+INT printOutput(printInfoStruct& printInfo)
{
if (debug)
- wcout << L"Constructing output string" << endl;
+ std::wcout << L"Constructing output string" << '\n';
state state = OK;
switch (state) {
case OK:
- wcout << L"USERS OK " << printInfo.users << L" User(s) logged in | users=" << printInfo.users << L";"
- << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << endl;
+ std::wcout << L"USERS OK " << printInfo.users << L" User(s) logged in | users=" << printInfo.users << L";"
+ << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << '\n';
break;
case WARNING:
- wcout << L"USERS WARNING " << printInfo.users << L" User(s) logged in | users=" << printInfo.users << L";"
- << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << endl;
+ std::wcout << L"USERS WARNING " << printInfo.users << L" User(s) logged in | users=" << printInfo.users << L";"
+ << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << '\n';
break;
case CRITICAL:
- wcout << L"USERS CRITICAL " << printInfo.users << L" User(s) logged in | users=" << printInfo.users << L";"
- << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << endl;
+ std::wcout << L"USERS CRITICAL " << printInfo.users << L" User(s) logged in | users=" << printInfo.users << L";"
+ << printInfo.warn.pString() << L";" << printInfo.crit.pString() << L";0;" << '\n';
break;
}
return state;
}
-int check_users(printInfoStruct& printInfo)
+INT check_users(printInfoStruct& printInfo)
{
- double users = 0;
+ DOUBLE users = 0;
WTS_SESSION_INFOW *pSessionInfo = NULL;
DWORD count;
DWORD index;
if (debug)
- wcout << L"Trying to enumerate terminal sessions" << endl;
+ std::wcout << L"Trying to enumerate terminal sessions" << '\n';
if (!WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &pSessionInfo, &count)) {
- wcout << L"Failed to enumerate terminal sessions" << endl;
+ std::wcout << L"Failed to enumerate terminal sessions" << '\n';
die();
if (pSessionInfo)
WTSFreeMemory(pSessionInfo);
}
if (debug)
- wcout << L"Got all sessions (" << count << L"), traversing and counting active ones" << endl;
+ std::wcout << L"Got all sessions (" << count << L"), traversing and counting active ones" << '\n';
for (index = 0; index < count; index++) {
LPWSTR name;
DWORD size;
- int len;
+ INT len;
if (debug)
- wcout << L"Querrying session number " << index << endl;
+ std::wcout << L"Querrying session number " << index << '\n';
if (!WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, pSessionInfo[index].SessionId,
WTSUserName, &name, &size))
continue;
if (debug)
- wcout << L"Found \"" << name << L"\". Checking whether it's a real session" << endl;
+ std::wcout << L"Found \"" << name << L"\". Checking whether it's a real session" << '\n';
len = lstrlenW(name);
if (pSessionInfo[index].State == WTSActive || pSessionInfo[index].State == WTSDisconnected) {
users++;
if (debug)
- wcout << L"\"" << name << L"\" is a real session, counting it. Now " << users << endl;
+ std::wcout << L"\"" << name << L"\" is a real session, counting it. Now " << users << '\n';
}
}
if (debug)
- wcout << "Finished coutning user sessions (" << users << "). Freeing memory and returning" << endl;
+ std::wcout << "Finished coutning user sessions (" << users << "). Freeing memory and returning" << '\n';
WTSFreeMemory(pSessionInfo);
printInfo.users = users;
--- /dev/null
+#ifndef CHECK_USERS_H
+#define CHECK_USERS_H
+#include "thresholds.h"
+#include "boost/program_options.hpp"
+struct printInfoStruct
+{
+ threshold warn, crit;
+ DOUBLE users;
+};
+
+INT parseArguments(INT, WCHAR **, boost::program_options::variables_map&, printInfoStruct&);
+INT printOutput(printInfoStruct&);
+INT check_users(printInfoStruct&);
+
+#endif // !CHECK_USERS_H
#include "thresholds.h"
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
-#include <vector>
#include <iostream>
using namespace boost::algorithm;
-using std::wstring;
-
threshold::threshold()
: set(false)
{}
-threshold::threshold(const wstring& stri)
+threshold::threshold(CONST std::wstring& stri)
{
if (stri.empty())
throw std::invalid_argument("Threshold must not be empty");
- wstring str = stri;
+ std::wstring str = stri;
//kill whitespace
boost::algorithm::trim(str);
bool low = (str.at(0) == L'!');
if (low)
- str = wstring(str.begin() + 1, str.end());
+ str = std::wstring(str.begin() + 1, str.end());
bool pc = false;
if (str.at(0) == L'[' && str.at(str.length() - 1) == L']') {//is range
- str = wstring(str.begin() + 1, str.end() - 1);
- std::vector<wstring> svec;
+ str = std::wstring(str.begin() + 1, str.end() - 1);
+ std::vector<std::wstring> svec;
boost::split(svec, str, boost::is_any_of(L"-"));
if (svec.size() != 2)
throw std::invalid_argument("Threshold range requires two arguments");
- wstring str1 = svec.at(0), str2 = svec.at(1);
+ std::wstring str1 = svec.at(0), str2 = svec.at(1);
if (str1.at(str1.length() - 1) == L'%' && str2.at(str2.length() - 1) == L'%') {
pc = true;
- str1 = wstring(str1.begin(), str1.end() - 1);
- str2 = wstring(str2.begin(), str2.end() - 1);
+ str1 = std::wstring(str1.begin(), str1.end() - 1);
+ str2 = std::wstring(str2.begin(), str2.end() - 1);
}
try {
boost::algorithm::trim(str1);
- lower = boost::lexical_cast<double>(str1);
+ lower = boost::lexical_cast<DOUBLE>(str1);
boost::algorithm::trim(str2);
- upper = boost::lexical_cast<double>(str2);
+ upper = boost::lexical_cast<DOUBLE>(str2);
legal = !low; perc = pc; set = true;
- } catch (const boost::bad_lexical_cast&) {
+ } catch (CONST boost::bad_lexical_cast&) {
throw std::invalid_argument("Unknown Threshold type");
}
} else { //not range
if (str.at(str.length() - 1) == L'%') {
pc = true;
- str = wstring(str.begin(), str.end() - 1);
+ str = std::wstring(str.begin(), str.end() - 1);
}
try {
boost::algorithm::trim(str);
- lower = upper = boost::lexical_cast<double>(str);
+ lower = upper = boost::lexical_cast<DOUBLE>(str);
legal = !low; perc = pc; set = true;
- } catch (const boost::bad_lexical_cast&) {
+ } catch (CONST boost::bad_lexical_cast&) {
throw std::invalid_argument("Unknown Threshold type");
}
}
}
//return TRUE if the threshold is broken
-bool threshold::rend(const double val, const double max)
+BOOL threshold::rend(CONST DOUBLE val, CONST DOUBLE max)
{
- double upperAbs = upper;
- double lowerAbs = lower;
+ DOUBLE upperAbs = upper;
+ DOUBLE lowerAbs = lower;
if (perc) {
- upperAbs = upper / 100 * max;
- lowerAbs = lower / 100 * max;
+ upperAbs = upper / 100.0 * max;
+ lowerAbs = lower / 100.0 * max;
}
if (!set)
}
//returns a printable string of the threshold
-std::wstring threshold::pString(const double max)
+std::wstring threshold::pString(CONST DOUBLE max)
{
if (!set)
return L"";
//transform percentages to abolute values
- double lowerAbs = lower;
- double upperAbs = upper;
+ DOUBLE lowerAbs = lower;
+ DOUBLE upperAbs = upper;
if (perc) {
- lowerAbs = lower / 100 * max;
- upperAbs = upper / 100 * max;
+ lowerAbs = lower / 100.0 * max;
+ upperAbs = upper / 100.0 * max;
}
std::wstring s, lowerStr = removeZero(lowerAbs),
return s;
}
-std::wstring removeZero(double val)
+std::wstring removeZero(DOUBLE val)
{
std::wstring ret = boost::lexical_cast<std::wstring>(val);
- int pos = ret.length();
+ INT pos = ret.length();
if (ret.find_first_of(L".") == std::string::npos)
return ret;
for (std::wstring::reverse_iterator rit = ret.rbegin(); rit != ret.rend(); ++rit) {
std::vector<std::wstring> splitMultiOptions(std::wstring str)
{
- std::vector<wstring> sVec;
+ std::vector<std::wstring> sVec;
boost::split(sVec, str, boost::is_any_of(L","));
return sVec;
}
-Bunit parseBUnit(const wstring& str)
+Bunit parseBUnit(CONST std::wstring& str)
{
- wstring wstr = to_upper_copy(str);
+ std::wstring wstr = to_upper_copy(str);
if (wstr == L"B")
return BunitB;
throw std::invalid_argument("Unknown unit type");
}
-wstring BunitStr(const Bunit& unit)
+std::wstring BunitStr(CONST Bunit& unit)
{
switch (unit) {
case BunitB:
return NULL;
}
-Tunit parseTUnit(const wstring& str) {
- wstring wstr = to_lower_copy(str);
+Tunit parseTUnit(CONST std::wstring& str) {
+ std::wstring wstr = to_lower_copy(str);
if (wstr == L"ms")
return TunitMS;
throw std::invalid_argument("Unknown unit type");
}
-wstring TunitStr(const Tunit& unit)
+std::wstring TunitStr(CONST Tunit& unit)
{
switch (unit) {
case TunitMS:
return NULL;
}
-void die(DWORD err)
+VOID die(DWORD err)
{
if (!err)
err = GetLastError();
LPWSTR mBuf = NULL;
- size_t mS = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
- NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&mBuf, 0, NULL);
- std::wcout << mBuf << std::endl;
+ if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&mBuf, 0, NULL))
+ std::wcout << "Failed to format error message, last error was: " << err << '\n';
+ else
+ std::wcout << mBuf << std::endl;
}
\ No newline at end of file
/******************************************************************************
- * Icinga 2 *
- * Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
- * *
- * 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. *
- ******************************************************************************/
+* Icinga 2 *
+* Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
+* *
+* 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. *
+******************************************************************************/
#ifndef THRESHOLDS_H
#define THRESHOLDS_H
#include <string>
#include <Windows.h>
#include <vector>
-enum Bunit { BunitB = 0, BunitkB = 1, BunitMB = 2, BunitGB = 3, BunitTB = 4 };
-enum Tunit { TunitMS, TunitS, TunitM, TunitH };
-enum state { OK = 0, WARNING = 1, CRITICAL = 2 };
+enum Bunit
+{
+ BunitB = 0, BunitkB = 1, BunitMB = 2, BunitGB = 3, BunitTB = 4
+};
+
+enum Tunit
+{
+ TunitMS, TunitS, TunitM, TunitH
+};
+
+enum state
+{
+ OK = 0, WARNING = 1, CRITICAL = 2
+};
class threshold
{
public:
- double lower, upper;
+ //DOUBLEs are always enough for ANY 64 bit value
+ DOUBLE lower, upper;
//TRUE means everything BELOW upper/outside [lower-upper] is fine
- bool legal, perc, set;
+ BOOL legal, perc, set;
threshold();
- threshold(const double v, const double c, bool l = true, bool p = false);
+ threshold(CONST DOUBLE v, CONST DOUBLE c, BOOL l = TRUE, BOOL p = FALSE);
- threshold(const std::wstring&);
+ threshold(CONST std::wstring&);
//return TRUE if the threshold is broken
- bool rend(const double val, const double max = 100);
+ BOOL rend(CONST DOUBLE val, CONST DOUBLE max = 100.0);
//returns a printable string of the threshold
- std::wstring pString(const double max = 100);
+ std::wstring pString(CONST DOUBLE max = 100.0);
};
-std::wstring removeZero(double);
+std::wstring removeZero(DOUBLE);
std::vector<std::wstring> splitMultiOptions(std::wstring);
-Bunit parseBUnit(const std::wstring&);
-std::wstring BunitStr(const Bunit&);
-Tunit parseTUnit(const std::wstring&);
-std::wstring TunitStr(const Tunit&);
+Bunit parseBUnit(CONST std::wstring&);
+std::wstring BunitStr(CONST Bunit&);
+Tunit parseTUnit(CONST std::wstring&);
+std::wstring TunitStr(CONST Tunit&);
-void die(DWORD err = 0);
+VOID die(DWORD err = 0);
#endif
\ No newline at end of file
projects / icinga2 / commitdiff