]> granicus.if.org Git - icinga2/blobdiff - plugins/check_service.cpp
Merge pull request #7164 from Icinga/bugfix/notification-times-validate
[icinga2] / plugins / check_service.cpp
index 7b2e92eaa60e6f08cb731555d7bee4ca137ef714..70762386258ce549ce3612f784544dfd6c4aeb8d 100644 (file)
@@ -1,51 +1,25 @@
-/******************************************************************************
- * Icinga 2                                                                   *
- * Copyright (C) 2012-2016 Icinga Development Team (https://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.             *
- ******************************************************************************/
-#include <Windows.h>
-#include <Shlwapi.h>
-#include <iostream>
-
-#include "check_service.h"
+/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
 
+#include "plugins/thresholds.hpp"
+#include <boost/program_options.hpp>
+#include <iostream>
+#include <windows.h>
+#include <shlwapi.h>
 
 #define VERSION 1.1
 
 namespace po = boost::program_options;
 
-static BOOL debug;
-
-INT wmain(INT argc, WCHAR **argv)
+struct printInfoStruct
 {
-       po::variables_map vm;
-       printInfoStruct printInfo = { false, 0, L"" };
+       bool warn;
+       DWORD ServiceState;
+       std::wstring service;
+};
 
-       INT ret = parseArguments(argc, argv, vm, printInfo);
-       if (ret != -1)
-               return ret;
+static bool l_Debug;
 
-       printInfo.ServiceState = ServiceStatus(printInfo);
-       if (printInfo.ServiceState == -1)
-               return 3;
-
-       return printOutput(printInfo);
-}
-
-INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo) 
+static int parseArguments(int ac, WCHAR **av, po::variables_map& vm, printInfoStruct& printInfo)
 {
        WCHAR namePath[MAX_PATH];
        GetModuleFileName(NULL, namePath, MAX_PATH);
@@ -56,12 +30,13 @@ INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& p
        desc.add_options()
                ("help,h", "Print help message and exit")
                ("version,V", "Print version and exit")
-               ("debug,d", "Verbose/Debug output")
-               ("service,s", po::wvalue<std::wstring>(), "Service to check (required)")
+               ("debug,D", "Verbose/Debug output")
+               ("service,s", po::wvalue<std::wstring>(), "Service name to check")
+               ("description,d", "Use \"service\" to match on description")
                ("warn,w", "Return warning (1) instead of critical (2),\n when service is not running")
                ;
 
-       po::basic_command_line_parser<WCHAR> parser(ac, av);
+       po::wcommand_line_parser parser(ac, av);
 
        try {
                po::store(
@@ -73,7 +48,7 @@ INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& p
                        .run(),
                        vm);
                vm.notify();
-       } catch (std::exception& e) {
+       } catch (const std::exception& e) {
                std::cout << e.what() << '\n' << desc << '\n';
                return 3;
        }
@@ -104,79 +79,161 @@ INT parseArguments(INT ac, WCHAR **av, po::variables_map& vm, printInfoStruct& p
                return 0;
        }
 
-        if (vm.count("version")) {
+       if (vm.count("version")) {
                std::cout << "Version: " << VERSION << '\n';
                return 0;
-       } 
+       }
 
        if (!vm.count("service")) {
-               std::cout << "Missing argument: service" << '\n' << desc << '\n';
+               std::cout << "Argument \"service\" is required.\n" << desc << '\n';
                return 3;
        }
 
-       if (vm.count("warn"))
-               printInfo.warn = true;
-       
        printInfo.service = vm["service"].as<std::wstring>();
 
-       if (vm.count("debug"))
-               debug = TRUE;
-       
+       printInfo.warn = vm.count("warn");
+
+       l_Debug = vm.count("debug") > 0;
+
        return -1;
 }
 
-INT printOutput(CONST printInfoStruct& printInfo) 
+static int printOutput(const printInfoStruct& printInfo)
 {
-       if (debug)
+       if (l_Debug)
                std::wcout << L"Constructing output string" << '\n';
 
        std::wstring perf;
        state state = OK;
 
        if (!printInfo.ServiceState) {
-               std::wcout << L"SERVICE CRITICAL NOTFOUND | service=" << printInfo.ServiceState << ";;;1;7" << '\n';
+               std::wcout << L"SERVICE CRITICAL NOT FOUND | 'service'=" << printInfo.ServiceState << ";;;1;7" << '\n';
                return 3;
        }
 
-       if (printInfo.ServiceState != 0x04) 
+       if (printInfo.ServiceState != 0x04)
                printInfo.warn ? state = WARNING : state = CRITICAL;
 
        switch (state) {
        case OK:
-               std::wcout << L"SERVICE OK RUNNING | service=4;;;1;7" << '\n';
+               std::wcout << L"SERVICE \"" << printInfo.service << "\" OK RUNNING | 'service'=4;;;1;7" << '\n';
                break;
        case WARNING:
-               std::wcout << L"SERVICE WARNING NOT RUNNING | service=" << printInfo.ServiceState << ";;;1;7" << '\n';
+               std::wcout << L"SERVICE \"" << printInfo.service << "\" WARNING NOT RUNNING | 'service'=" << printInfo.ServiceState << ";;;1;7" << '\n';
                break;
        case CRITICAL:
-               std::wcout << L"SERVICE CRITICAL NOT RUNNING | service=" << printInfo.ServiceState << ";;;1;7" << '\n';
+               std::wcout << L"SERVICE \"" << printInfo.service << "\" CRITICAL NOT RUNNING | 'service'=" << printInfo.ServiceState << ";;;1;7" << '\n';
                break;
        }
 
        return state;
 }
 
