Changeset 9bd40e2 in nscp

Timestamp:

05/06/12 21:25:45 (13 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.1, 0.4.2

Children:

ef5832c

Parents:

53473f7

Message:

• Refactored server internals to be more uniform (This is the first step to adding more protocols like NRDP and unit tests for check_nt)

Files:

• changelog (modified) (1 diff)
• include/check_nt/server/connection.cpp (deleted)
• include/check_nt/server/connection.hpp (deleted)
• include/check_nt/server/handler.hpp (modified) (1 diff)
• include/check_nt/server/parser.hpp (modified) (1 diff)
• include/check_nt/server/protocol.hpp (added)
• include/check_nt/server/server.cpp (deleted)
• include/check_nt/server/server.hpp (deleted)
• include/check_nt/server/ssl_connection.cpp (deleted)
• include/check_nt/server/ssl_connection.hpp (deleted)
• include/check_nt/server/tcp_connection.cpp (deleted)
• include/check_nt/server/tcp_connection.hpp (deleted)
• include/nrpe/server/connection.cpp (deleted)
• include/nrpe/server/connection.hpp (deleted)
• include/nrpe/server/handler.hpp (modified) (1 diff)
• include/nrpe/server/parser.hpp (modified) (3 diffs)
• include/nrpe/server/protocol.hpp (added)
• include/nrpe/server/server.cpp (deleted)
• include/nrpe/server/server.hpp (deleted)
• include/nrpe/server/ssl_connection.cpp (deleted)
• include/nrpe/server/ssl_connection.hpp (deleted)
• include/nrpe/server/tcp_connection.cpp (deleted)
• include/nrpe/server/tcp_connection.hpp (deleted)
• include/nsca/nsca_socket.hpp (modified) (1 diff)
• include/nsca/server/connection.cpp (deleted)
• include/nsca/server/connection.hpp (deleted)
• include/nsca/server/handler.hpp (modified) (1 diff)
• include/nsca/server/parser.hpp (modified) (2 diffs)
• include/nsca/server/protocol.hpp (added)
• include/nsca/server/server.cpp (deleted)
• include/nsca/server/server.hpp (deleted)
• include/socket/connection.hpp (added)
• include/socket/server.hpp (modified) (4 diffs)
• modules/NRPEServer/CMakeLists.txt (modified) (4 diffs)
• modules/NRPEServer/NRPEServer.cpp (modified) (8 diffs)
• modules/NRPEServer/NRPEServer.h (modified) (2 diffs)
• modules/NRPEServer/handler_impl.hpp (modified) (1 diff)
• modules/NSCAServer/CMakeLists.txt (modified) (4 diffs)
• modules/NSCAServer/NSCAServer.cpp (modified) (5 diffs)
• modules/NSCAServer/NSCAServer.h (modified) (3 diffs)
• modules/NSCAServer/handler_impl.cpp (modified) (1 diff)
• modules/NSCAServer/handler_impl.hpp (modified) (3 diffs)
• modules/NSClientServer/CMakeLists.txt (modified) (3 diffs)
• modules/NSClientServer/NSClientServer.cpp (modified) (7 diffs)
• modules/NSClientServer/NSClientServer.h (modified) (2 diffs)
• modules/NSClientServer/handler_impl.hpp (modified) (1 diff)

changelog

@@ -5 +5 @@
  * Fix RtlStringFromGUID problem on NT4
 
+2012-05-06 MickeM
+ * Refactored server internals to be more uniform (This is the first step to adding more protocols like NRDP and unittests for check_nt)
+ 
 2012-05-03 MickeM
  * Fixed issue with parsing size-type (usch as MinCritFree=10G)

include/check_nt/server/handler.hpp

@@ -6 +6 @@
 namespace check_nt {
   namespace server {
-    class handler {
+    class handler : public boost::noncopyable {
     public:
-      handler() {}
-      handler(const handler &other) {}
-      handler& operator= (const handler &other) {
-        return *this;
-      }
       virtual check_nt::packet handle(check_nt::packet packet) = 0;
-      virtual void log_debug(std::string file, int line, std::wstring msg) = 0;
-      virtual void log_error(std::string file, int line, std::wstring msg) = 0;
+      virtual void log_debug(std::string module, std::string file, int line, std::string msg) const = 0;
+      virtual void log_error(std::string module, std::string file, int line, std::string msg) const = 0;
       virtual check_nt::packet create_error(std::wstring msg) = 0;
 

include/check_nt/server/parser.hpp

@@ -9 +9 @@
 namespace check_nt {
   namespace server {
-    class parser : public boost::noncopyable{
+    class parser : public boost::noncopyable {
       std::vector<char> buffer_;
-      boost::shared_ptr<check_nt::server::handler> handler_;
     public:
-      parser(boost::shared_ptr<check_nt::server::handler> handler) : handler_(handler) {}
+      parser() {}
 
       template <typename InputIterator>

include/nrpe/server/handler.hpp

@@ -6 +6 @@
 namespace nrpe {
   namespace server {
-    class handler {
+    class handler : boost::noncopyable {
     public:
-      handler() {}
-      handler(const handler &other) {}
-      handler& operator= (const handler &other) {
-        return *this;
-      }
       virtual nrpe::packet handle(nrpe::packet packet) = 0;
-      virtual void log_debug(std::string file, int line, std::wstring msg) = 0;
-      virtual void log_error(std::string file, int line, std::wstring msg) = 0;
+      virtual void log_debug(std::string module, std::string file, int line, std::string msg) const = 0;
+      virtual void log_error(std::string module, std::string file, int line, std::string msg) const = 0;
       virtual nrpe::packet create_error(std::wstring msg) = 0;
       virtual unsigned int get_payload_length() = 0;

include/nrpe/server/parser.hpp

@@ -13 +13 @@
       unsigned int packet_length_;
       unsigned int payload_length_;
-      boost::shared_ptr<nrpe::server::handler> handler_;
     public:
-      parser(boost::shared_ptr<nrpe::server::handler> handler) : handler_(handler) {
-        set_payload_length(handler->get_payload_length());
+      parser(unsigned int payload_length) : payload_length_(payload_length), packet_length_(nrpe::length::get_packet_length(payload_length)) {
       }
 
@@ -32 +30 @@
         return packet;
       }
+      /*
       void set_payload_length(unsigned int length) {
         payload_length_ = length;
@@ -39 +38 @@
         return payload_length_;
       }
+      */
     };
 

include/nsca/nsca_socket.hpp

@@ -92 +92 @@
       std::string iv = iv_packet.get_iv();
       time = iv_packet.get_time();
-      NSC_DEBUG_MSG(_T("Encrypting using when sending: ") + utf8::cvt<std::wstring>(nsca::nsca_encrypt::helpers::encryption_to_string(encryption_method)) + _T(" and ") + utf8::cvt<std::wstring>(password));
+      NSC_DEBUG_MSG(_T("Encrypting using: ") + utf8::cvt<std::wstring>(nsca::nsca_encrypt::helpers::encryption_to_string(encryption_method)) + _T(", password '") + utf8::cvt<std::wstring>(password) + _T("'"));
       crypt_inst.encrypt_init(password, encryption_method, iv);
       return true;

include/nsca/server/handler.hpp

@@ -5 +5 @@
 namespace nsca {
   namespace server {
-    class handler {
+    class handler : boost::noncopyable {
     public:
-      handler() {}
-      handler(const handler &other) {}
-      handler& operator= (const handler &other) {
-        return *this;
-      }
       virtual void handle(nsca::packet packet) = 0;
-      virtual void log_debug(std::string file, int line, std::wstring msg) = 0;
-      virtual void log_error(std::string file, int line, std::wstring msg) = 0;
+      virtual void log_debug(std::string module, std::string file, int line, std::string msg) const = 0;
+      virtual void log_error(std::string module, std::string file, int line, std::string msg) const = 0;
       virtual unsigned int get_payload_length() = 0;
       virtual void set_payload_length(unsigned int payload) = 0;

include/nsca/server/parser.hpp

@@ -17 +17 @@
       boost::shared_ptr<nsca::server::handler> handler_;
     public:
-      parser(boost::shared_ptr<nsca::server::handler> handler) : handler_(handler) {
-        set_payload_length(handler->get_payload_length());
+      parser(unsigned int payload_length) : payload_length_(payload_length), packet_length_(nsca::length::get_packet_length(payload_length)) {
       }
 
@@ -41 +40 @@
         return buffer_;
       }
-      void set_payload_length(unsigned int length) {
-        payload_length_ = length;
-        packet_length_ = nsca::length::get_packet_length(length);
-      }
-      int get_payload_lenght() const { return payload_length_; }
       std::string::size_type size() {
         return buffer_.size();

include/socket/server.hpp

@@ -10 +10 @@
 
 #include <socket/socket_helpers.hpp>
+#include <socket/connection.hpp>
 #include <strEx.h>
 
@@ -16 +17 @@
   namespace server {
     namespace str = nscp::helpers;
-    /*
-    struct dummy_handler {
-    handler() {}
-    handler(const handler &other) {}
-    handler& operator= (const handler &other) {
-    return *this;
-    }
-    virtual std::string handle(std::string packet) = 0;
-    virtual void log_debug(std::string file, int line, std::wstring msg) = 0;
-    virtual void log_error(std::string file, int line, std::wstring msg) = 0;
-    virtual std::string create_error(std::wstring msg) = 0;
-    };
-    struct dummy_connection_info : public socket_helpers::connection_info {
-    dummy_connection_info(boost::shared_ptr<dummy_handler> request_handler) : request_handler(request_handler) {}
-    dummy_connection_info(const connection_info &other) 
-    : socket_helpers::connection_info(other)
-    , request_handler(other.request_handler)
-    {}
-    connection_info& operator=(const connection_info &other) {
-    socket_helpers::connection_info::operator=(other);
-    request_handler = other.request_handler;
-    return *this;
-    }
-    boost::shared_ptr<dummy_handler> request_handler;
-    };
-
-
-    struct dummy_server_definition {
-    typedef boost::shared_ptr<dummy_handler> handler_type;
-    typedef dummy_connection_info connection_info_type;
-
-    static connection_info_type create(boost::asio::io_service& io_service, boost::asio::ssl::context &context, handler_type handler, connection_info_type info);
-    };
-
-    */
+    
     class server_exception : public std::exception {
       std::string error;
@@ -74 +41 @@
     namespace ip = boost::asio::ip;
 
-    template<class ServerDefinition>
-    class server : boost::noncopyable {
+    template<class protocol_type, std::size_t N>
+    class server : private boost::noncopyable {
+
+      typedef socket_helpers::server::connection<protocol_type, N> connection_type;
+#ifdef USE_SSL
+      typedef socket_helpers::server::ssl_connection<protocol_type, N> ssl_connection_type;
+#endif
     public:
-      server(typename ServerDefinition::connection_info_type info) 
-        : acceptor_(io_service_)
+      server(boost::shared_ptr<protocol_type> protocol)
+        : protocol_(protocol)
+        , acceptor_(io_service_)
         , accept_strand_(io_service_)
-        , request_handler_(info.request_handler)
 #ifdef USE_SSL
         , context_(io_service_, boost::asio::ssl::context::sslv23)
 #endif
-        , info_(info) {}
+      {
+        if (!protocol_)
+          throw server_exception("Invalid protocol instance");
+      }
+      ~server() {
 
-      void setup() {
-        if (!request_handler_)
-          throw server_exception("Invalid handler when creating server");
+      }
 
-        // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
+      void start() {
         ip::tcp::resolver resolver(io_service_);
         ip::tcp::resolver::iterator endpoint_iterator;
-        if (info_.address.empty()) {
-          endpoint_iterator = resolver.resolve(ip::tcp::resolver::query(info_.get_port()));
+        if (protocol_->get_info().address.empty()) {
+          endpoint_iterator = resolver.resolve(ip::tcp::resolver::query(protocol_->get_info().get_port()));
         } else {
-          endpoint_iterator = resolver.resolve(ip::tcp::resolver::query(info_.get_address(), info_.get_port()));
+          endpoint_iterator = resolver.resolve(ip::tcp::resolver::query(protocol_->get_info().get_address(), protocol_->get_info().get_port()));
         }
         ip::tcp::resolver::iterator end;
-        if (endpoint_iterator == end)
-          throw server_exception("Failed to lookup: " + info_.get_endpoint_string());
+        if (endpoint_iterator == end) {
+          protocol_->log_error(__FILE__, __LINE__, "Failed to lookup: " + protocol_->get_info().get_endpoint_string());
+          return;
+        }
+        if (protocol_->get_info().use_ssl) {
 #ifdef USE_SSL
-        if (info_.use_ssl) {
           SSL_CTX_set_cipher_list(context_.impl(), "ADH");
-          request_handler_->log_debug(__FILE__, __LINE__, _T("Using cert: ") + str::to_wstring(info_.certificate));
-          context_.use_tmp_dh_file(to_string(info_.certificate));
+          protocol_->log_debug(__FILE__, __LINE__, "Using certificate: " + utf8::cvt<std::string>(protocol_->get_info().certificate));
+          context_.use_tmp_dh_file(to_string(protocol_->get_info().certificate));
           context_.set_verify_mode(boost::asio::ssl::context::verify_none);
+#else
+          protocol_->log_error(__FILE__, __LINE__, "Not compiled with SSL");
+#endif
         }
-#endif
         new_connection_.reset(create_connection());
 
@@ -114 +92 @@
         acceptor_.open(endpoint.protocol());
         acceptor_.set_option(ip::tcp::acceptor::reuse_address(true));
-        request_handler_->log_debug(__FILE__, __LINE__, _T("Attempting to bind to: ") + info_.get_endpoint_wstring());
+        protocol_->log_debug(__FILE__, __LINE__, "Attempting to bind to: " + protocol_->get_info().get_endpoint_string());
         acceptor_.bind(endpoint);
-        if (info_.back_log == connection_info::backlog_default)
+        if (protocol_->get_info().back_log == connection_info::backlog_default)
           acceptor_.listen();
         else
-          acceptor_.listen(info_.back_log);
+          acceptor_.listen(protocol_->get_info().back_log);
 
-        acceptor_.async_accept(new_connection_->socket(),
-          accept_strand_.wrap(
-          boost::bind(&server<ServerDefinition>::handle_accept, this, boost::asio::placeholders::error)
-          )
-          );
-        request_handler_->log_debug(__FILE__, __LINE__, _T("Bound to: ") + info_.get_endpoint_wstring());
-      }
+        acceptor_.async_accept(new_connection_->socket(),accept_strand_.wrap(
+          boost::bind(&server::handle_accept, this, boost::asio::placeholders::error)
+          ));
+        protocol_->log_debug(__FILE__, __LINE__, "Bound to: " + protocol_->get_info().get_endpoint_string());
 
-      typename ServerDefinition::connection_type* create_connection() {
-#ifdef USE_SSL
-        return ServerDefinition::create(io_service_, context_, request_handler_, info_);
-#else
-        return ServerDefinition::create(io_service_, request_handler_, info_);
-#endif
-      }
-
-
-      virtual ~server() {}
-
-      /// Run the server's io_service loop.
-      void start() {
-        // Create a pool of threads to run all of the io_services.
-        for (std::size_t i = 0; i < info_.thread_pool_size; ++i) {
-          boost::shared_ptr<boost::thread> thread(
-            new boost::thread( boost::bind(&boost::asio::io_service::run, &io_service_) ));
-          threads_.push_back(thread);
+        for (std::size_t i = 0; i < protocol_->get_info().thread_pool_size; ++i) {
+          thread_group_.create_thread(boost::bind(&boost::asio::io_service::run, &io_service_));
         }
-        request_handler_->log_debug(__FILE__, __LINE__, _T("Thredpool containes: ") + str::to_wstring(info_.thread_pool_size));
       }
 
       void stop() {
         io_service_.stop();
-        for (std::size_t i = 0; i < threads_.size(); ++i)
-          threads_[i]->join();
+        thread_group_.join_all();
       }
 
+    private:
       void handle_accept(const boost::system::error_code& e) {
         if (!e) {
           std::list<std::string> errors;
-          try {
-            if (info_.allowed_hosts.is_allowed(new_connection_->socket().remote_endpoint().address(), errors)) {
-              std::string s = new_connection_->socket().remote_endpoint().address().to_string();
-              request_handler_->log_debug(__FILE__, __LINE__, _T("Accepting connection from: ") + str::to_wstring(s));
-              new_connection_->start();
-            } else {
-              BOOST_FOREACH(const std::string &e, errors) {
-                request_handler_->log_error(__FILE__, __LINE__, utf8::cvt<std::wstring>(e));
-              }
-              std::string s = new_connection_->socket().remote_endpoint().address().to_string();
-              request_handler_->log_error(__FILE__, __LINE__, _T("Rejcted connection from: ") + str::to_wstring(s));
-              new_connection_->stop();
-            }
-          } catch(const std::exception &e) {
+          if (protocol_->on_accept(new_connection_->socket())) {
+            new_connection_->start();
+          } else {
             new_connection_->stop();
-            request_handler_->log_error(__FILE__, __LINE__, utf8::cvt<std::wstring>(e.what()));
           }
+
           new_connection_.reset(create_connection());
+
           acceptor_.async_accept(new_connection_->socket(),
-            accept_strand_.wrap(boost::bind(&server<ServerDefinition>::handle_accept, this, boost::asio::placeholders::error))
-          );
+            accept_strand_.wrap(
+            boost::bind(&server::handle_accept, this, boost::asio::placeholders::error)
+            )
+            );
         } else {
-          request_handler_->log_error(__FILE__, __LINE__, _T("Socket ERROR: ") + str::to_wstring(e.message()));
+          protocol_->log_error(__FILE__, __LINE__, "Socket ERROR: " + e.message());
         }
       }
 
-
-    private:
+      typename connection_type* create_connection() {
+#ifdef USE_SSL
+        if (protocol_->get_info().use_ssl) {
+          return new ssl_connection_type(io_service_, context_, protocol_);
+        }
+#endif
+        return new connection_type(io_service_, protocol_);
+      }
 
       boost::asio::io_service io_service_;
-
       boost::asio::ip::tcp::acceptor acceptor_;
-
-      boost::shared_ptr<typename ServerDefinition::connection_type> new_connection_;
-
-      std::vector<boost::shared_ptr<boost::thread> > threads_;
-
-      typename ServerDefinition::handler_type request_handler_;
-
+      boost::shared_ptr<connection_type> new_connection_;
+      boost::thread_group thread_group_;
 #ifdef USE_SSL
       boost::asio::ssl::context context_;
 #endif
+      boost::asio::strand accept_strand_;
+      boost::shared_ptr<protocol_type> protocol_;
 
-      boost::asio::strand accept_strand_;
-
-      typename ServerDefinition::connection_info_type info_;
     };
 

modules/NRPEServer/CMakeLists.txt

@@ -12 +12 @@
   "${TARGET}.cpp"
   "handler_impl.cpp"
-  ${NSCP_INCLUDEDIR}/nrpe/server/server.cpp
-  ${NSCP_INCLUDEDIR}/nrpe/server/connection.cpp
-  ${NSCP_INCLUDEDIR}/nrpe/server/tcp_connection.cpp
-  ${NSCP_INCLUDEDIR}/nrpe/server/ssl_connection.cpp
   ${NSCP_INCLUDEDIR}/nrpe/packet.cpp
   ${NSCP_INCLUDEDIR}/socket/socket_helpers.cpp
@@ -33 +29 @@
     "${TARGET}.def"
     "handler_impl.hpp"
-    ${NSCP_INCLUDEDIR}/nrpe/server/server.hpp
-    ${NSCP_INCLUDEDIR}/nrpe/server/connection.hpp
-    ${NSCP_INCLUDEDIR}/nrpe/server/tcp_connection.hpp
-    ${NSCP_INCLUDEDIR}/nrpe/server/ssl_connection.hpp
+    ${NSCP_INCLUDEDIR}/nrpe/server/protocol.hpp
     ${NSCP_INCLUDEDIR}/nrpe/server/handler.hpp
     ${NSCP_INCLUDEDIR}/nrpe/server/parser.hpp
@@ -42 +35 @@
     ${NSCP_INCLUDEDIR}/swap_bytes.hpp
     ${NSCP_INCLUDEDIR}/socket/socket_helpers.hpp
+    ${NSCP_INCLUDEDIR}/socket/server.hpp
+    ${NSCP_INCLUDEDIR}/socket/connection.hpp
 
     ${NSCP_DEF_PLUGIN_HPP}
@@ -58 +53 @@
 INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake)
 SOURCE_GROUP("Server" REGULAR_EXPRESSION .*include/nrpe/.*)
+SOURCE_GROUP("Socket" REGULAR_EXPRESSION .*include/socket/.*)

modules/NRPEServer/NRPEServer.cpp

@@ -31 +31 @@
 
 
-NRPEListener::NRPEListener() : info_(boost::shared_ptr<nrpe::server::handler>(new handler_impl(1024))) {
+NRPEServer::NRPEServer() : handler_(new handler_impl(1024)) {
 }
-NRPEListener::~NRPEListener() {}
+NRPEServer::~NRPEServer() {}
 
-bool NRPEListener::loadModule() {
+bool NRPEServer::loadModule() {
   return false;
 }
 
-bool NRPEListener::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
+bool NRPEServer::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
   try {
 
@@ -46 +46 @@
 
     settings.alias().add_path_to_settings()
-      (_T("NRPE SERVER SECTION"), _T("Section for NRPE (NRPEListener.dll) (check_nrpe) protocol options."))
+      (_T("NRPE SERVER SECTION"), _T("Section for NRPE (NRPEServer.dll) (check_nrpe) protocol options."))
       ;
 
@@ -53 +53 @@
       _T("PORT NUMBER"), _T("Port to use for NRPE."))
 
-      (_T("payload length"), sh::int_fun_key<unsigned int>(boost::bind(&nrpe::server::handler::set_payload_length, info_.request_handler, _1), 1024),
+      (_T("payload length"), sh::int_fun_key<unsigned int>(boost::bind(&nrpe::server::handler::set_payload_length, handler_, _1), 1024),
       _T("PAYLOAD LENGTH"), _T("Length of payload to/from the NRPE agent. This is a hard specific value so you have to \"configure\" (read recompile) your NRPE agent to use the same value for it to work."), true)
 
-      (_T("allow arguments"), sh::bool_fun_key<bool>(boost::bind(&nrpe::server::handler::set_allow_arguments, info_.request_handler, _1), false),
+      (_T("allow arguments"), sh::bool_fun_key<bool>(boost::bind(&nrpe::server::handler::set_allow_arguments, handler_, _1), false),
       _T("COMMAND ARGUMENT PROCESSING"), _T("This option determines whether or not the we will allow clients to specify arguments to commands that are executed."))
 
-      (_T("allow nasty characters"), sh::bool_fun_key<bool>(boost::bind(&nrpe::server::handler::set_allow_nasty_arguments, info_.request_handler, _1), false),
+      (_T("allow nasty characters"), sh::bool_fun_key<bool>(boost::bind(&nrpe::server::handler::set_allow_nasty_arguments, handler_, _1), false),
       _T("COMMAND ALLOW NASTY META CHARS"), _T("This option determines whether or not the we will allow clients to specify nasty (as in |`&><'\"\\[]{}) characters in arguments."))
 
-      (_T("performance data"), sh::bool_fun_key<bool>(boost::bind(&nrpe::server::handler::set_perf_data, info_.request_handler, _1), true),
+      (_T("performance data"), sh::bool_fun_key<bool>(boost::bind(&nrpe::server::handler::set_perf_data, handler_, _1), true),
       _T("PERFORMANCE DATA"), _T("Send performance data back to nagios (set this to 0 to remove all performance data)."), true)
 
@@ -104 +104 @@
     }
 #endif
-    if (info_.request_handler->get_payload_length() != 1024)
-      NSC_DEBUG_MSG_STD(_T("Non-standard buffer length (hope you have recompiled check_nrpe changing #define MAX_PACKETBUFFER_LENGTH = ") + strEx::itos(info_.request_handler->get_payload_length()));
+    if (handler_->get_payload_length() != 1024)
+      NSC_DEBUG_MSG_STD(_T("Non-standard buffer length (hope you have recompiled check_nrpe changing #define MAX_PACKETBUFFER_LENGTH = ") + strEx::itos(handler_->get_payload_length()));
     if (!boost::filesystem::is_regular(info_.certificate))
       NSC_LOG_ERROR_STD(_T("Certificate not found: ") + info_.certificate);
@@ -120 +120 @@
 
     if (mode == NSCAPI::normalStart) {
+#ifndef USE_SSL
       if (info_.use_ssl) {
-#ifdef USE_SSL
-        server_.reset(new nrpe::server::server(info_));
-#else
         NSC_LOG_ERROR_STD(_T("SSL is not supported (not compiled with openssl)"));
         return false;
+      }
 #endif
-      } else {
-        server_.reset(new nrpe::server::server(info_));
-      }
+      server_.reset(new nrpe::server::server(boost::shared_ptr<nrpe::read_protocol>(new nrpe::read_protocol(info_, handler_))));
       if (!server_) {
         NSC_LOG_ERROR_STD(_T("Failed to create server instance!"));
@@ -136 +133 @@
       server_->start();
     }
-  } catch (nrpe::server::nrpe_exception &e) {
-    NSC_LOG_ERROR_STD(_T("Exception caught: ") + e.what());
-    return false;
   } catch (std::exception &e) {
     NSC_LOG_ERROR_STD(_T("Exception caught: ") + to_wstring(e.what()));
@@ -151 +145 @@
 }
 
-bool NRPEListener::unloadModule() {
+bool NRPEServer::unloadModule() {
   try {
     if (server_) {
@@ -165 +159 @@
 
 
-bool NRPEListener::hasCommandHandler() {
+bool NRPEServer::hasCommandHandler() {
   return false;
 }
-bool NRPEListener::hasMessageHandler() {
+bool NRPEServer::hasMessageHandler() {
   return false;
 }
 
 NSC_WRAP_DLL();
-NSC_WRAPPERS_MAIN_DEF(NRPEListener);
+NSC_WRAPPERS_MAIN_DEF(NRPEServer);
 NSC_WRAPPERS_IGNORE_MSG_DEF();
 NSC_WRAPPERS_IGNORE_CMD_DEF();

modules/NRPEServer/NRPEServer.h

@@ -21 +21 @@
 
 #include <socket_helpers.hpp>
-#include <nrpe/server/server.hpp>
+#include <nrpe/server/protocol.hpp>
+#include "handler_impl.hpp"
 
 NSC_WRAPPERS_MAIN();
 
-class NRPEListener : public nscapi::impl::simple_plugin {
-private:
-  typedef enum {
-    inject, script, script_dir,
-  } command_type;
-  struct command_data {
-    command_data() : type(inject) {}
-    command_data(command_type type_, std::wstring arguments_) : type(type_), arguments(arguments_) {}
-    command_type type;
-    std::wstring arguments;
-  };
-
-  nrpe::server::server::connection_info info_;
-
+class NRPEServer : public nscapi::impl::simple_plugin {
 public:
-  NRPEListener();
-  virtual ~NRPEListener();
+  NRPEServer();
+  virtual ~NRPEServer();
   // Module calls
   bool loadModule();
@@ -67 +55 @@
   NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, wchar_t **char_args, std::wstring &message, std::wstring &perf);
   std::wstring getConfigurationMeta();
+  
+private:
+  socket_helpers::connection_info info_;
   boost::shared_ptr<nrpe::server::server> server_;
+  boost::shared_ptr<handler_impl> handler_;
 
-private:
+
   class NRPEException {
     std::wstring error_;

modules/NRPEServer/handler_impl.hpp

@@ -35 +35 @@
     noPerfData_ = !v;
     if (noPerfData_)
-      log_debug(__FILE__, __LINE__, _T("Performance data disabled!"));
+      log_debug("nrpe", __FILE__, __LINE__, "Performance data disabled!");
   }
 
-  void log_debug(std::string file, int line, std::wstring msg) {
+  void log_debug(std::string module, std::string file, int line, std::string msg) const {
     if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
       GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
     }
   }
-  void log_error(std::string file, int line, std::wstring msg) {
+  void log_error(std::string module, std::string file, int line, std::string msg) const {
     if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
       GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);

modules/NSCAServer/CMakeLists.txt

@@ -9 +9 @@
   "${TARGET}.cpp"
   "handler_impl.cpp"
-  ${NSCP_INCLUDEDIR}/nsca/server/server.cpp
-  ${NSCP_INCLUDEDIR}/nsca/server/connection.cpp
+  ${NSCP_INCLUDEDIR}/nsca/nsca_packet.cpp
   ${NSCP_INCLUDEDIR}/socket/socket_helpers.cpp
-  ${NSCP_INCLUDEDIR}/nsca/nsca_packet.cpp
 
   ${NSCP_DEF_PLUGIN_CPP}
@@ -25 +23 @@
 ENDIF(HAVE_CRYPTOPP)
 
+#IF(OPENSSL_FOUND)
+# ADD_DEFINITIONS(-DUSE_SSL)
+#ENDIF(OPENSSL_FOUND)
+
 ADD_DEFINITIONS(${NSCP_GLOBAL_DEFINES})
 
@@ -33 +35 @@
     "${TARGET}.def"
     "handler_impl.hpp"
-    ${NSCP_INCLUDEDIR}/nsca/server/server.hpp
-    ${NSCP_INCLUDEDIR}/nsca/server/connection.hpp
+    ${NSCP_INCLUDEDIR}/nsca/server/protocol.hpp
     ${NSCP_INCLUDEDIR}/nsca/server/handler.hpp
     ${NSCP_INCLUDEDIR}/nsca/server/parser.hpp
     ${NSCP_INCLUDEDIR}/nsca/nsca_packet.hpp
     ${NSCP_INCLUDEDIR}/swap_bytes.hpp
+    ${NSCP_INCLUDEDIR}/socket/socket_helpers.hpp
     ${NSCP_INCLUDEDIR}/socket/server.hpp
-    ${NSCP_INCLUDEDIR}/socket/socket_helpers.hpp
+    ${NSCP_INCLUDEDIR}/socket/connection.hpp
 
     ${NSCP_DEF_PLUGIN_HPP}
@@ -54 +56 @@
   ${Boost_THREAD_LIBRARY}
   ${NSCP_DEF_PLUGIN_LIB}
+# ${OPENSSL_LIBRARIES}
   ${CRYPTOPP_LIB}
 )
 INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake)
 SOURCE_GROUP("Server" REGULAR_EXPRESSION .*include/nsca/.*)
+SOURCE_GROUP("Socket" REGULAR_EXPRESSION .*include/socket/.*)

modules/NSCAServer/NSCAServer.cpp

@@ -29 +29 @@
 namespace str = nscp::helpers;
 
-NSCAServer::NSCAServer() : info_(boost::shared_ptr<nsca::server::handler>(new handler_impl(1024))) {}
+NSCAServer::NSCAServer() : handler_(new nsca_handler_impl(1024)) {}
 
 bool NSCAServer::loadModule() {
@@ -50 +50 @@
       _T("PORT NUMBER"), _T("Port to use for NSCA."))
 
-      (_T("payload length"), sh::int_fun_key<unsigned int>(boost::bind(&nsca::server::handler::set_payload_length, info_.request_handler, _1), 512),
+      (_T("payload length"), sh::int_fun_key<unsigned int>(boost::bind(&nsca::server::handler::set_payload_length, handler_, _1), 512),
       _T("PAYLOAD LENGTH"), _T("Length of payload to/from the NSCA agent. This is a hard specific value so you have to \"configure\" (read recompile) your NSCA agent to use the same value for it to work."))
 
-      (_T("performance data"), sh::bool_fun_key<bool>(boost::bind(&nsca::server::handler::set_perf_data, info_.request_handler, _1), true),
+      (_T("performance data"), sh::bool_fun_key<bool>(boost::bind(&nsca::server::handler::set_perf_data, handler_, _1), true),
       _T("PERFORMANCE DATA"), _T("Send performance data back to nagios (set this to 0 to remove all performance data)."))
 
-      (_T("encryption"), sh::string_fun_key<std::string>(boost::bind(&nsca::server::handler::set_encryption, info_.request_handler, _1), "aes"),
+      (_T("encryption"), sh::string_fun_key<std::string>(boost::bind(&nsca::server::handler::set_encryption, handler_, _1), "aes"),
       _T("ENCRYPTION"), _T("Encryption to use"))
 
-      (_T("password"), sh::string_fun_key<std::string>(boost::bind(&nsca::server::handler::set_password, info_.request_handler, _1), ""),
+      (_T("password"), sh::string_fun_key<std::string>(boost::bind(&nsca::server::handler::set_password, handler_, _1), ""),
       _T("PASSWORD"), _T("Password to use"))
 
@@ -85 +85 @@
       _T("TIMEOUT"), _T("Timeout when reading packets on incoming sockets. If the data has not arrived within this time we will bail out."))
 
-      (_T("inbox"), sh::string_fun_key<std::wstring>(boost::bind(&nsca::server::handler::set_channel, info_.request_handler, _1), _T("inbox")),
+      (_T("inbox"), sh::string_fun_key<std::wstring>(boost::bind(&nsca::server::handler::set_channel, handler_, _1), _T("inbox")),
       _T("INBOX"), _T("The default channel to post incoming messages on"))
 
@@ -93 +93 @@
     settings.notify();
 
-    if (info_.request_handler->get_payload_length() != 512)
-      NSC_DEBUG_MSG_STD(_T("Non-standard buffer length (hope you have recompiled check_nsca changing #define MAX_PACKETBUFFER_LENGTH = ") + strEx::itos(info_.request_handler->get_payload_length()));
+    if (handler_->get_payload_length() != 512)
+      NSC_DEBUG_MSG_STD(_T("Non-standard buffer length (hope you have recompiled check_nsca changing #define MAX_PACKETBUFFER_LENGTH = ") + strEx::itos(handler_->get_payload_length()));
 
     std::list<std::string> errors;
@@ -104 +104 @@
 
     if (mode == NSCAPI::normalStart) {
-      server_.reset(new nsca::server::nsca_server(info_));
+#ifndef USE_SSL
+      if (info_.use_ssl) {
+        NSC_LOG_ERROR_STD(_T("SSL is not supported (not compiled with openssl)"));
+        return false;
+      }
+#endif
+      server_.reset(new nsca::server::server(boost::shared_ptr<nsca::read_protocol>(new nsca::read_protocol(info_, handler_))));
       if (!server_) {
         NSC_LOG_ERROR_STD(_T("Failed to create server instance!"));
         return false;
       }
-      server_->setup();
+      //server_->setup();
       server_->start();
     }

modules/NSCAServer/NSCAServer.h

@@ -21 +21 @@
 
 #include <socket_helpers.hpp>
-#include <nsca/server/server.hpp>
+#include <nsca/server/protocol.hpp>
 
 NSC_WRAPPERS_MAIN();
@@ -27 +27 @@
 class NSCAServer : public nscapi::impl::simple_plugin {
 private:
-  nsca::server::nsca_connection_info info_;
+  socket_helpers::connection_info info_;
 
 public:
@@ -55 +55 @@
   static std::wstring getCryptos();
 
-  boost::shared_ptr<nsca::server::nsca_server> server_;
+  boost::shared_ptr<nsca::server::server> server_;
+  boost::shared_ptr<nsca::server::handler> handler_;
 };
 

modules/NSCAServer/handler_impl.cpp

@@ -6 +6 @@
 #include <config.h>
 
-void handler_impl::handle(nsca::packet p) {
+void nsca_handler_impl::handle(nsca::packet p) {
   std::wstring response;
   std::string::size_type pos = p.result.find('|');

modules/NSCAServer/handler_impl.hpp

@@ -9 +9 @@
 #include <unicode_char.hpp>
 
-class handler_impl : public nsca::server::handler, private boost::noncopyable {
+class nsca_handler_impl : public nsca::server::handler, private boost::noncopyable {
   unsigned int payload_length_;
   bool allowArgs_;
@@ -18 +18 @@
   std::string password_;
 public:
-  handler_impl(unsigned int payload_length) : payload_length_(payload_length), noPerfData_(false), allowNasty_(false), allowArgs_(false) {}
+  nsca_handler_impl(unsigned int payload_length) : payload_length_(payload_length), noPerfData_(false), allowNasty_(false), allowArgs_(false) {}
 
   unsigned int get_payload_length() {
@@ -50 +50 @@
     noPerfData_ = !v;
     if (noPerfData_)
-      log_debug(__FILE__, __LINE__, _T("Performance data disabled!"));
+      log_debug("nsca", __FILE__, __LINE__, "Performance data disabled!");
   }
 
-  void log_debug(std::string file, int line, std::wstring msg) {
+  void log_debug(std::string module, std::string file, int line, std::string msg) const {
     if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
       GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
     }
   }
-  void log_error(std::string file, int line, std::wstring msg) {
+  void log_error(std::string module, std::string file, int line, std::string msg) const {
     if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
       GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);

modules/NSClientServer/CMakeLists.txt

@@ -11 +11 @@
   stdafx.cpp
   "${TARGET}.cpp"
-  "handler_impl.cpp"
-  ${NSCP_INCLUDEDIR}/check_nt/server/server.cpp
-  ${NSCP_INCLUDEDIR}/check_nt/server/connection.cpp
-  ${NSCP_INCLUDEDIR}/check_nt/server/tcp_connection.cpp
-  ${NSCP_INCLUDEDIR}/check_nt/server/ssl_connection.cpp
   ${NSCP_INCLUDEDIR}/check_nt/packet.cpp
   ${NSCP_INCLUDEDIR}/socket/socket_helpers.cpp
@@ -33 +28 @@
     "${TARGET}.def"
     "handler_impl.hpp"
-    ${NSCP_INCLUDEDIR}/check_nt/server/server.hpp
-    ${NSCP_INCLUDEDIR}/check_nt/server/connection.hpp
-    ${NSCP_INCLUDEDIR}/check_nt/server/tcp_connection.hpp
-    ${NSCP_INCLUDEDIR}/check_nt/server/ssl_connection.hpp
-    ${NSCP_INCLUDEDIR}/check_nt/server/handler.hpp
+    ${NSCP_INCLUDEDIR}/check_nt/server/protocol.hpp
     ${NSCP_INCLUDEDIR}/check_nt/server/parser.hpp
     ${NSCP_INCLUDEDIR}/check_nt/packet.hpp
     ${NSCP_INCLUDEDIR}/swap_bytes.hpp
+
     ${NSCP_INCLUDEDIR}/socket/socket_helpers.hpp
+    ${NSCP_INCLUDEDIR}/socket/connection.hpp
+    ${NSCP_INCLUDEDIR}/socket/server.hpp
 
     ${NSCP_DEF_PLUGIN_HPP}
@@ -57 +51 @@
 )
 INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake)
+SOURCE_GROUP("Server" REGULAR_EXPRESSION .*include/check_nt/.*)
+SOURCE_GROUP("Socket" REGULAR_EXPRESSION .*include/socket/.*)

modules/NSClientServer/NSClientServer.cpp

@@ -26 +26 @@
 #include "handler_impl.hpp"
 #include <settings/client/settings_client.hpp>
+#include <nscapi/nscapi_core_helper.hpp>
 
 namespace sh = nscapi::settings_helper;
 
-NSClientListener::NSClientListener() : info_(boost::shared_ptr<check_nt::server::handler>(new handler_impl())) {
-}
-NSClientListener::~NSClientListener() {
-}
-
-bool NSClientListener::loadModule() {
+NSClientServer::NSClientServer() 
+  : noPerfData_(false)
+  , allowNasty_(false)
+  , allowArgs_(false)
+{
+}
+NSClientServer::~NSClientServer() {
+}
+
+bool NSClientServer::loadModule() {
   return false;
 }
 
-bool NSClientListener::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
+bool NSClientServer::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
 
   try {
@@ -53 +58 @@
       _T("PORT NUMBER"), _T("Port to use for check_nt."))
 
-      (_T("performance data"), sh::bool_fun_key<bool>(boost::bind(&check_nt::server::handler::set_perf_data, info_.request_handler, _1), true),
+      (_T("performance data"), sh::bool_fun_key<bool>(boost::bind(&NSClientServer::set_perf_data, this, _1), true),
       _T("PERFORMANCE DATA"), _T("Send performance data back to nagios (set this to 0 to remove all performance data)."))
 
@@ -90 +95 @@
       _T("TIMEOUT"), _T("Timeout when reading packets on incoming sockets. If the data has not arrived within this time we will bail out."))
 
-      (_T("password"), sh::string_fun_key<std::wstring>(boost::bind(&check_nt::server::handler::set_password, info_.request_handler, _1), _T("")),
+      (_T("password"), sh::string_fun_key<std::wstring>(boost::bind(&NSClientServer::set_password, this, _1), _T("")),
       _T("PASSWORD"), _T("Password used to authenticate againast server"))
 
@@ -119 +124 @@
   if (mode == NSCAPI::normalStart) {
     try {
+#ifndef USE_SSL
           if (info_.use_ssl) {
-#ifdef USE_SSL
-            server_.reset(new check_nt::server::server(info_));
-#else
             NSC_LOG_ERROR_STD(_T("SSL is not supported (not compiled with openssl)"));
             return false;
+          }
 #endif
-          } else {
-            server_.reset(new check_nt::server::server(info_));
-          }
+          server_.reset(new check_nt::server::server(boost::shared_ptr<check_nt::read_protocol>(new check_nt::read_protocol(info_, this))));
           if (!server_) {
             NSC_LOG_ERROR_STD(_T("Failed to create server instance!"));
@@ -134 +136 @@
           }
           server_->start();
-
-    } catch (check_nt::server::check_nt_exception &e) {
-      NSC_LOG_ERROR_STD(_T("Exception caught: ") + e.what());
-      return false;
     } catch (std::exception &e) {
       NSC_LOG_ERROR_STD(_T("Exception caught: ") + to_wstring(e.what()));
@@ -148 +146 @@
   return true;
 }
-bool NSClientListener::unloadModule() {
+bool NSClientServer::unloadModule() {
   try {
     if (server_) {
@@ -161 +159 @@
 }
 
+
+
+#define REQ_CLIENTVERSION 1 // Works fine!
+#define REQ_CPULOAD     2 // Quirks
+#define REQ_UPTIME      3 // Works fine!
+#define REQ_USEDDISKSPACE 4 // Works fine!
+#define REQ_SERVICESTATE  5 // Works fine!
+#define REQ_PROCSTATE   6 // Works fine!
+#define REQ_MEMUSE      7 // Works fine!
+#define REQ_COUNTER     8 // Works fine!
+#define REQ_FILEAGE     9 // Works fine! (i hope)
+#define REQ_INSTANCES   10  // Works fine! (i hope)
+
+bool NSClientServer::isPasswordOk(std::wstring remotePassword)  {
+  std::wstring localPassword = get_password();
+  if (localPassword == remotePassword) {
+    return true;
+  }
+  if ((remotePassword == _T("None")) && (localPassword.empty())) {
+    return true;
+  }
+  return false;
+}
+
+void split_to_list(std::list<std::wstring> &list, std::wstring str) {
+  strEx::splitList add = strEx::splitEx(str, _T("&"));
+  list.insert(list.begin(), add.begin(), add.end());
+}
+
+check_nt::packet NSClientServer::handle(check_nt::packet p) {
+  std::wstring buffer = p.get_payload();
+  NSC_DEBUG_MSG_STD(_T("Data: ") + buffer);
+
+  std::wstring::size_type pos = buffer.find_first_of(_T("\n\r"));
+  if (pos != std::wstring::npos) {
+    std::wstring::size_type pos2 = buffer.find_first_not_of(_T("\n\r"), pos);
+    if (pos2 != std::wstring::npos) {
+      std::wstring rest = buffer.substr(pos2);
+      NSC_DEBUG_MSG_STD(_T("Ignoring data: ") + rest);
+    }
+    buffer = buffer.substr(0, pos);
+  }
+
+  strEx::token pwd = strEx::getToken(buffer, '&');
+  if (!isPasswordOk(pwd.first)) {
+    NSC_LOG_ERROR_STD(_T("Invalid password (") + pwd.first + _T(")."));
+    return check_nt::packet("ERROR: Invalid password.");
+  }
+  if (pwd.second.empty())
+    return check_nt::packet("ERROR: No command specified.");
+  strEx::token cmd = strEx::getToken(pwd.second, '&');
+  if (cmd.first.empty())
+    return check_nt::packet("ERROR: No command specified.");
+
+  int c = boost::lexical_cast<int>(cmd.first.c_str());
+
+  NSC_DEBUG_MSG_STD(_T("Data: ") + cmd.second);
+
+  std::list<std::wstring> args;
+
+  // prefix various commands
+  switch (c) {
+    case REQ_CPULOAD:
+      cmd.first = _T("checkCPU");
+      split_to_list(args, cmd.second);
+      args.push_back(_T("nsclient"));
+      break;
+    case REQ_UPTIME:
+      cmd.first = _T("checkUpTime");
+      args.push_back(_T("nsclient"));
+      break;
+    case REQ_USEDDISKSPACE:
+      cmd.first = _T("CheckDriveSize");
+      split_to_list(args, cmd.second);
+      args.push_back(_T("nsclient"));
+      break;
+    case REQ_CLIENTVERSION:
+      {
+        //std::wstring v = SETTINGS_GET_STRING(nsclient::VERSION);
+        //if (v == _T("auto"))
+        std::wstring v = nscapi::plugin_singleton->get_core()->getApplicationName() + _T(" ") + nscapi::plugin_singleton->get_core()->getApplicationVersionString();
+        return strEx::wstring_to_string(v);
+      }
+    case REQ_SERVICESTATE:
+      cmd.first = _T("checkServiceState");
+      split_to_list(args, cmd.second);
+      args.push_back(_T("nsclient"));
+      break;
+    case REQ_PROCSTATE:
+      cmd.first = _T("checkProcState");
+      split_to_list(args, cmd.second);
+      args.push_back(_T("nsclient"));
+      break;
+    case REQ_MEMUSE:
+      cmd.first = _T("checkMem");
+      args.push_back(_T("nsclient"));
+      break;
+    case REQ_COUNTER:
+      cmd.first = _T("checkCounter");
+      args.push_back(_T("Counter=") + cmd.second);
+      args.push_back(_T("nsclient"));
+      break;
+    case REQ_FILEAGE:
+      cmd.first = _T("getFileAge");
+      args.push_back(_T("path=") + cmd.second);
+      break;
+    case REQ_INSTANCES:
+      cmd.first = _T("listCounterInstances");
+      args.push_back(cmd.second);
+      break;
+
+
+    default:
+      split_to_list(args, cmd.second);
+  }
+
+  std::wstring message, perf;
+  NSCAPI::nagiosReturn ret = nscapi::core_helper::simple_query(cmd.first.c_str(), args, message, perf);
+  if (!nscapi::plugin_helper::isNagiosReturnCode(ret)) {
+    if (message.empty())
+      return check_nt::packet("ERROR: Could not complete the request check log file for more information.");
+    return check_nt::packet("ERROR: " + strEx::wstring_to_string(message));
+  }
+  switch (c) {
+    case REQ_UPTIME:    // Some check_nt commands has no return code syntax
+    case REQ_MEMUSE:
+    case REQ_CPULOAD:
+    case REQ_CLIENTVERSION:
+    case REQ_USEDDISKSPACE:
+    case REQ_COUNTER:
+    case REQ_FILEAGE:
+      return check_nt::packet(message);
+
+    case REQ_SERVICESTATE:  // Some check_nt commands return the return code (coded as a string)
+    case REQ_PROCSTATE:
+      return check_nt::packet(strEx::itos(nscapi::plugin_helper::nagios2int(ret)) + _T("& ") + message);
+
+    default:        // "New" check_nscp also returns performance data
+      if (perf.empty())
+        return check_nt::packet(nscapi::plugin_helper::translateReturn(ret) + _T("&") + message);
+      return check_nt::packet(nscapi::plugin_helper::translateReturn(ret) + _T("&") + message + _T("&") + perf);
+  }
+
+  return check_nt::packet("FOO");
+}
+
+
+
 NSC_WRAP_DLL();
-NSC_WRAPPERS_MAIN_DEF(NSClientListener);
+NSC_WRAPPERS_MAIN_DEF(NSClientServer);
 NSC_WRAPPERS_IGNORE_MSG_DEF();
 NSC_WRAPPERS_IGNORE_CMD_DEF();

modules/NSClientServer/NSClientServer.h

@@ -19 +19 @@
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
-//#include <Socket.h>
 #include <socket_helpers.hpp>
-#include <check_nt/server/server.hpp>
+#include <check_nt/server/protocol.hpp>
 
 NSC_WRAPPERS_MAIN();
 
-class NSClientListener : public nscapi::impl::simple_plugin {
-private:
-
-  check_nt::server::server::connection_info info_;
-  boost::shared_ptr<check_nt::server::server> server_;
-
+class NSClientServer : public nscapi::impl::simple_plugin, public check_nt::server::handler {
 public:
-  NSClientListener();
-  virtual ~NSClientListener();
+  NSClientServer();
+  virtual ~NSClientServer();
   // Module calls
   bool loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode);
@@ -50 +44 @@
     return _T("A simple server that listens for incoming NSClient (check_nt) connection and handles them.\nAlthough NRPE is the preferred method NSClient is fully supported and can be used for simplicity or for compatibility.");
   }
+
+
+  check_nt::packet handle(check_nt::packet packet);
+
+  check_nt::packet create_error(std::wstring msg) {
+    return check_nt::packet("ERROR: Failed to parse");
+  }
+
+  void log_debug(std::string module, std::string file, int line, std::string msg) const {
+    if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
+      GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
+    }
+  }
+  void log_error(std::string module, std::string file, int line, std::string msg) const {
+    if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
+      GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);
+    }
+  }
+
+  std::wstring get_password() const {
+    return password_;
+  }
+
+private:
+  void set_password(std::wstring password) {
+    password_ = password;
+  }
+  virtual void set_allow_arguments(bool v)  {
+    allowArgs_ = v;
+  }
+  virtual void set_allow_nasty_arguments(bool v) {
+    allowNasty_ = v;
+  }
+  virtual void set_perf_data(bool v) {
+    noPerfData_ = !v;
+  }
+  bool isPasswordOk(std::wstring remotePassword);
+
+private:
+  socket_helpers::connection_info info_;
+  boost::shared_ptr<check_nt::server::server> server_;
+
+  bool allowArgs_;
+  bool allowNasty_;
+  bool noPerfData_;
+  std::wstring password_;
+
 };

modules/NSClientServer/handler_impl.hpp

@@ -30 +30 @@
 
 
-  void log_debug(std::string file, int line, std::wstring msg) {
+  void log_debug(std::string module, std::string file, int line, std::string msg) {
     if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
       GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
     }
   }
-  void log_error(std::string file, int line, std::wstring msg) {
+  void log_error(std::string module, std::string file, int line, std::string msg) {
     if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
       GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);