Changeset 254

Timestamp:

02/11/10 19:44:30 (2 years ago)

Author:

mickem

Message:

Preliminary NSCA support (much is hard coded right now so only a PoC not a finished concept)

Location:

trunk

Files:

• CMakeLists.txt (modified) (3 diffs)
• include/NSCHelper.cpp (modified) (5 diffs)
• include/NSCHelper.h (modified) (3 diffs)
• include/file (added)
• include/file/file_finder.cpp (added)
• include/file/file_finder.hpp (added)
• include/filter_framework.hpp (modified) (1 diff)
• include/nrpe/nrpe_packet.cpp (added)
• include/nrpe/nrpe_packet.hpp (added)
• include/nrpe/nrpe_socket.cpp (added)
• include/nrpe/nrpe_socket.hpp (added)
• include/nrpe/nrpepacket.cpp (deleted)
• include/nrpe/nrpepacket.hpp (deleted)
• include/nsc_module_wrapper.hpp (modified) (2 diffs)
• include/nsca (added)
• include/nsca/nsca_enrypt.hpp (added)
• include/nsca/nsca_packet.hpp (added)
• include/nsca/nsca_socket.hpp (added)
• include/socket_helpers.hpp (modified) (1 diff)
• include/strEx.h (modified) (5 diffs)
• include/swap_bytes.hpp (added)
• libs (added)
• libs/cryptopp (added)
• libs/cryptopp/CMakeLists.txt (added)
• libs/protobuf (added)
• libs/protobuf/CMakeLists.txt (added)
• libs/protobuf/plugin.proto (added)
• libs/protobuf/plugin.proto.h.in (added)
• modules/CheckExternalScripts/CheckExternalScripts.cpp (modified) (2 diffs)
• modules/NRPEClient/CMakeLists.txt (modified) (2 diffs)
• modules/NRPEClient/NRPEClient.cpp (modified) (4 diffs)
• modules/NRPEClient/NRPEClient.h (modified) (2 diffs)
• modules/NRPEServer/CMakeLists.txt (modified) (2 diffs)
• modules/NRPEServer/nrpe_connection.cpp (modified) (1 diff)
• modules/NRPEServer/nrpe_handler.hpp (modified) (1 diff)
• modules/NRPEServer/nrpe_parser.hpp (modified) (3 diffs)
• modules/NRPEServer/stdafx.h (modified) (1 diff)
• modules/NSCAAgent/CMakeLists.txt (added)
• modules/NSCAAgent/NSCAAgent.cpp (modified) (6 diffs)
• modules/NSCAAgent/NSCAAgent.def (modified) (1 diff)
• modules/NSCAAgent/NSCAAgent.h (modified) (2 diffs)
• modules/NSCAAgent/NSCAThread.cpp (modified) (3 diffs)
• modules/NSCAAgent/NSCAThread.h (modified) (4 diffs)
• modules/NSCAAgent/nsca_enrypt.hpp (deleted)
• modules/NSCAAgent/stdafx.h (modified) (3 diffs)
• modules/Scheduler/Scheduler.cpp (modified) (1 diff)
• proto/CMakeLists.txt (deleted)
• proto/plugin.proto (deleted)
• proto/plugin.proto.h.in (deleted)
• service/CMakeLists.txt (modified) (1 diff)
• service/NSCPlugin.cpp (modified) (4 diffs)
• service/NSCPlugin.h (modified) (3 diffs)
• service/NSClient++.cpp (modified) (5 diffs)
• service/NSClient++.h (modified) (4 diffs)
• service/channels.hpp (added)
• service/core_api.cpp (modified) (1 diff)
• service/core_api.h (modified) (1 diff)

trunk/CMakeLists.txt

@@ -26 +26 @@
 
 SET(NSCP_INCLUDE_PATH "${NSCP_SOURCE_DIR}/include" CACHE PATH "directory containing NSCP specific includes")
-SET(PB_PATH "${NSCP_SOURCE_DIR}/proto" CACHE PATH "directory containing NSCP specific protocol buffer files")
+#SET(PB_PATH "${NSCP_SOURCE_DIR}/proto" CACHE PATH "directory containing NSCP specific protocol buffer files")
 INCLUDE_DIRECTORIES(${NSCP_INCLUDE_PATH})
-INCLUDE_DIRECTORIES(${PB_PATH})
+#INCLUDE_DIRECTORIES(${PB_PATH})
 
 SET(BOOST_LIBRARYDIR ${BOOST_LIBRARYDIR} CACHE PATH "")
@@ -169 +169 @@
   ${EXTRA_LIBS}
   ${PROTOBUF_LIBRARY}
-  proto
-)
-  message(STATUS, "LIB: ${NSCP_DEF_PLUGIN_LIB}")
-
+  protobuf
+)
+message(STATUS, "LIB: ${NSCP_DEF_PLUGIN_LIB}")
+
+  
+SET(ALL_LIB_NAMES)
+FILE(GLOB ALL_LIB_PROJECTS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "libs/*/CMakeLists.txt")
+foreach(CURRENT_LIB ${ALL_LIB_PROJECTS})
+  get_filename_component(CURRENT_LIB_PATH ${CURRENT_LIB} PATH)
+  get_filename_component(CURRENT_LIB_NAME ${CURRENT_LIB_PATH} NAME)
+  message(STATUS "Adding library: ${CURRENT_LIB_PATH} (${CURRENT_LIB_NAME})")
+  ADD_SUBDIRECTORY("${CURRENT_LIB_PATH}")
+  SET(ALL_LIB_NAMES ${ALL_LIB_NAMES} ${CURRENT_LIB_NAME})
+endforeach(CURRENT_LIB ${ALL_LIB_PROJECTS})
+  
 
 # Compile time constants & make sure our build finds it
@@ -189 +200 @@
 MESSAGE(STATUS "Build path: ${PROJECT_BINARY_DIR}")
 ADD_SUBDIRECTORY("service")
-ADD_SUBDIRECTORY("proto")
 
 SET(ALL_MODULE_NAMES)

trunk/include/NSCHelper.cpp

@@ -358 +358 @@
 }
 