-DWORD ServiceStatus(CONST printInfoStruct& printInfo) 
+static std::wstring getServiceByDescription(const std::wstring& description)
+{
+       SC_HANDLE hSCM = NULL;
+       LPENUM_SERVICE_STATUSW lpServices = NULL;
+       LPBYTE lpBuf = NULL;
+       DWORD cbBufSize = 0;
+       DWORD lpServicesReturned = 0;
+       DWORD pcbBytesNeeded = 0;
+       DWORD lpResumeHandle = 0;;
+
+       if (l_Debug)
+               std::wcout << L"Opening SC Manager" << '\n';
+
+       hSCM = OpenSCManager(NULL, NULL, GENERIC_READ);
+       if (hSCM == NULL)
+               goto die;
+
+       if (l_Debug)
+               std::wcout << L"Determining initially required memory" << '\n';
+
+       EnumServicesStatus(hSCM, SERVICE_WIN32 | SERVICE_DRIVER, SERVICE_STATE_ALL, NULL, 0,
+               &pcbBytesNeeded, &lpServicesReturned, &lpResumeHandle);
+
+       /* This should always be ERROR_INSUFFICIENT_BUFFER... But for some reason it is sometimes ERROR_MORE_DATA
+       * See the MSDN on EnumServiceStatus for a glimpse of despair
+       */
+
+       if (GetLastError() != ERROR_INSUFFICIENT_BUFFER && GetLastError() != ERROR_MORE_DATA)
+               goto die;
+
+       lpServices = reinterpret_cast<LPENUM_SERVICE_STATUSW>(new BYTE[pcbBytesNeeded]);
+
+       if (l_Debug)
+               std::wcout << L"Requesting Service Information. Entry point: " << lpResumeHandle << '\n';
+
+       EnumServicesStatus(hSCM, SERVICE_WIN32 | SERVICE_DRIVER, SERVICE_STATE_ALL, lpServices, pcbBytesNeeded,
+               &pcbBytesNeeded, &lpServicesReturned, &lpResumeHandle);
+
+       for (decltype(lpServicesReturned) index = 0; index < lpServicesReturned; index++) {
+               LPWSTR lpCurrent = lpServices[index].lpServiceName;
+
+               if (l_Debug) {
+                       std::wcout << L"Opening Service \"" << lpServices[index].lpServiceName << L"\"\n";
+               }
+
+               SC_HANDLE hService = OpenService(hSCM, lpCurrent, SERVICE_QUERY_CONFIG);
+               if (!hService)
+                       goto die;
+
+               DWORD dwBytesNeeded = 0;
+               if (l_Debug)
+                       std::wcout << "Accessing config\n";
+
+               if (!QueryServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, NULL, 0, &dwBytesNeeded) && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+                       continue;
+
+               LPSERVICE_DESCRIPTION lpsd = reinterpret_cast<LPSERVICE_DESCRIPTION>(new BYTE[dwBytesNeeded]);
+
+               if (!QueryServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, (LPBYTE)lpsd, dwBytesNeeded, &dwBytesNeeded))
+                       continue;
+
+               if (lpsd->lpDescription != NULL && lstrcmp(lpsd->lpDescription, L"") != 0) {
+                       std::wstring desc(lpsd->lpDescription);
+                       if (l_Debug)
+                               std::wcout << "Got description:\n" << desc << '\n';
+                       size_t p = desc.find(description);
+                       if (desc.find(description) != desc.npos)
+                               return lpCurrent;
+               }
+               else if (l_Debug)
+                       std::wcout << "No description found\n";
+       }
+
+       CloseServiceHandle(hSCM);
+       delete[] lpServices;
+       return L"";
+
+die:
+       printErrorInfo();
+       if (hSCM)
+               CloseServiceHandle(hSCM);
+       if (lpServices)
+               delete[] lpServices;
+       return L"";
+}
+
+static DWORD getServiceStatus(const printInfoStruct& printInfo)
 {
        SC_HANDLE hSCM;
        SC_HANDLE hService;
        DWORD cbBufSize;
+       DWORD lpResumeHandle = 0;
        LPBYTE lpBuf = NULL;
 
-       if (debug)
+       if (l_Debug)
                std::wcout << L"Opening SC Manager" << '\n';
 
        hSCM = OpenSCManager(NULL, NULL, GENERIC_READ);
        if (hSCM == NULL)
                goto die;
 
-       if (debug)
-               std::wcout << L"Getting Service Information" << '\n';
-
        hService = OpenService(hSCM, printInfo.service.c_str(), SERVICE_QUERY_STATUS);
        if (hService == NULL)
                goto die;
-       
+
        QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, NULL, 0, &cbBufSize);
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
                goto die;
@@ -187,14 +244,39 @@ DWORD ServiceStatus(CONST printInfoStruct& printInfo)
                return pInfo->dwCurrentState;
        }
 
-
 die:
-       die();
+       printErrorInfo();
        if (hSCM)
                CloseServiceHandle(hSCM);
        if (hService)
                CloseServiceHandle(hService);
-       delete [] lpBuf;
+       if (lpBuf)
+               delete [] lpBuf;
 
        return -1;
 }
+
+int wmain(int argc, WCHAR **argv)
+{
+       po::variables_map vm;
+       printInfoStruct printInfo;
+
+       int ret = parseArguments(argc, argv, vm, printInfo);
+       if (ret != -1)
+               return ret;
+
+       if (vm.count("description"))
+               printInfo.service = getServiceByDescription(vm["service"].as<std::wstring>());
+
+       if (printInfo.service.empty()) {
+               std::wcout << "Could not find service matching description\n";
+               return 3;
+       }
+
+       printInfo.ServiceState = getServiceStatus(printInfo);
+       if (printInfo.ServiceState == -1)
+               return 3;
+
+       return printOutput(printInfo);
+}
+