Changeset 220

Timestamp:

11/22/09 23:09:39 (2 years ago)

Author:

mickem

Message:

Semi-working NRPEClient (debian boost is broken so need to recompile it myself before I can finish it off) But "should almost work" (from CLI)

Location:

trunk

Files:

• CMakeLists.txt (modified) (2 diffs)
• build.cmake (modified) (1 diff)
• include/nrpe/nrpepacket.hpp (modified) (5 diffs)
• include/nsc_module_wrapper.hpp (modified) (2 diffs)
• include/program_options_ex.hpp (modified) (1 diff)
• include/types.hpp (modified) (1 diff)
• modules/NRPEClient/NRPEClient.cpp (modified) (15 diffs)
• modules/NRPEClient/NRPEClient.h (modified) (6 diffs)
• modules/NRPEClient/stdafx.h (modified) (2 diffs)
• service/NSCPlugin.cpp (modified) (1 diff)
• service/NSCPlugin.h (modified) (2 diffs)
• service/NSClient++.cpp (modified) (5 diffs)
• service/NSClient++.h (modified) (1 diff)

trunk/CMakeLists.txt

@@ -128 +128 @@
 ADD_SUBDIRECTORY("service")
 
+SET(ALL_MODULE_NAMES)
 FILE(GLOB ALL_MODULES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "modules/*/CMakeLists.txt")
 foreach(CURRENT_MODULE ${ALL_MODULES})
   get_filename_component(CURRENT_MODULE_PATH ${CURRENT_MODULE} PATH)
-  message(STATUS "Adding module: ${CURRENT_MODULE_PATH}")
+  get_filename_component(CURRENT_MODULE_NAME ${CURRENT_MODULE_PATH} NAME)
+  message(STATUS "Adding module: ${CURRENT_MODULE_PATH} (${CURRENT_MODULE_NAME})")
   ADD_SUBDIRECTORY("${CURRENT_MODULE_PATH}")
+  SET(ALL_MODULE_NAMES ${ALL_MODULE_NAMES} ${CURRENT_MODULE_NAME})
 endforeach(CURRENT_MODULE ${ALL_MODULES})
 
 