-NSCAPI::errorReturn NSCModuleHelper::NotifyChannel(std::wstring channel, std::wstring command, NSCAPI::nagiosReturn code, std::wstring message, std::wstring perf) {
+NSCAPI::errorReturn NSCModuleHelper::NotifyChannel(std::wstring channel, std::wstring command, NSCAPI::nagiosReturn code, std::string result) {
   if (!fNSAPINotify)
     throw NSCMHExcpetion(_T("NSCore has not been initiated..."));
-  return fNSAPINotify(channel.c_str(), command.c_str(), code, message.c_str(), perf.c_str());
+  return fNSAPINotify(channel.c_str(), command.c_str(), code, result.c_str(), result.size());
 }
 
@@ -422 +422 @@
     throw NSCMHExcpetion(_T("NSCore has not been initiated..."));
 
-
-  PluginCommand::RequestMessage message;
-  PluginCommand::Header *hdr = message.mutable_header();
-  hdr->set_type(PluginCommand::Header_Type_REQUEST);
-  hdr->set_version(PluginCommand::Header_Version_VERSION_1);
-
-  PluginCommand::Request *req = message.add_payload();
-  req->set_command(to_string(command));
-  req->set_version(PluginCommand::Request_Version_VERSION_1);
-
-  BOOST_FOREACH(std::wstring s, argument)
-    req->add_arguments(to_string(s));
-
-  std::string request;
-  message.SerializeToString(&request);
-
-  char *buffer = NULL;
-  unsigned int buffer_size = 0;
-
-  NSCAPI::nagiosReturn retC = InjectCommandRAW(command.c_str(), request.c_str(), request.size(), &buffer, &buffer_size);
-
-  if (buffer_size > 0 && buffer != NULL) {
+  std::string response;
+  NSCAPI::nagiosReturn ret = InjectCommand(command, argument, response);
+  if (!response.empty()) {
     PluginCommand::ResponseMessage rsp_msg;
-    std::string response(buffer, buffer_size);
     rsp_msg.ParseFromString(response);
     if (rsp_msg.payload_size() != 1) {
@@ -452 +432 @@
     }
     msg = to_wstring(rsp_msg.payload(0).message());
+  }
+  return ret;
+}
+/**
+* Inject a request command in the core (this will then be sent to the plug-in stack for processing)
+* @param command Command to inject (password should not be included.
+* @param argLen The length of the argument buffer
+* @param **argument The argument buffer
+* @param message The return message buffer
+* @param perf The return performance data buffer
+* @return The return of the command
+*/
+NSCAPI::nagiosReturn NSCModuleHelper::InjectCommand(const std::wstring command, const std::list<std::wstring> argument, std::string & result) 
+{
+  if (!fNSAPIInject)
+    throw NSCMHExcpetion(_T("NSCore has not been initiated..."));
+
+
+  PluginCommand::RequestMessage message;
+  PluginCommand::Header *hdr = message.mutable_header();
+  hdr->set_type(PluginCommand::Header_Type_REQUEST);
+  hdr->set_version(PluginCommand::Header_Version_VERSION_1);
+
+  PluginCommand::Request *req = message.add_payload();
+  req->set_command(to_string(command));
+  req->set_version(PluginCommand::Request_Version_VERSION_1);
+
+  BOOST_FOREACH(std::wstring s, argument)
+    req->add_arguments(to_string(s));
+
+  std::string request;
+  message.SerializeToString(&request);
+
+  char *buffer = NULL;
+  unsigned int buffer_size = 0;
+
+  NSCAPI::nagiosReturn retC = InjectCommandRAW(command.c_str(), request.c_str(), request.size(), &buffer, &buffer_size);
+
+  if (buffer_size > 0 && buffer != NULL) {
+    PluginCommand::ResponseMessage rsp_msg;
+    result = std::string(buffer, buffer_size);
   }
 
@@ -944 +965 @@
  */
 NSCAPI::boolReturn NSCModuleWrapper::wrapHasCommandHandler(bool has) {
-  if (has)
-    return NSCAPI::istrue;
-  return NSCAPI::isfalse;
+  return has?NSCAPI::istrue:NSCAPI::isfalse;
 }
 /**
@@ -954 +973 @@
  */
 NSCAPI::boolReturn NSCModuleWrapper::wrapHasMessageHandler(bool has) {
-  if (has)
-    return NSCAPI::istrue;
-  return NSCAPI::isfalse;
-}
+  return has?NSCAPI::istrue:NSCAPI::isfalse;
+}
+NSCAPI::boolReturn NSCModuleWrapper::wrapHasNotificationHandler(bool has) {
+  return has?NSCAPI::istrue:NSCAPI::isfalse;
+}
+
+NSCAPI::nagiosReturn NSCModuleWrapper::wrapHandleNotification(NSCAPI::nagiosReturn retResult) {
+  return retResult;
+}
+
 /**
  * Wrap the HandleCommand call

trunk/include/NSCHelper.h

@@ -140 +140 @@
   typedef NSCAPI::errorReturn (*lpNSAPIStopServer)(void);
   typedef NSCAPI::errorReturn (*lpNSAPIExit)(void);
-  typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const wchar_t* command, const char *request, const unsigned int request_len, char **response, unsigned int *response_len);
+  typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const wchar_t*, const char *, const unsigned int, char **, unsigned int *);
   typedef void (*lpNSAPIDestroyBuffer)(char**);
 
-  typedef NSCAPI::errorReturn (*lpNSAPINotify)(const wchar_t*, const wchar_t*, NSCAPI::nagiosReturn, const wchar_t*, const wchar_t*);
+  typedef NSCAPI::errorReturn (*lpNSAPINotify)(const wchar_t*, const wchar_t*, NSCAPI::nagiosReturn, const char*, unsigned int);
 
   typedef NSCAPI::boolReturn (*lpNSAPICheckLogMessages)(int);
@@ -177 +177 @@
   NSCAPI::nagiosReturn InjectCommandRAW(const wchar_t* command, const char *request, const unsigned int request_len, char **response, unsigned int *response_len);
   void DestroyBuffer(char**buffer);
+  NSCAPI::nagiosReturn InjectCommand(const std::wstring command, const std::list<std::wstring> argument, std::string & result);
   NSCAPI::nagiosReturn InjectSimpleCommand(const std::wstring command, const std::list<std::wstring> argument, std::wstring & message, std::wstring & perf);
-  NSCAPI::errorReturn NotifyChannel(std::wstring channel, std::wstring command, NSCAPI::nagiosReturn code, std::wstring message, std::wstring perf);
+  NSCAPI::errorReturn NotifyChannel(std::wstring channel, std::wstring command, NSCAPI::nagiosReturn code, std::string result);
   NSCAPI::nagiosReturn InjectSplitAndCommand(const wchar_t* command, wchar_t* buffer, wchar_t splitChar, std::wstring & message, std::wstring & perf);
   NSCAPI::nagiosReturn InjectSplitAndCommand(const std::wstring command, const std::wstring buffer, wchar_t splitChar, std::wstring & message, std::wstring & perf, bool escape = false);
@@ -201 +202 @@
 
 
+  class SimpleNotificationHandler {
+  public:
+    NSCAPI::nagiosReturn handleRAWNotification(const wchar_t* channel, const wchar_t* command, NSCAPI::nagiosReturn code, std::string result) {
+      try {
+        PluginCommand::ResponseMessage message;
+        message.ParseFromString(result);
+        if (message.payload_size() != 1) {
+          //NSC_LOG_ERROR_STD(_T("Unsupported payload size: ") + to_wstring(request_message.payload_size()));
+          return NSCAPI::returnIgnored;
+        }
+
+        ::PluginCommand::Response payload = message.payload().Get(0);
+        std::list<std::wstring> args;
+        for (int i=0;i<payload.arguments_size();i++) {
+          args.push_back(to_wstring(payload.arguments(i)));
+        }
+        std::wstring msg = to_wstring(payload.message()), perf;
+        NSCAPI::nagiosReturn ret = handleSimpleNotification(channel, command, code, msg, perf);
+      } catch (std::exception &e) {
+        std::cout << "Failed to parse data from: " << strEx::strip_hex(result) << e.what() <<  std::endl;;
+      } catch (...) {
+        std::cout << "Failed to parse data from: " << strEx::strip_hex(result) << std::endl;;
+      }
+
+      return -1;
+    }
+    virtual NSCAPI::nagiosReturn handleSimpleNotification(const std::wstring channel, const std::wstring command, NSCAPI::nagiosReturn code, std::wstring msg, std::wstring perf) = 0;
+
+  };
+
   class SimpleCommand {
 

trunk/include/filter_framework.hpp

@@ -51 +51 @@
       static bool filter(std::wstring filter, std::wstring str) {
         return str == filter;
+      }
+    };
+    struct not_string_filter {
+      static bool filter(std::wstring filter, std::wstring str) {
+        return !(str == filter);
       }
     };

trunk/include/nsc_module_wrapper.hpp

@@ -23 +23 @@
   NSCAPI::boolReturn wrapHasCommandHandler(bool has);
   NSCAPI::boolReturn wrapHasMessageHandler(bool has);
+  NSCAPI::boolReturn wrapHasNotificationHandler(bool has);
+  NSCAPI::nagiosReturn wrapHandleNotification(NSCAPI::nagiosReturn retResult);
   int wrapUnloadModule(bool success);
   NSCAPI::nagiosReturn wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::string &reply, char **reply_buffer, unsigned int *size);
@@ -170 +172 @@
   extern NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* command, const char* request_buffer, const unsigned int request_buffer_len, char** reply_buffer, unsigned int *reply_buffer_len) \
   { \
-    try { \
-      std::string request(request_buffer, request_buffer_len), reply; \
-      NSCAPI::nagiosReturn retCode = (&toObject)->handleRAWCommand(command, request, reply); \
-      return NSCModuleWrapper::wrapHandleCommand(retCode, reply, reply_buffer, reply_buffer_len); \
-    } catch (...) { \
-      NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHandleCommand(...)")); \
-      return NSCAPI::returnIgnored; \
+  try { \
+  std::string request(request_buffer, request_buffer_len), reply; \
+  NSCAPI::nagiosReturn retCode = (&toObject)->handleRAWCommand(command, request, reply); \
+  return NSCModuleWrapper::wrapHandleCommand(retCode, reply, reply_buffer, reply_buffer_len); \
+    } catch (...) { \
+    NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHandleCommand(...)")); \
+    return NSCAPI::returnIgnored; \
     } \
   } \
   extern NSCAPI::boolReturn NSHasCommandHandler() { \
-    try { \
-      return NSCModuleWrapper::wrapHasCommandHandler(toObject.hasCommandHandler()); \
-    } catch (...) { \
-      NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHasCommandHandler(...)")); \
-      return NSCAPI::isfalse; \
+  try { \
+  return NSCModuleWrapper::wrapHasCommandHandler(toObject.hasCommandHandler()); \
+    } catch (...) { \
+    NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHasCommandHandler(...)")); \
+    return NSCAPI::isfalse; \
     } \
   }
 #define NSC_WRAPPERS_IGNORE_CMD_DEF() \
   extern NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* IN_cmd, const unsigned int IN_argsLen, wchar_t **IN_args, \
-                  wchar_t *OUT_retBufMessage, unsigned int IN_retBufMessageLen, wchar_t *OUT_retBufPerf, unsigned int IN_retBufPerfLen) { \
-    return NSCAPI::returnIgnored; \
+  wchar_t *OUT_retBufMessage, unsigned int IN_retBufMessageLen, wchar_t *OUT_retBufPerf, unsigned int IN_retBufPerfLen) { \
+  return NSCAPI::returnIgnored; \
   } \
   extern NSCAPI::boolReturn NSHasCommandHandler() { return NSCAPI::isfalse; }
+#define NSC_WRAPPERS_IGNORE_NOTIFICATION_DEF() \
+  extern void NSHandleNotification(const wchar_t*, const wchar_t*, NSCAPI::nagiosReturn, const char*, unsigned int) {} \
+  extern NSCAPI::boolReturn NSHasNotificationHandler() { return NSCAPI::isfalse; }
+#define NSC_WRAPPERS_HANDLE_NOTIFICATION_DEF(toObject) \
+  extern NSCAPI::nagiosReturn NSHandleNotification(const wchar_t* channel, const wchar_t* command, NSCAPI::nagiosReturn code, const char* result_buffer, unsigned int result_buffer_len) \
+  { \
+    try { \
+      std::string result(result_buffer, result_buffer_len); \
+      return NSCModuleWrapper::wrapHandleNotification((&toObject)->handleRAWNotification(channel, command, code, result)); \
+    } catch (...) { \
+      NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHasNotificationHandler(...)")); \
+      return NSCAPI::returnIgnored; \
+    } \
+  } \
+  extern NSCAPI::boolReturn NSHasNotificationHandler() { \
+    try { \
+      return NSCModuleWrapper::wrapHasNotificationHandler(toObject.hasNotificationHandler()); \
+    } catch (...) { \
+      NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHasNotificationHandler(...)")); \
+      return NSCAPI::isfalse; \
+    } \
+  }
 
 

trunk/include/socket_helpers.hpp

@@ -115 +115 @@
     }
   };
+
+  namespace io {
+    void set_result(boost::optional<boost::system::error_code>* a, boost::system::error_code b) {
+      a->reset(b);
+    } 
+
+    template <typename AsyncReadStream, typename RawSocket, typename MutableBufferSequence>
+    void read_with_timeout(AsyncReadStream& sock, RawSocket& rawSocket, const MutableBufferSequence& buffers, boost::posix_time::time_duration duration) {
+      boost::optional<boost::system::error_code> timer_result;
+      boost::asio::deadline_timer timer(sock.io_service());
+      timer.expires_from_now(duration);
+      timer.async_wait(boost::bind(set_result, &timer_result, _1));
+
+      boost::optional<boost::system::error_code> read_result;
+      async_read(sock, buffers, boost::bind(set_result, &read_result, _1));
+
+      sock.io_service().reset();
+      while (sock.io_service().run_one()) {
+        if (read_result)
+          timer.cancel();
+        else if (timer_result)
+          rawSocket.close();
+      }
+
+      if (*read_result)
+        throw boost::system::system_error(*read_result);
+    } 
+
+    template <typename AsyncWriteStream, typename RawSocket, typename MutableBufferSequence>
+    void write_with_timeout(AsyncWriteStream& sock, RawSocket& rawSocket, const MutableBufferSequence& buffers, boost::posix_time::time_duration duration) {
+      boost::optional<boost::system::error_code> timer_result;
+      boost::asio::deadline_timer timer(sock.io_service());
+      timer.expires_from_now(duration);
+      timer.async_wait(boost::bind(set_result, &timer_result, _1));
+
+      boost::optional<boost::system::error_code> read_result;
+      async_write(sock, buffers, boost::bind(set_result, &read_result, _1));
+
+      sock.io_service().reset();
+      while (sock.io_service().run_one()) {
+        if (read_result)
+          timer.cancel();
+        else if (timer_result)
+          rawSocket.close();
+      }
+
+      if (*read_result)
+        throw boost::system::system_error(*read_result);
+    }
+
+  }
 }
+

trunk/include/strEx.h

@@ -74 +74 @@
     std::locale loc;
     for(unsigned int i= 0; i < arg.size(); ++i)
-      result += std::use_facet<std::ctype<char> >(loc).narrow(arg[i], 0);
+      result += std::use_facet<std::ctype<wchar_t> >(loc).narrow(arg[i], 0);
     return result;
   }
@@ -112 +112 @@
       if (c==0||c==7||c==10||c==11||c==12||c==13||c==127)
         ret.push_back(L'?');
+      else
+        ret.push_back(c);
+    }
+    return ret;
+  }
+  inline std::string strip_hex(std::string str) {
+    std::string ret; ret.reserve(str.size());
+    BOOST_FOREACH(char c, str)
+    {
+      if (c==0||c==7||c==10||c==11||c==12||c==13||c==127)
+        ret.push_back('?');
       else
         ret.push_back(c);
@@ -404 +415 @@
     return value * smallest_unit;
   }
+  inline long stol_as_time_sec(std::wstring time, unsigned int smallest_unit = 1) {
+    long neg = 1;
+    if (time.length() > 1 && time[0] == L'-')
+      return -stoui_as_time_sec(time.substr(1), smallest_unit);
+    return stoui_as_time_sec(time, smallest_unit);
+  }
 
   inline unsigned long long stoi64_as_time(std::wstring time, unsigned int smallest_unit = 1000) {
@@ -809 +826 @@
     return boost::lexical_cast<std::string>(arg) ;
   }
-  catch(boost::bad_lexical_cast& e) {
+  catch(...) {
     return "";
   }
@@ -817 +834 @@
     return boost::lexical_cast<std::wstring>(arg) ;
   }
-  catch(boost::bad_lexical_cast& e) {
+  catch(...) {
     return _T("");
   }

trunk/modules/CheckExternalScripts/CheckExternalScripts.cpp

@@ -35 +35 @@
 
 CheckExternalScripts gCheckExternalScripts;
-#ifdef _WIN32
-BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
-{
-  NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
-  return TRUE;
-}
-#endif
 
 CheckExternalScripts::CheckExternalScripts() {}
@@ -174 +167 @@
 
 
+NSC_WRAP_DLL();
 NSC_WRAPPERS_MAIN_DEF(gCheckExternalScripts);
 NSC_WRAPPERS_IGNORE_MSG_DEF();

trunk/modules/NRPEClient/CMakeLists.txt

@@ -8 +8 @@
   stdafx.cpp
   "${TARGET}.cpp"
-  ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.cpp
+  ${NSCP_INCLUDE_PATH}/nrpe/nrpe_packet.cpp
 
   ${NSCP_DEF_PLUGIN_CPP}
@@ -20 +20 @@
     "${TARGET}.h"
     "${TARGET}.def"
-    ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.hpp
     ${NSCP_INCLUDE_PATH}/socket_helpers.hpp
+    ${NSCP_INCLUDE_PATH}/nrpe/nrpe_packet.hpp
+    ${NSCP_INCLUDE_PATH}/nrpe/nrpe_socket.hpp
+    ${NSCP_INCLUDE_PATH}/swap_bytes.hpp
 
     ${NSCP_DEF_PLUGIN_HPP}

trunk/modules/NRPEClient/NRPEClient.cpp

@@ -29 +29 @@
 #include <boost/filesystem.hpp>
 #include <strEx.h>
+#include <nrpe/nrpe_socket.hpp>
 
 
@@ -217 +218 @@
   }
 }
-/*
-NRPEPacket NRPEClient::send_ssl(std::wstring host, int port, int timeout, NRPEPacket packet)
-{
-#ifndef USE_SSL
-  return send_nossl(host, port, timeout, packet);
-#else
-  
-  simpleSSL::Socket socket(true);
-  socket.connect(host, port);
-  NSC_DEBUG_MSG_STD(_T(">>>length: ") + strEx::itos(packet.getBufferLength()));
-  socket.sendAll(packet.getBuffer(), packet.getBufferLength());
-  simpleSocket::DataBuffer buffer;
-  socket.readAll(buffer, packet.getBufferLength());
-  NSC_DEBUG_MSG_STD(_T("<<<length: ") + strEx::itos(buffer.getLength()));
-  packet.readFrom(buffer.getBuffer(), buffer.getLength());
-  return packet;
-  
-
-  boost::asio::ssl::context ctx(io_service, boost::asio::ssl::context::sslv23);
-  ctx.use_tmp_dh_file("d:\\nrpe_512.pem");
-  ctx.set_verify_mode(boost::asio::ssl::context::verify_peer);
-  nrpe_ssl_socket socket(io_service, ctx, host, port);
-  //socket.
-
-#endif
-}
-*/
-using boost::asio::ip::tcp;
-
-void set_result(boost::optional<boost::system::error_code>* a, boost::system::error_code b)
-{
-  a->reset(b);
-} 
-template <typename AsyncReadStream, typename RawSocket, typename MutableBufferSequence>
-void read_with_timeout(AsyncReadStream& sock, RawSocket& rawSocket, const MutableBufferSequence& buffers, boost::posix_time::time_duration duration)
-{
-  boost::optional<boost::system::error_code> timer_result;
-  boost::asio::deadline_timer timer(sock.io_service());
-  timer.expires_from_now(duration);
-  timer.async_wait(boost::bind(set_result, &timer_result, _1));
-
-  boost::optional<boost::system::error_code> read_result;
-  async_read(sock, buffers, boost::bind(set_result, &read_result, _1));
-
-  sock.io_service().reset();
-  while (sock.io_service().run_one())
-  {
-    if (read_result)
-      timer.cancel();
-    else if (timer_result)
-      rawSocket.close();
-  }
-
-  if (*read_result)
-    throw boost::system::system_error(*read_result);
-} 
-
-template <typename AsyncWriteStream, typename RawSocket, typename MutableBufferSequence>
-void write_with_timeout(AsyncWriteStream& sock, RawSocket& rawSocket, const MutableBufferSequence& buffers, boost::posix_time::time_duration duration)
-{
-  boost::optional<boost::system::error_code> timer_result;
-  boost::asio::deadline_timer timer(sock.io_service());
-  timer.expires_from_now(duration);
-  timer.async_wait(boost::bind(set_result, &timer_result, _1));
-
-  boost::optional<boost::system::error_code> read_result;
-  async_write(sock, buffers, boost::bind(set_result, &read_result, _1));
-
-  sock.io_service().reset();
-  while (sock.io_service().run_one())
-  {
-    if (read_result)
-      timer.cancel();
-    else if (timer_result)
-      rawSocket.close();
-  }
-
-  if (*read_result)
-    throw boost::system::system_error(*read_result);
-}
-
-class nrpe_socket : public boost::noncopyable {
-public:
-  tcp::socket socket_;
-
-public:
-  nrpe_socket(boost::asio::io_service &io_service, std::wstring host, int port) : socket_(io_service) {
-    tcp::resolver resolver(io_service);
-    tcp::resolver::query query(to_string(host), to_string(port));
-    //tcp::resolver::query query("www.medin.name", "80");
-    //tcp::resolver::query query("test_server", "80");
-
-    tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
-    tcp::resolver::iterator end;
-
-    boost::system::error_code error = boost::asio::error::host_not_found;
-    while (error && endpoint_iterator != end)
-    {
-      tcp::resolver::endpoint_type ep = *endpoint_iterator;
-      NSC_DEBUG_MSG_STD(_T("Attempting to connect to: ") + to_wstring(ep.address().to_string()) + _T(":") + to_wstring(ep.port()));
-      socket_.close();
-      socket_.connect(*endpoint_iterator++, error);
-    }
-    if (error)
-      throw boost::system::system_error(error);
-  }
-  ~nrpe_socket() {
-    socket_.close();
-  }
-
-  void send(nrpe::packet &packet, boost::posix_time::seconds timeout) {
-    std::vector<char> buf(packet.get_packet_length());
-    write_with_timeout(socket_, socket_, boost::asio::buffer(packet.create_buffer(), packet.get_packet_length()), timeout);
-  }
-  nrpe::packet recv(const nrpe::packet &packet, boost::posix_time::seconds timeout) {
-    std::vector<char> buf(packet.get_packet_length());
-    std::cout <<  "About to read: " << buf.size() << std::endl;
-    read_with_timeout(socket_, socket_, boost::asio::buffer(buf), timeout);
-    std::cout <<  "Read data: " << buf.size() << std::endl;
-    return nrpe::packet(&buf[0], buf.size(), packet.get_payload_length());
-  }
-};
+
+
 #ifdef USE_SSL
-
-class nrpe_ssl_socket {
-
-private:
-  boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket_;
-public:
-  nrpe_ssl_socket(boost::asio::io_service &io_service, boost::asio::ssl::context &ctx, std::wstring host, int port) : socket_(io_service, ctx) {
-    NSC_LOG_CRITICAL(_T("Looking up..."));
-    tcp::resolver resolver(io_service);
-    tcp::resolver::query query(to_string(host), to_string(port));
-    //tcp::resolver::query query("www.medin.name", "80");
-    //tcp::resolver::query query("test_server", "80");
-
-    tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
-    tcp::resolver::iterator end;
-
-    boost::system::error_code error = boost::asio::error::host_not_found;
-    NSC_LOG_CRITICAL(_T("Connecting..."));
-    while (error && endpoint_iterator != end)
-    {
-      tcp::resolver::endpoint_type ep = *endpoint_iterator;
-      NSC_DEBUG_MSG_STD(_T("Attempting to connect to: ") + to_wstring(ep.address().to_string()) + _T(":") + to_wstring(ep.port()));
-      socket_.lowest_layer().close();
-      socket_.lowest_layer().connect(*endpoint_iterator++, error);
-    }
-    if (error)
-      throw boost::system::system_error(error);
-    NSC_LOG_CRITICAL(_T("Connected..."));
-
-    NSC_LOG_CRITICAL(_T("Handshaking..."));
-    //socket_.handshake(boost::asio::ssl::stream_base::client);
-    socket_.handshake(boost::asio::ssl::stream_base::client);
-    NSC_LOG_CRITICAL(_T("Handshook...") + strEx::itos(error.value()));
-
-  }
-
-  void send(nrpe::packet &packet, boost::posix_time::seconds timeout) {
-    std::vector<char> buf(packet.get_packet_length());
-    write_with_timeout(socket_, socket_.lowest_layer(), boost::asio::buffer(packet.create_buffer(), packet.get_packet_length()), timeout);
-  }
-  nrpe::packet recv(const nrpe::packet &packet, boost::posix_time::seconds timeout) {
-    std::vector<char> buf(packet.get_packet_length());
-    read_with_timeout(socket_, socket_.lowest_layer(), boost::asio::buffer(buf), timeout);
-    return nrpe::packet(&buf[0], buf.size(), packet.get_payload_length());
-  }
-};
-nrpe::packet NRPEClient::send_ssl(std::wstring host, int port, int timeout, nrpe::packet packet)
-{
+nrpe::packet NRPEClient::send_ssl(std::wstring host, int port, int timeout, nrpe::packet packet) {
   boost::asio::io_service io_service;
   boost::asio::ssl::context ctx(io_service, boost::asio::ssl::context::sslv23);
@@ -393 +227 @@
   ctx.use_tmp_dh_file(to_string(cert_));
   ctx.set_verify_mode(boost::asio::ssl::context::verify_none);
-  nrpe_ssl_socket socket(io_service, ctx, host, port);
+  nrpe::ssl_socket socket(io_service, ctx, host, port);
   socket.send(packet, boost::posix_time::seconds(timeout));
   return socket.recv(packet, boost::posix_time::seconds(timeout));
@@ -399 +233 @@
 #endif
 
-nrpe::packet NRPEClient::send_nossl(std::wstring host, int port, int timeout, nrpe::packet packet)
-{
+nrpe::packet NRPEClient::send_nossl(std::wstring host, int port, int timeout, nrpe::packet packet) {
   boost::asio::io_service io_service;
-  nrpe_socket socket(io_service, host, port);
+  nrpe::socket socket(io_service, host, port);
   socket.send(packet, boost::posix_time::seconds(timeout));
   return socket.recv(packet, boost::posix_time::seconds(timeout));

trunk/modules/NRPEClient/NRPEClient.h

@@ -22 +22 @@
 NSC_WRAPPERS_MAIN();
 #include <map>
-#include <nrpe/nrpepacket.hpp>
+#include <nrpe/nrpe_packet.hpp>
 
 
@@ -127 +127 @@
   nrpe::packet send_ssl(std::wstring host, int port, int timeout, nrpe::packet packet);
   void add_options(po::options_description &desc, nrpe_connection_data &command_data);
-#ifdef USE_BOOST
-#endif
 
 private:

trunk/modules/NRPEServer/CMakeLists.txt

@@ -14 +14 @@
   nrpe_connection.cpp
   nrpe_handler.cpp
-  ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.cpp
+  ${NSCP_INCLUDE_PATH}/nrpe/nrpe_packet.cpp
 
   ${NSCP_DEF_PLUGIN_CPP}
@@ -30 +30 @@
     nrpe_handler.hpp
     nrpe_parser.hpp
-    ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.hpp
     ${NSCP_INCLUDE_PATH}/socket_helpers.hpp
+    ${NSCP_INCLUDE_PATH}/nrpe/nrpe_packet.hpp
+    ${NSCP_INCLUDE_PATH}/swap_bytes.hpp
 
     ${NSCP_DEF_PLUGIN_HPP}

trunk/modules/NRPEServer/nrpe_connection.cpp

@@ -41 +41 @@
           boost::tie(result, begin) = parser_.digest(begin, end);
           if (begin == old_begin) {
-            std::cout << "Whoops, this is wrong...";
+            handler_.create_error(_T("Something strange happened..."));
             return;
           }

trunk/modules/NRPEServer/nrpe_handler.hpp

@@ -1 @@
-#include <nrpe/nrpepacket.hpp>
+#include <nrpe/nrpe_packet.hpp>
 #include <boost/tuple/tuple.hpp>
 

trunk/modules/NRPEServer/nrpe_parser.hpp

@@ -1 @@
-#include <nrpe/nrpepacket.hpp>
+#include <nrpe/nrpe_packet.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/noncopyable.hpp>
@@ -13 +13 @@
         : payload_length_(payload_length)
         , packet_length_(nrpe::length::get_packet_length(payload_length))
-      {
-        std::cout << "== ctor length: " << payload_length_ << "/" << packet_length_ << std::endl;
-      }
+      {}
 
       template <typename InputIterator>
       boost::tuple<bool, InputIterator> digest(InputIterator begin, InputIterator end) {
-        std::cout << "== Parsing: " << payload_length_ << "/" << packet_length_ << std::endl;
         int count = packet_length_ - buffer_.size();
-        std::cout << "Bytes already: " << buffer_.size() << ", need more: " << count << " got: " << (end-begin) << std::endl;
         for (; count > 0&& begin != end; ++begin, --count)
           buffer_.push_back(*begin);
@@ -35 +31 @@
         payload_length_ = length;
         packet_length_ = nrpe::length::get_packet_length(length);
-        std::cout << "== Setting length: " << payload_length_ << "/" << packet_length_ << std::endl;
       }
     };

trunk/modules/NRPEServer/stdafx.h

@@ -48 +48 @@
 #include <NSCHelper.h>
 #include <nsc_module_wrapper.hpp>
-#include <nrpe/nrpepacket.hpp>
+#include <nrpe/nrpe_packet.hpp>
 

trunk/modules/NSCAAgent/NSCAAgent.cpp

@@ -25 +25 @@
 #include <list>
 #include <string>
+#include <nsca/nsca_enrypt.hpp>
+#include <nsca/nsca_packet.hpp>
+#include <nsca/nsca_socket.hpp>
 
 NSCAAgent gNSCAAgent;
@@ -63 +66 @@
     SETTINGS_REG_PATH(nsca::CMD_SECTION);
 
-    SETTINGS_REG_KEY_I(nsca::INTERVAL);
     SETTINGS_REG_KEY_S(nsca::HOSTNAME);
     SETTINGS_REG_KEY_S(nsca::SERVER_HOST);
@@ -69 +71 @@
     SETTINGS_REG_KEY_I(nsca::ENCRYPTION);
     SETTINGS_REG_KEY_S(nsca::PASSWORD);
-    SETTINGS_REG_KEY_I(nsca::THREADS);
     SETTINGS_REG_KEY_B(nsca::CACHE_HOST);
+
+    hostname_ = to_string(SETTINGS_GET_STRING(nsca::HOSTNAME));
+    nscahost_ = SETTINGS_GET_STRING(nsca::SERVER_HOST);
+    nscaport_ = SETTINGS_GET_INT(nsca::SERVER_PORT);
+
+    encryption_method_ = SETTINGS_GET_INT(nsca::ENCRYPTION);
+    password_ = strEx::wstring_to_string(SETTINGS_GET_STRING(nsca::PASSWORD));
+    cacheNscaHost_ = SETTINGS_GET_INT(nsca::CACHE_HOST);
+    timeout_ = SETTINGS_GET_INT(nsca::READ_TIMEOUT);
+    payload_length_ = SETTINGS_GET_INT(nsca::PAYLOAD_LENGTH);
+    time_delta_ = strEx::stol_as_time_sec(SETTINGS_GET_STRING(nsca::TIME_DELTA_DEFAULT), 1);
 
 
@@ -79 +91 @@
   }
 
-  if (mode == NSCAPI::normalStart) {
-    int e_threads = SETTINGS_GET_INT(nsca::THREADS);
 
-    for (int i=0;i<e_threads;i++) {
-      std::wstring id = _T("nsca_t_") + strEx::itos(i);
-      NSCAThreadImpl *thread = new NSCAThreadImpl(id);
-      extra_threads.push_back(thread);
-    }
-    for (std::list<NSCAThreadImpl*>::const_iterator cit=extra_threads.begin();cit != extra_threads.end(); ++cit) {
-      (*cit)->createThread(reinterpret_cast<LPVOID>(rand()));
-    }
-  }
-  
   return true;
 }
@@ -100 +100 @@
  */
 bool NSCAAgent::unloadModule() {
-  /*
-  if (!pdhThread.exitThread(20000)) {
-    std::wcout << _T("MAJOR ERROR: Could not unload thread...") << std::endl;
-    NSC_LOG_ERROR(_T("Could not exit the thread, memory leak and potential corruption may be the result..."));
-  }
-  */
-  for (std::list<NSCAThreadImpl*>::iterator it=extra_threads.begin();it != extra_threads.end(); ++it) {
-    if (!(*it)->exitThread(20000)) {
-      std::wcout << _T("MAJOR ERROR: Could not unload thread...") << std::endl;
-      NSC_LOG_ERROR(_T("Could not exit the thread, memory leak and potential corruption may be the result..."));
-    }
-  }
   return true;
-}
-/**
- * Check if we have a command handler.
- * @return true (as we have a command handler)
- */
-bool NSCAAgent::hasCommandHandler() {
-  return false;
-}
-/**
- * Check if we have a message handler.
- * @return false as we have no message handler
- */
-bool NSCAAgent::hasMessageHandler() {
-  return false;
-}
-
-int NSCAAgent::commandLineExec(const TCHAR* command, const unsigned int argLen, TCHAR** args) {
-  return -1;
-}
-
-
-/**
- * Main command parser and delegator.
- * This also handles a lot of the simpler responses (though some are deferred to other helper functions)
- *
- *
- * @param command 
- * @param argLen 
- * @param **args 
- * @return 
- */
-NSCAPI::nagiosReturn NSCAAgent::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) {
-  return NSCAPI::returnIgnored;
 }
 std::wstring NSCAAgent::getCryptos() {
   std::wstring ret = _T("{");
   for (int i=0;i<LAST_ENCRYPTION_ID;i++) {
-    if (nsca_encrypt::hasEncryption(i)) {
+    if (nsca::nsca_encrypt::hasEncryption(i)) {
       std::wstring name;
       try {
-        nsca_encrypt::any_encryption *core = nsca_encrypt::get_encryption_core(i);
+        nsca::nsca_encrypt::any_encryption *core = nsca::nsca_encrypt::get_encryption_core(i);
         if (core == NULL)
           name = _T("Broken<NULL>");
         else
           name = core->getName();
-      } catch (nsca_encrypt::encryption_exception &e) {
+      } catch (nsca::nsca_encrypt::encryption_exception &e) {
         name = e.getMessage();
       }
@@ -169 +124 @@
 }
 
+NSCAPI::nagiosReturn NSCAAgent::handleSimpleNotification(const std::wstring channel, const std::wstring command, NSCAPI::nagiosReturn code, std::wstring msg, std::wstring perf) {
+  try {
+    NSC_DEBUG_MSG_STD(_T("* * *NSCA * * * Handling command: ") + command);
+    boost::asio::io_service io_service;
+    NSC_DEBUG_MSG_STD(_T("* * *NSCA * * * message: ") + msg);
+    nsca::socket socket(io_service);
+    socket.connect(nscahost_, nscaport_);
+    nsca::packet packet(hostname_, payload_length_, time_delta_);
+    packet.code = code;
+    packet.host = "hello";
+    packet.result = to_string(msg);
+    socket.recv_iv(password_, encryption_method_, boost::posix_time::seconds(timeout_));
+    socket.send_nsca(packet, boost::posix_time::seconds(timeout_));
+    return 1;
+  } catch (std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to send data: ") + to_wstring(e.what()));
+  } catch (...) {
+    NSC_LOG_ERROR_STD(_T("Failed to send data: UNKNOWN"));
+  }
+}
+
 
 NSC_WRAPPERS_MAIN_DEF(gNSCAAgent);
 NSC_WRAPPERS_IGNORE_MSG_DEF();
-NSC_WRAPPERS_HANDLE_CMD_DEF(gNSCAAgent);
-NSC_WRAPPERS_HANDLE_CONFIGURATION(gNSCAAgent);
-NSC_WRAPPERS_CLI_DEF(gNSCAAgent);
-
-
-
-MODULE_SETTINGS_START(NSCAAgent, _T("NRPE Listener configuration"), _T("...")) 
-
-PAGE(_T("NRPE Listsner configuration")) 
-
-ITEM_EDIT_TEXT(_T("port"), _T("This is the port the NRPEListener.dll will listen to.")) 
-ITEM_MAP_TO(_T("basic_ini_text_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("port")) 
-OPTION(_T("default"), _T("5666")) 
-ITEM_END()
-
-ITEM_CHECK_BOOL(_T("allow_arguments"), _T("This option determines whether or not the NRPE daemon will allow clients to specify arguments to commands that are executed.")) 
-ITEM_MAP_TO(_T("basic_ini_bool_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("allow_arguments")) 
-OPTION(_T("default"), _T("false")) 
-OPTION(_T("true_value"), _T("1")) 
-OPTION(_T("false_value"), _T("0")) 
-ITEM_END()
-
-ITEM_CHECK_BOOL(_T("allow_nasty_meta_chars"), _T("This might have security implications (depending on what you do with the options)")) 
-ITEM_MAP_TO(_T("basic_ini_bool_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("allow_nasty_meta_chars")) 
-OPTION(_T("default"), _T("false")) 
-OPTION(_T("true_value"), _T("1")) 
-OPTION(_T("false_value"), _T("0")) 
-ITEM_END()
-
-ITEM_CHECK_BOOL(_T("use_ssl"), _T("This option will enable SSL encryption on the NRPE data socket (this increases security somwhat.")) 
-ITEM_MAP_TO(_T("basic_ini_bool_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("use_ssl")) 
-OPTION(_T("default"), _T("true")) 
-OPTION(_T("true_value"), _T("1")) 
-OPTION(_T("false_value"), _T("0")) 
-ITEM_END()
-
-PAGE_END()
-ADVANCED_PAGE(_T("Access configuration")) 
-
-ITEM_EDIT_OPTIONAL_LIST(_T("Allow connection from:"), _T("This is the hosts that will be allowed to poll performance data from the NRPE server.")) 
-OPTION(_T("disabledCaption"), _T("Use global settings (defined previously)")) 
-OPTION(_T("enabledCaption"), _T("Specify hosts for NRPE server")) 
-OPTION(_T("listCaption"), _T("Add all IP addresses (not hosts) which should be able to connect:")) 
-OPTION(_T("separator"), _T(",")) 
-OPTION(_T("disabled"), _T("")) 
-ITEM_MAP_TO(_T("basic_ini_text_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("allowed_hosts")) 
-OPTION(_T("default"), _T("")) 
-ITEM_END()
-
-PAGE_END()
-MODULE_SETTINGS_END()
+NSC_WRAPPERS_IGNORE_CMD_DEF();
+NSC_WRAPPERS_HANDLE_NOTIFICATION_DEF(gNSCAAgent);

trunk/modules/NSCAAgent/NSCAAgent.def

@@ -11 +11 @@
   NSHandleCommand
   NSUnloadModule
-  NSGetConfigurationMeta
   NSGetModuleDescription
-  NSCommandLineExec
+  NSDeleteBuffer
+  NSHandleNotification
+  NSHasNotificationHandler

trunk/modules/NSCAAgent/NSCAAgent.h

@@ -21 +21 @@
 #pragma once
 
-#include "NSCAThread.h"
 #include <CheckMemory.h>
 
 NSC_WRAPPERS_MAIN();
-NSC_WRAPPERS_CLI();
 
-class NSCAAgent {
+class NSCAAgent : public NSCModuleHelper::SimpleNotificationHandler {
 private:
-  CheckMemory memoryChecker;
-  int processMethod_;
-//  NSCAThreadImpl pdhThread;
-  std::list<NSCAThreadImpl*> extra_threads;
 
-public:
+  std::string hostname_;
+  std::wstring nscahost_;
+  unsigned int nscaport_;
+  unsigned int payload_length_;
+  bool cacheNscaHost_;
+  std::string password_;
+  int encryption_method_;
+  unsigned int timeout_;
+  int time_delta_;
 
 public:
@@ -66 +68 @@
     return std::wstring(_T("Passive check support (needs NSCA on nagios server).\nAvalible crypto are: ")) + getCryptos();
   }
-
-  bool hasCommandHandler();
-  bool hasMessageHandler();
-  NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf);
-  int commandLineExec(const TCHAR* command, const unsigned int argLen, TCHAR** args);
+  bool hasNotificationHandler() { return true; }
 
   std::wstring getCryptos();
 
+  NSCAPI::nagiosReturn handleSimpleNotification(const std::wstring channel, const std::wstring command, NSCAPI::nagiosReturn code, std::wstring msg, std::wstring perf);
+
+
 };

trunk/modules/NSCAAgent/NSCAThread.cpp

@@ -90 +90 @@
   read_timeout_ = SETTINGS_GET_INT(nsca::READ_TIMEOUT);
 
-  std::list<std::wstring> items = NSCModuleHelper::getSettingsSection(settings::nsca::CMD_SECTION_TITLE);
+  std::list<std::wstring> items = NSCModuleHelper::getSettingsSection(setting_keys::nsca::CMD_SECTION_TITLE);
   for (std::list<std::wstring>::const_iterator cit = items.begin(); cit != items.end(); ++cit) {
     addCommand(*cit);
@@ -118 +118 @@
   std::wstring msg;
   std::wstring perf;
-  NSCAPI::nagiosReturn ret = NSCModuleHelper::InjectCommand(cmd_.c_str(), args_.getLen(), args_.get(), msg, perf);
+  NSCAPI::nagiosReturn ret = NSCModuleHelper::InjectSimpleCommand(cmd_.c_str(), args_, msg, perf);
   result.service = alias_;
   if (ret == NSCAPI::returnIgnored) {
@@ -139 +139 @@
 
 void NSCAThread::addCommand(std::wstring key) {
-  std::wstring value = NSCModuleHelper::getSettingsString(settings::nsca::CMD_SECTION_PATH, key, _T(""));
+  std::wstring value = NSCModuleHelper::getSettingsString(setting_keys::nsca::CMD_SECTION_PATH, key, _T(""));
   if ((key.length() > 4) && (key.substr(0,4) == _T("host")))
     commands_.push_back(Command(_T(""), value));

trunk/modules/NSCAAgent/NSCAThread.h

@@ -24 +24 @@
 #include <Mutex.h>
 #include <arrayBuffer.h>
-#include <Socket.h>
 #include "nsca_enrypt.hpp"
 
@@ -93 +92 @@
 
 
-class Arguments {
-  arrayBuffer::arrayBuffer arglist_;
-  unsigned int arglen_;
-public:
-  Arguments() : arglist_(NULL), arglen_(0) {}
-  ~Arguments() {
-    arrayBuffer::destroyArrayBuffer(arglist_, arglen_);
-    arglist_ = NULL;
-  }
-  Arguments(const Arguments& other) : arglist_(NULL), arglen_(0) {
-    arglen_ = other.getLen();
-    arglist_ = arrayBuffer::copy(other.get(), other.getLen());
-  }
-  Arguments& operator=(Arguments& other) {
-    if (this != &other){
-      arglen_ = other.getLen();
-      arglist_ = other.detach();
-    }
-    return *this;
-  }
-  Arguments& operator=(const Arguments& other) {
-    if (this != &other){
-      arglen_ = other.getLen();
-      arglist_ = arrayBuffer::copy(other.get(), other.getLen());
-    }
-    return *this;
-  }
-  Arguments(const std::wstring &other) : arglist_(NULL), arglen_(0)  {
-    arglist_ = arrayBuffer::split2arrayBuffer(other, ' ', arglen_, true);
-  }
-  arrayBuffer::arrayBuffer detach() {
-    arrayBuffer::arrayBuffer ret = arglist_;
-    arglist_ = NULL;
-    arglen_ = 0;
-    return ret;
-  }
-  const arrayBuffer::arrayBuffer get() const {
-    return arglist_;
-  }
-  unsigned int getLen() const {
-    return arglen_;
-  }
-};
+
 class Command {
   std::wstring cmd_;
   std::wstring alias_;
-  Arguments args_;
+  std::list<std::wstring> args_;
 public:
 
@@ -160 +117 @@
     }
 
-    simpleSocket::DataBuffer getBuffer(nsca_encrypt &crypt_inst, __time32_t time_delta, unsigned int pluginoutput_length) const {
+    std::string getBuffer(nsca_encrypt &crypt_inst, __time32_t time_delta, unsigned int pluginoutput_length) const {
+      std::string ret; ret.resize(buffer_len);
       std::string s = strEx::wstring_to_string(service);
       std::string r = strEx::wstring_to_string(result);
@@ -203 +161 @@
     strEx::token token = strEx::getToken(raw, ' ');
     cmd_ = token.first;
-    args_ = token.second;
+    args_.push_back(token.second);
   }
   static unsigned int conv_code(NSCAPI::nagiosReturn ret) {

trunk/modules/NSCAAgent/stdafx.h

@@ -21 +21 @@
 #pragma once
 
-#define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers
-// Windows Header Files:
-#include <windows.h>
-
-#define COMPILE_NEWAPIS_STUBS
 #define WANT_GETLONGPATHNAME_WRAPPER
 //#include <NewAPIs.h>
@@ -34 +29 @@
 #include <hash_map>
 #include <list>
+
+
+#include <boost/asio.hpp>
+#ifdef USE_SSL
+#include <boost/asio/ssl.hpp>
+#endif
+
 #include <NSCAPI.h>
 #include <NSCHelper.h>
@@ -41 +43 @@
 #include <error.hpp>
 
+
 #ifdef MEMCHECK
 #include <vld.h>

trunk/modules/Scheduler/Scheduler.cpp

@@ -123 +123 @@
 void Scheduler::handle_schedule(scheduler::target item) {
   try {
-    std::wstring msg, perf;
-    NSCAPI::nagiosReturn code = NSCModuleHelper::InjectSimpleCommand(item.command.c_str(), item.arguments, msg, perf);
+    std::string response;
+    NSCAPI::nagiosReturn code = NSCModuleHelper::InjectCommand(item.command.c_str(), item.arguments, response);
     if (NSCHelper::report::matches(item.report, code)) {
-      NSCModuleHelper::NotifyChannel(item.channel, item.alias, code, msg, perf);
+      NSCModuleHelper::NotifyChannel(item.channel, item.alias, code, response);
     }
   } catch (NSCModuleHelper::NSCMHExcpetion &e) {

trunk/service/CMakeLists.txt

@@ -40 +40 @@
     
     commands.hpp
+    channels.hpp
     logger.hpp
     settings_logger_impl.hpp

trunk/service/NSCPlugin.cpp

@@ -48 +48 @@
   ,fShowTray(NULL)
   ,fHideTray(NULL)
+  ,fHasNotificationHandler(NULL)
+  ,fHandleNotification(NULL)
   ,bLoaded_(false)
   ,lastIsMsgPlugin_(false)
@@ -206 +208 @@
   }
 }
+bool NSCPlugin::hasNotificationHandler() {
+  if (!isLoaded())
+    throw NSPluginException(module_, _T("Module not loaded"));
+  if (!fHasNotificationHandler)
+    return false;
+  try {
+    if (fHasNotificationHandler()) {
+      return true;
+    }
+    return false;
+  } catch (...) {
+    throw NSPluginException(module_, _T("Unhandled exception in hasMessageHandler."));
+  }
+}
 /**
  * Allow for the plug in to handle a command from the input core.
@@ -231 +247 @@
 }
 
+bool NSCPlugin::handleNotification(const wchar_t *channel, const wchar_t* command, NSCAPI::nagiosReturn code, char* result, unsigned int result_len) {
+  if (!isLoaded() || fHandleNotification == NULL)
+    throw NSPluginException(module_, _T("Library is not loaded"));
+  try {
+    return fHandleNotification(channel, command, code, result, result_len);
+  } catch (...) {
+    throw NSPluginException(module_, _T("Unhandled exception in handleCommand."));
+  }
+}
+
+
 
 void NSCPlugin::deleteBuffer(char** buffer) {
@@ -386 +413 @@
     fGetConfigurationMeta = (lpGetConfigurationMeta)module_.load_proc("NSGetConfigurationMeta");
     fCommandLineExec = (lpCommandLineExec)module_.load_proc("NSCommandLineExec");
-
+    fHandleNotification = (lpHandleNotification)module_.load_proc("NSHandleNotification");
+    fHasNotificationHandler = (lpHasNotificationHandler)module_.load_proc("NSHasNotificationHandler");
+    
     fShowTray = (lpShowTray)module_.load_proc("ShowIcon");
     fHideTray = (lpHideTray)module_.load_proc("HideIcon");

trunk/service/NSCPlugin.h

@@ -126 +126 @@
   typedef void (*lpShowTray)();
   typedef void (*lpHideTray)();
+  typedef int (*lpHasNotificationHandler)();
+  typedef int (*lpHandleNotification)(const wchar_t *channel, const wchar_t* command, NSCAPI::nagiosReturn code, char* result, unsigned int result_len);
 
 
@@ -143 +145 @@
   lpShowTray fShowTray;
   lpHideTray fHideTray;
+  lpHasNotificationHandler fHasNotificationHandler;
+  lpHandleNotification fHandleNotification;
 
 public:
@@ -157 +161 @@
   bool getVersion(int *major, int *minor, int *revision);
   bool hasCommandHandler(void);
+  bool hasNotificationHandler(void);
   bool hasMessageHandler(void);
   NSCAPI::nagiosReturn handleCommand(const wchar_t *command, const char* dataBuffer, const unsigned int dataBuffer_len, char** returnBuffer, unsigned int *returnBuffer_len);
   NSCAPI::nagiosReturn handleCommand(const wchar_t* command, std::string &request, std::string &reply);
+  bool handleNotification(const wchar_t *channel, const wchar_t* command, NSCAPI::nagiosReturn code, char* result, unsigned int result_len);
   void deleteBuffer(char**buffer);
   void handleMessage(int msgType, const wchar_t* file, const int line, const wchar_t *message);

trunk/service/NSClient++.cpp

@@ -872 +872 @@
       return;
     }
-    commandHandlers_.clear();
     if (unloadLoggers)
       messageHandlers_.clear();
@@ -989 +988 @@
     plugins_.insert(plugins_.end(), plugin);
     commands_.add_plugin(plugin);
-    if (plugin->hasCommandHandler())
-      commandHandlers_.insert(commandHandlers_.end(), plugin);
+    channels_.add_plugin(plugin);
+    if (plugin->hasNotificationHandler()) {
+      channels_.register_listener(plugin->get_id(), _T("NSCA"));
+    }
     if (plugin->hasMessageHandler())
       messageHandlers_.insert(messageHandlers_.end(), plugin);
@@ -1109 +1110 @@
     }
   } else */{
-    /*
     boost::shared_lock<boost::shared_mutex> readLock(m_mutexRW, boost::get_system_time() + boost::posix_time::milliseconds(5000));
     if (!readLock.owns_lock()) {
@@ -1115 +1115 @@
       return NSCAPI::returnUNKNOWN;
     }
-    */
     try {
       nsclient::commands::plugin_type plugin = commands_.get(command);
@@ -1132 +1131 @@
       return NSCAPI::returnIgnored;
     }
+  }
+}
+
+
+NSCAPI::errorReturn NSClientT::send_notification(const wchar_t* channel, const wchar_t* command, NSCAPI::nagiosReturn code,  char* result, unsigned int result_len) {
+  boost::shared_lock<boost::shared_mutex> readLock(m_mutexRW, boost::get_system_time() + boost::posix_time::milliseconds(5000));
+  if (!readLock.owns_lock()) {
+    LOG_ERROR_CORE(_T("FATAL ERROR: Could not get read-mutex."));
+    return NSCAPI::hasFailed;
+  }
+  try {
+    LOG_ERROR_CORE_STD(_T("Notifying: ") + strEx::strip_hex(to_wstring(std::string(result,result_len))));
+    bool found = false;
+    BOOST_FOREACH(nsclient::channels::plugin_type p, channels_.get(channel)) {
+      p->handleNotification(channel, command, code, result, result_len);
+      found = true;
+    }
+    if (!found) {
+      LOG_ERROR_CORE_STD(_T("Noone listens for events from: ") + std::wstring(channel));
+    }
+    return NSCAPI::isSuccess;
+  } catch (nsclient::channels::channel_exception &e) {
+    LOG_ERROR_CORE(_T("No handler for channel: ") + std::wstring(channel) + _T(": ") + to_wstring(e.what()));
+    return NSCAPI::hasFailed;
+  } catch (...) {
+    LOG_ERROR_CORE(_T("Error handling channel: ") + std::wstring(channel));
+    return NSCAPI::hasFailed;
   }
 }

trunk/service/NSClient++.h

@@ -30 +30 @@
 #include "NSCPlugin.h"
 #include "commands.hpp"
+#include "channels.hpp"
 #include "logger.hpp"
 
@@ -101 +102 @@
   typedef std::list<cached_log_entry> log_cache_type;
   pluginList plugins_;
-  pluginList commandHandlers_;
   pluginList messageHandlers_;
   boost::filesystem::wpath  basePath;
@@ -122 +122 @@
   bool enable_shared_session_;
   nsclient::commands commands_;
+  nsclient::channels channels_;
 
 
 public:
   // c-tor, d-tor
-  NSClientT(void) : debug_(log_unknown), plugins_loaded_(false), enable_shared_session_(false), commands_(this) {}
+  NSClientT(void) : debug_(log_unknown), plugins_loaded_(false), enable_shared_session_(false), commands_(this), channels_(this) {}
   virtual ~NSClientT(void) {}
   void enableDebug(bool debug = true) {
@@ -163 +164 @@
   // Member functions
   boost::filesystem::wpath getBasePath(void);
+  NSCAPI::errorReturn send_notification(const wchar_t* channel, const wchar_t* command, NSCAPI::nagiosReturn code, char* result, unsigned int result_len);
   NSCAPI::nagiosReturn injectRAW(const wchar_t* command, std::string &request, std::string &response);
   NSCAPI::nagiosReturn inject(std::wstring command, std::wstring arguments, std::wstring &msg, std::wstring & perf);

trunk/service/core_api.cpp

@@ -433 +433 @@
 }
 
-NSCAPI::errorReturn NSAPINotify(const wchar_t* channel, const wchar_t* command, NSCAPI::nagiosReturn code, const wchar_t* message, const wchar_t* perf) {
-  LOG_ERROR_STD(_T("TODO: implment channels: ") + std::wstring(command));
-  return NSCAPI::hasFailed;
+NSCAPI::errorReturn NSAPINotify(const wchar_t* channel, const wchar_t* command, NSCAPI::nagiosReturn code,  char* result, unsigned int result_len) {
+  return mainClient.send_notification(channel, command, code, result, result_len);
 }
 

trunk/service/core_api.h

@@ -58 +58 @@
 NSCAPI::errorReturn NSAPIReleasePluginList(int,NSCAPI::plugin_info*[]);
 NSCAPI::errorReturn NSAPISettingsSave(void);
-NSCAPI::errorReturn NSAPINotify(const wchar_t*, const wchar_t*, NSCAPI::nagiosReturn, const wchar_t*, const wchar_t*);
+NSCAPI::errorReturn NSAPINotify(const wchar_t*, const wchar_t*, NSCAPI::nagiosReturn, char*, unsigned int);
 void NSAPIDestroyBuffer(char**);