-SET_TARGET_PROPERTIES("nsclient++" "CheckHelpers" PROPERTIES 
+SET_TARGET_PROPERTIES("nsclient++" ${ALL_MODULE_NAMES} PROPERTIES 
         RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}"
     LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/modules"
@@ -145 +148 @@
 if (MSVC_IDE)
     # hack to get around the "Debug" and "Release" directories cmake tries to add on Windows
-    set_target_properties ("nsclient++" "CheckHelpers" PROPERTIES PREFIX "../")
+    set_target_properties ("nsclient++" ${ALL_MODULE_NAMES} PROPERTIES PREFIX "../")
 endif()

trunk/build.cmake

@@ -4 +4 @@
 set(BOOST_USE_MULTITHREADED ON)
 
-SET(BOOST_INCLUDEDIR c:/src/include/boost-1_39/)
-SET(BOOST_LIBRARYDIR c:/src/lib/x86/)
+SET(BOOST_INCLUDEDIR D:/source/include/boost-1_40)
+SET(BOOST_LIBRARYDIR d:/source/lib/x86/)
 SET(BOOST_LIB_SUFFIX vc80-mt)
-SET(BOOST_LIB_VERSION 1.39)
+SET(BOOST_LIB_VERSION 1.40)

trunk/include/nrpe/nrpepacket.hpp

@@ -21 +21 @@
 #pragma once
 
+#include <types.hpp>
 
-typedef short int16_t;
-typedef unsigned long u_int32_t;
 
 class NRPEPacket {
@@ -79 +78 @@
   {
   }
-  NRPEPacket(NRPEPacket &other) : tmpBuffer(NULL) {
+  NRPEPacket(const NRPEPacket &other) : tmpBuffer(NULL) {
     payload_ = other.payload_;
     type_ = other.type_;
@@ -88 +87 @@
     buffer_length_ = other.buffer_length_;
   }
+  NRPEPacket& operator=(NRPEPacket const& other) {
+    tmpBuffer=NULL;
+    payload_ = other.payload_;
+    type_ = other.type_;
+    version_ = other.version_;
+    result_ = other.result_;
+    crc32_ = other.crc32_;
+    calculatedCRC32_ = other.calculatedCRC32_;
+    buffer_length_ = other.buffer_length_;
+    return *this;
+  }
+
   ~NRPEPacket() {
     delete [] tmpBuffer;
@@ -98 +109 @@
     delete [] tmpBuffer;
     tmpBuffer = new char[getBufferLength()+1];
-    ZeroMemory(tmpBuffer, getBufferLength()+1);
+    //TODO readd this ZeroMemory(tmpBuffer, getBufferLength()+1);
     packet *p = reinterpret_cast<packet*>(tmpBuffer);
     p->result_code = htons(NSCHelper::nagios2int(result_));
@@ -106 +117 @@
       throw NRPEPacketException(_T("To much data cant create return packet (truncate datat)"));
     //ZeroMemory(p->buffer, buffer_length_-1);
-    strncpy_s(p->buffer, buffer_length_-1, strEx::wstring_to_string(payload_).c_str(), payload_.length());
+    strncpy(p->buffer, to_string(payload_).c_str(), payload_.length());
     p->buffer[payload_.length()] = 0;
     p->crc32_value = 0;

trunk/include/nsc_module_wrapper.hpp

@@ -44 +44 @@
 
 #define NSC_WRAPPERS_CLI() \
-  extern "C" int NSCommandLineExec(const wchar_t*,const unsigned int,wchar_t**)
+  extern "C" int NSCommandLineExec(const unsigned int,wchar_t**)
 
 #ifdef DEBUG
@@ -193 +193 @@
 
 #define NSC_WRAPPERS_CLI_DEF(toObject) \
-  extern int NSCommandLineExec(const wchar_t* command,const unsigned int argLen,wchar_t** args) { \
-    try { \
-      return toObject.commandLineExec(command, argLen, args); \
+  extern int NSCommandLineExec(const unsigned int argLen,wchar_t** args) { \
+    try { \
+      return toObject.commandLineExec(argLen, args); \
     } catch (...) { \
       NSC_LOG_CRITICAL(_T("Unknown exception in: commandLineExec(...)")); \

trunk/include/program_options_ex.hpp

@@ -7 +7 @@
 class basic_command_line_parser_ex : public boost::program_options::basic_command_line_parser<charT> {
 public:
-  static boost::program_options::basic_parsed_options<charT> parse_command_line(const charT* arg0, int argc, charT* argv[], const boost::program_options::options_description& desc,
+  static boost::program_options::basic_parsed_options<charT> parse_command_line(int argc, charT* argv[], const boost::program_options::options_description& desc,
     int style = 0, boost::function1<std::pair<std::string, std::string>, const std::string&> ext = boost::program_options::ext_parser())
   {
-    return basic_command_line_parser_ex<charT>(arg0, argc, argv).options(desc).style(style).extra_parser(ext).run();
+    return basic_command_line_parser_ex<charT>(argc, argv).options(desc).style(style).extra_parser(ext).run();
   }
 
-  template<class charT, class Iterator>
-    std::vector<std::basic_string<charT> > 
-      make_vector(const charT *a0, Iterator i, Iterator e)
+  template<class charTx, class Iterator>
+    std::vector<std::basic_string<charTx> > 
+      make_vector(Iterator i, Iterator e)
     {
-      std::vector<std::basic_string<charT> > result;
+      std::vector<std::basic_string<charTx> > result;
       // Some compilers don't have templated constructor for 
       // vector, so we can't create vector from (argv+1, argv+argc) range
-      if (a0 != NULL)
-        result.push_back(a0);
+      //if (a0 != NULL)
+      //  result.push_back(a0);
       for(; i != e; ++i)
         result.push_back(*i);
       return result;            
     }
-    basic_command_line_parser_ex(const charT* arg0, int argc, charT* argv[]) 
+    basic_command_line_parser_ex(int argc, charT* argv[]) 
       : boost::program_options::basic_command_line_parser<charT>(
-      make_vector<charT, charT**>(arg0, argv, argv+argc)
+      make_vector<charT, charT**>(argv, argv+argc)
       )
     {}
+    /*
+#ifdef _WIN32
     basic_command_line_parser_ex(const std::wstring args) 
       : boost::program_options::basic_command_line_parser<charT>(boost::program_options::split_winmain(args))
     {}
+#endif
+    */
 
 };

trunk/include/types.hpp

@@ -8 +8 @@
 typedef void* LPVOID;
 typedef int BOOL;
+#endif
+#ifdef WIN32
+typedef short int16_t;
+typedef unsigned long u_int32_t;
 #endif
 

trunk/modules/NRPEClient/NRPEClient.cpp

@@ -25 +25 @@
 #include <config.h>
 #include <msvc_wrappers.h>
-#include <execute_process.hpp>
-#ifdef USE_BOOST
+//#include <execute_process.hpp>
 #include <program_options_ex.hpp>
-#endif
 #include <strEx.h>
 
 NRPEClient gNRPEClient;
 
+#ifdef WIN32
 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
 {
@@ -38 +37 @@
   return TRUE;
 }
+#endif
 
 NRPEClient::NRPEClient() : buffer_length_(0), bInitSSL(false) {
@@ -77 +77 @@
 
 void NRPEClient::addCommand(strEx::blindstr key, std::wstring args) {
-#ifndef USE_BOOST
-  NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str() + _T(" boost not avalible!"));
-#else
   try {
+    /*
+    TODO: reimplem,ent this!
     boost::program_options::options_description desc = get_optionDesc();
     boost::program_options::positional_options_description p = get_optionsPositional();
@@ -86 +85 @@
     boost::program_options::variables_map vm;
     boost::program_options::store(
-      basic_command_line_parser_ex<TCHAR>(args).options(desc).positional(p).run()
+      basic_command_line_parser_ex<wchar_t>(args).options(desc).positional(p).run()
       , vm);
     boost::program_options::notify(vm); 
@@ -92 +91 @@
     NSC_DEBUG_MSG_STD(_T("Added NRPE Client: ") + key.c_str() + _T(" = ") + cd.toString());
     commands[key] = cd;
+    */
   } catch (boost::program_options::validation_error &e) {
     NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str() + strEx::string_to_wstring(e.what()));
@@ -97 +97 @@
     NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str());
   }
-#endif
 }
 
@@ -139 +138 @@
 }
 
-#ifdef USE_BOOST
 boost::program_options::options_description NRPEClient::get_optionDesc() {
   boost::program_options::options_description desc("Allowed options");
@@ -151 +149 @@
     ("buffer-length,l", boost::program_options::value<int>(), std::string("Length of payload (has to be same as on the server (default=" + strEx::s::itos(buffer_length_) + ")").c_str())
     ("no-ssl,n", "Do not initial an ssl handshake with the server, talk in plaintext.")
-    ("arguments,a", boost::program_options::wvalue<std::vector<std::wstring>>(), "list of arguments")
+    ("arguments,a", boost::program_options::wvalue<std::vector<std::wstring> >(), "list of arguments")
     ;
   return desc;
@@ -160 +158 @@
   return p;
 }
-NRPEClient::nrpe_connection_data NRPEClient::get_ConectionData(boost::program_options::variables_map &vm) {
-  nrpe_connection_data ret(buffer_length_);
-  if (vm.count("host"))
-    ret.host = vm["host"].as<std::wstring>();
-  if (vm.count("port"))
-    ret.port = vm["port"].as<int>();
-  if (vm.count("timeout"))
-    ret.timeout = vm["timeout"].as<int>();
-  if (vm.count("buffer-length"))
-    ret.buffer_length = vm["buffer-length"].as<int>();
-  if (vm.count("command"))
-    ret.command = vm["command"].as<std::wstring>();
-  if (vm.count("arguments")) {
-    std::vector<std::wstring> v = vm["arguments"].as<std::vector<std::wstring>>();
-    for (std::vector<std::wstring>::const_iterator cit = v.begin(); cit != v.end(); ++cit) {
-      if (!ret.arguments.empty())
-        ret.arguments += _T("!");
-      ret.arguments += *cit;
-    }
-  }
-  if (vm.count("no-ssl"))
-    ret.ssl = false;
-  return ret;
-}
-#endif
-
-
-int NRPEClient::commandLineExec(const TCHAR* command, const unsigned int argLen, TCHAR** args) {
-#ifndef USE_BOOST
-  NSC_LOG_ERROR_STD(_T("Could not execute ") + std::wstring(command) + _T(" boost not avalible!"));
-  return NSCAPI::returnUNKNOWN;
-#else
+
+namespace po = boost::program_options;
+int NRPEClient::commandLineExec(const unsigned int argLen, TCHAR** args) {
   try {
-    boost::program_options::options_description desc = get_optionDesc();
-    boost::program_options::positional_options_description p = get_optionsPositional();
-    
+
+    NRPEClient::nrpe_connection_data command_data;
     boost::program_options::variables_map vm;
-    boost::program_options::store(
-      basic_command_line_parser_ex<TCHAR>(command, argLen, args).options(desc).positional(p).run()
-      , vm);
-    boost::program_options::notify(vm);    
+
+    po::options_description desc("Allowed options");
+    buffer_length_ = SETTINGS_GET_INT(nrpe::PAYLOAD_LENGTH);
+    desc.add_options()
+      ("help,h", "Show this help message.")
+      ("host,H", po::wvalue<std::wstring>(&command_data.host), "The address of the host running the NRPE daemon")
+      ("port,p", po::value<int>(&command_data.port), "The port on which the daemon is running (default=5666)")
+      ("command,c", po::wvalue<std::wstring>(&command_data.command), "The name of the command that the remote daemon should run")
+      ("timeout,t", po::value<int>(&command_data.timeout), "Number of seconds before connection times out (default=10)")
+      ("buffer-length,l", po::value<unsigned int>(&command_data.buffer_length), std::string("Length of payload (has to be same as on the server (default=" + to_string(buffer_length_) + ")").c_str())
+      ("no-ssl,n", po::value<bool>(&command_data.no_ssl)->zero_tokens()->default_value(false), "Do not initial an ssl handshake with the server, talk in plaintext.")
+      ("arguments,a", po::wvalue<std::vector<std::wstring> >(&command_data.argument_vector), "list of arguments")
+      ;
+
+    po::positional_options_description p;
+    p.add("arguments", -1);
+    po::wparsed_options parsed = basic_command_line_parser_ex<wchar_t>(argLen, args).options(desc).positional(p).run();
+    po::store(parsed, vm);
+    po::notify(vm);
+    command_data.parse_arguments();
+
+    std::wcout << _T("parsed data: ") << command_data.toString()<< std::endl;
 
     if (vm.count("help")) {
@@ -206 +192 @@
       return 1;
     }
-
-    NRPEClient::nrpe_connection_data command = get_ConectionData(vm);
-    nrpe_result_data result = execute_nrpe_command(command, command.arguments);
+    nrpe_result_data result = execute_nrpe_command(command_data, command_data.arguments);
     std::wcout << result.text << std::endl;
     return result.result;
@@ -217 +201 @@
   }
   return NSCAPI::returnUNKNOWN;
-#endif
 }
 NRPEClient::nrpe_result_data NRPEClient::execute_nrpe_command(nrpe_connection_data con, std::wstring arguments) {
   try {
     NRPEPacket packet;
-    if (con.ssl) {
+    if (!con.no_ssl) {
 #ifdef USE_SSL
       packet = send_ssl(con.host, con.port, con.timeout, NRPEPacket::make_request(con.get_cli(arguments), con.buffer_length));
@@ -233 +216 @@
   } catch (NRPEPacket::NRPEPacketException &e) {
     return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("NRPE Packet errro: ") + e.getMessage());
-  } catch (simpleSocket::SocketException &e) {
-    return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("Socket error: ") + e.getMessage());
   } catch (std::runtime_error &e) {
     return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("Socket error: ") + boost::lexical_cast<std::wstring>(e.what()));
-#ifdef USE_SSL
-  } catch (simpleSSL::SSLException &e) {
-    return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("SSL Socket error: ") + e.getMessage());
-#endif
   } catch (...) {
     return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("Unknown error -- REPORT THIS!"));
@@ -369 +346 @@
   }
 };
+#ifdef USE_SSL
 
 class nrpe_ssl_socket {
@@ -419 +397 @@
   }
 };
-
-NRPEPacket NRPEClient::send_nossl(std::wstring host, int port, int timeout, NRPEPacket packet)
-{
-  boost::asio::io_service io_service;
-  nrpe_socket socket(io_service, host, port);
-  socket.send(packet, boost::posix_time::seconds(timeout));
-  return socket.recv(packet, boost::posix_time::seconds(timeout));
-}
-
 NRPEPacket NRPEClient::send_ssl(std::wstring host, int port, int timeout, NRPEPacket packet)
 {
@@ -439 +408 @@
   return socket.recv(packet, boost::posix_time::seconds(timeout));
 }
+#endif
+
+NRPEPacket NRPEClient::send_nossl(std::wstring host, int port, int timeout, NRPEPacket packet)
+{
+  boost::asio::io_service io_service;
+  nrpe_socket socket(io_service, host, port);
+  socket.send(packet, boost::posix_time::seconds(timeout));
+  return socket.recv(packet, boost::posix_time::seconds(timeout));
+}
+
 /*
 NRPEPacket NRPEClient::send_nossl(std::wstring host, int port, int timeout, NRPEPacket packet)

trunk/modules/NRPEClient/NRPEClient.h

@@ -21 +21 @@
 
 NSC_WRAPPERS_MAIN();
-#include <Socket.h>
-#ifdef USE_SSL
-#include <SSLSocket.h>
-#endif
 #include <map>
-#include <nrpe/NRPEPacket.hpp>
-#ifdef USE_BOOST
+#include <nrpe/nrpepacket.hpp>
 #include <boost/program_options.hpp>
-#endif
 
 
@@ -42 +36 @@
     std::wstring arguments;
     std::wstring command_line;
+    std::vector<std::wstring> argument_vector;
     int port;
     int timeout;
     unsigned int buffer_length;
-    bool ssl;
+    bool no_ssl;
     nrpe_connection_data(unsigned int buffer_length_ = 1024) 
       : host(_T("127.0.0.1")), 
       port(5666), 
       timeout(10), 
-      ssl(true), 
+      no_ssl(false), 
       buffer_length(buffer_length_) 
     {}
+    void parse_arguments() {
+      for (std::vector<std::wstring>::const_iterator cit = argument_vector.begin(); cit != argument_vector.end(); ++cit) {
+        if (!arguments.empty())
+          arguments += _T("!");
+        arguments += *cit;
+      }
+    }
     std::wstring get_cli(std::wstring arguments_) {
       if (command_line.empty()) {
@@ -70 +72 @@
       ss << _T(", port: ") << port;
       ss << _T(", timeout: ") << timeout;
-      ss << _T(", ssl: ") << ssl;
+      ss << _T(", no_ssl: ") << no_ssl;
       ss << _T(", buffer_length: ") << buffer_length;
       return ss.str();
@@ -107 +109 @@
   std::wstring getModuleDescription() {
     return _T("A simple client for checking remote NRPE servers (think proxy).\n")
-#ifndef USE_BOOST
-    _T("BOOST support is missing (this is probably very bad)!\n")
-#endif
 #ifndef USE_SSL
     _T("SSL support is missing (so you cant use encryption)!")
@@ -119 +118 @@
   bool hasMessageHandler();
   NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf);
-  int commandLineExec(const TCHAR* command,const unsigned int argLen,TCHAR** args);
+  int commandLineExec(const unsigned int argLen,TCHAR** args);
   std::wstring getConfigurationMeta();
 
@@ -127 +126 @@
   NRPEPacket send_ssl(std::wstring host, int port, int timeout, NRPEPacket packet);
   void initSSL();
-#ifdef USE_BOOST
-  boost::program_options::options_description NRPEClient::get_optionDesc();
-  boost::program_options::positional_options_description NRPEClient::get_optionsPositional();
-  nrpe_connection_data NRPEClient::get_ConectionData(boost::program_options::variables_map &vm);
-#endif
+  boost::program_options::options_description get_optionDesc();
+  boost::program_options::positional_options_description get_optionsPositional();
+  nrpe_connection_data get_ConectionData(boost::program_options::variables_map &vm);
 
 

trunk/modules/NRPEClient/stdafx.h

@@ -21 +21 @@
 #pragma once
 
+#ifdef _WIN32
 #define _WIN32_WINNT 0x0400
-
 #define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers
 // Windows Header Files:
 #include <windows.h>
 #include <winsock2.h>
+#endif
 
 #include <string>
@@ -42 +43 @@
 #include <boost/optional.hpp>
 #include <boost/bind.hpp>
+#ifdef USE_SSL
 #include <boost/asio/ssl.hpp>
+#endif
 
-#ifdef MEMCHECK
-#include <vld.h>
-#endif

trunk/service/NSCPlugin.cpp

@@ -391 +391 @@
 }
 
-int NSCPlugin::commandLineExec(const wchar_t* command, const unsigned int argLen, wchar_t **arguments) {
+int NSCPlugin::commandLineExec(const unsigned int argLen, wchar_t **arguments) {
   if (fCommandLineExec== NULL)
     throw NSPluginException(module_, _T("Module does not support CommandLineExec"));
   try {
-    return fCommandLineExec(command, argLen, arguments);
+    return fCommandLineExec(argLen, arguments);
   } catch (...) {
     throw NSPluginException(module_, _T("Unhandled exception in commandLineExec."));

trunk/service/NSCPlugin.h

@@ -119 +119 @@
   typedef int (*lpHasMessageHandler)();
   typedef NSCAPI::nagiosReturn (*lpHandleCommand)(const wchar_t*,const unsigned int, wchar_t**,wchar_t*,unsigned int,wchar_t *,unsigned int);
-  typedef int (*lpCommandLineExec)(const wchar_t*,const unsigned int,wchar_t**);
+  typedef int (*lpCommandLineExec)(const unsigned int,wchar_t**);
   typedef int (*lpHandleMessage)(int,const wchar_t*,const int,const wchar_t*);
   typedef int (*lpUnLoadModule)();
@@ -160 +160 @@
   void unload(void);
   std::wstring getCongifurationMeta();
-  int commandLineExec(const wchar_t* command, const unsigned int argLen, wchar_t **arguments);
+  int commandLineExec(const unsigned int argLen, wchar_t **arguments);
   void showTray();
   void hideTray();

trunk/service/NSClient++.cpp

@@ -354 +354 @@
       mainClient.enableDebug(false);
       mainClient.initCore(false);
-      if (argc>=4)
-        nRetCode = mainClient.commandLineExec(argv[2], argv[3], argc-4, &argv[4]);
+      if (argc>=3)
+        nRetCode = mainClient.commandLineExec(argv[2], argc-3, &argv[3]);
       else
-        nRetCode = mainClient.commandLineExec(argv[2], argv[3], 0, NULL);
+        nRetCode = mainClient.commandLineExec(argv[2], 0, NULL);
       mainClient.exitCore(true);
       return nRetCode;
@@ -404 +404 @@
   } else if (argc > 2) {
     g_bConsoleLog = true;
+    std::wcout << _T(" * * * * * * * ") << std::endl;
     mainClient.initCore(true);
     if (argc>=3)
-      nRetCode = mainClient.commandLineExec(argv[1], argv[2], argc-3, &argv[3]);
+      nRetCode = mainClient.commandLineExec(argv[1], argc-2, &argv[2]);
     else
-      nRetCode = mainClient.commandLineExec(argv[1], argv[2], 0, NULL);
+      nRetCode = mainClient.commandLineExec(argv[1], 0, NULL);
     mainClient.exitCore(true);
     return nRetCode;
@@ -888 +889 @@
 // Member functions
 
-int NSClientT::commandLineExec(const wchar_t* module, const wchar_t* command, const unsigned int argLen, wchar_t** args) {
+int NSClientT::commandLineExec(const wchar_t* module, const unsigned int argLen, wchar_t** args) {
   std::wstring sModule = module;
   std::wstring moduleList = _T("");
@@ -906 +907 @@
           LOG_DEBUG_STD(_T("Found module: ") + p->getName() + _T("..."));
           try {
-            return p->commandLineExec(command, argLen, args);
+            return p->commandLineExec(argLen, args);
           } catch (NSPluginException e) {
             LOG_ERROR_CORE_STD(_T("Could not execute command: ") + e.error_ + _T(" in ") + e.file_);
@@ -919 +920 @@
     LOG_DEBUG_STD(_T("Loading plugin: ") + plugin->getName() + _T("..."));
     plugin->load_plugin(NSCAPI::dontStart);
-    return plugin->commandLineExec(command, argLen, args);
+    return plugin->commandLineExec(argLen, args);
   } catch (NSPluginException e) {
     LOG_MESSAGE_STD(_T("Module (") + e.file_ + _T(") was not found: ") + e.error_);

trunk/service/NSClient++.h

@@ -168 +168 @@
   std::wstring execute(std::wstring password, std::wstring cmd, std::list<std::wstring> args);
   void reportMessage(int msgType, const wchar_t* file, const int line, std::wstring message);
-  int commandLineExec(const wchar_t* module, const wchar_t* command, const unsigned int argLen, wchar_t** args);
+  int commandLineExec(const wchar_t* module, const unsigned int argLen, wchar_t** args);
 
   void addPlugins(const std::list<std::wstring> plugins);