Changeset 0f7b655 in nscp

Timestamp:

02/08/12 23:42:00 (16 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

76540c3

Parents:

e396b2f

Message:

• Added test cases for targets to NRPE
• Added test cases for targets to NSCA
• Added test cases for lenghts to NSCA
• Changed to python API sleep uses milliseconds (not seconds as before) Makes NSCA unittests go much faster (as I can wait much less)
• Fixed a lot of bugs related to target handling.
• implemented target refactoring on all Client modules.

Files:

• changelog (modified) (2 diffs)
• include/client/command_line_parser.cpp (modified) (8 diffs)
• include/client/command_line_parser.hpp (modified) (4 diffs)
• include/nsca/server/connection.cpp (modified) (1 diff)
• include/nsca/server/parser.hpp (modified) (1 diff)
• include/nscapi/functions.hpp (modified) (2 diffs)
• modules/NRPEClient/NRPEClient.cpp (modified) (9 diffs)
• modules/NRPEClient/NRPEClient.h (modified) (4 diffs)
• modules/NSCAClient/NSCAClient.cpp (modified) (11 diffs)
• modules/NSCAClient/NSCAClient.h (modified) (6 diffs)
• modules/NSCPClient/NSCPClient.cpp (modified) (10 diffs)
• modules/NSCPClient/NSCPClient.h (modified) (7 diffs)
• modules/PythonScript/script_wrapper.cpp (modified) (1 diff)
• modules/SMTPClient/SMTPClient.cpp (modified) (8 diffs)
• modules/SMTPClient/SMTPClient.h (modified) (6 diffs)
• modules/SyslogClient/SyslogClient.cpp (modified) (10 diffs)
• modules/SyslogClient/SyslogClient.h (modified) (6 diffs)
• scripts/python/test_all.py (modified) (1 diff)
• scripts/python/test_eventlog.py (modified) (1 diff)
• scripts/python/test_nrpe.py (modified) (3 diffs)
• scripts/python/test_nsca.py (modified) (7 diffs)
• scripts/python/test_python.py (modified) (1 diff)
• scripts/python/test_stress.py (modified) (1 diff)
• scripts/python/test_w32_system.py (modified) (1 diff)

changelog

@@ -6 +6 @@
  * Fix RtlStringFromGUID problem on NT4
 
+2012-02-05 MickeM
+ * Added test cases for targets to NRPE
+ * Added test cases for targets to NSCA
+ * Added test cases for lenghts to NSCA
+ * Changed to python API sleep uses milliseconds (not seconds as before)
+   Makes NSCA unittests go much faster (as I can wait much less)
+ * Fixed a lot of bugs related to target handling.
+ * implemented target refactoring on all Client modules.
 
 2012-02-05 MickeM
@@ -20 +28 @@
  * Implemented full settings API for LuaScript (next RC will have to wait till next weekend)
 
-2012-01-31 MickeM
+2012-01-31 MickeM1
  * Fixed issue with parsing "invalid external commands".
    If parsing falies it will notify you but use the legacy split string method instead.

include/client/command_line_parser.cpp

@@ -95 +95 @@
 }
 
-int client::command_line_parser::do_execute_command_as_query(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, const std::string &request, std::string &result) {
+int client::command_line_parser::do_execute_command_as_query(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, std::string &result) {
   if (!config.validate())
     throw cli_exception("Invalid data: " + config.to_string());
@@ -102 +102 @@
   } else if (command == _T("query")) {
     return do_query(config, command, arguments, result);
-  } else if (command == _T("forward")) {
-    return do_forward(config, request, result);
   } else if (command == _T("exec")) {
     int ret = do_exec(config, command, arguments, result);
@@ -136 +134 @@
 }
 
+
+int client::command_manager::process_query(std::wstring cmd, client::configuration &config, const Plugin::QueryRequestMessage &message, std::string &result) {
+  if (cmd == _T("forward"))
+    return config.handler->query(config.data, message, result);
+
+  // TODO: Loop though commands here!
+  if (message.payload_size() != 1) {
+    return nscapi::functions::create_simple_query_response_unknown(cmd, _T("Multiple payloads currently not supported"), result);
+  }
+  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(message.payload(0));
+  if (client::command_line_parser::is_command(cmd))
+    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, result);
+  return exec_simple(config, data.target, cmd, data.args, result);
+}
+
+int client::command_manager::process_exec(std::wstring cmd, client::configuration &config, const Plugin::ExecuteRequestMessage &message, std::string &result) {
+  if (cmd == _T("forward"))
+    return config.handler->exec(config.data, message, result);
+
+  // TODO: Loop though commands here!
+  if (message.payload_size() != 1) {
+    return nscapi::functions::create_simple_exec_response_unknown(cmd, std::wstring(_T("Multiple payloads currently not supported")), result);
+  }
+  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(cmd, message);
+  if (client::command_line_parser::is_command(cmd))
+    return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
+  return exec_simple(config, data.target, cmd, data.args, result);
+}
+
 int client::command_manager::exec_simple(configuration &config, const std::wstring &target, const std::wstring &command, std::list<std::wstring> &arguments, std::string &response) {
   command_type::const_iterator cit = commands.find(command);
@@ -179 +206 @@
   modify_header(config, message.mutable_header(), config.data->recipient);
   nscapi::functions::append_simple_query_request_payload(message.add_payload(), config.data->command, config.data->arguments);
-  return config.handler->query(config.data, message.mutable_header(), message.SerializeAsString(), response);
-}
-
-int client::command_line_parser::do_forward(configuration &config, const std::string &request, std::string &response) {
-  /*
-  if (!config.data->target_id.empty()) {
-    if (!config.target_lookup)
-      throw cli_exception("No target interface given when looking for targets");
-    config.data->recipient.import(config.target_lookup->lookup_target(config.data->target_id));
-  }
-  */
-  Plugin::QueryRequestMessage message;
-  message.ParseFromString(request);
-  return config.handler->query(config.data, message.mutable_header(), request, response);
+  return config.handler->query(config.data, message, response);
 }
 
@@ -222 +236 @@
   std::string response;
   nscapi::functions::append_simple_exec_request_payload(message.add_payload(), config.data->command, config.data->arguments);
-  return config.handler->exec(config.data, message.mutable_header(), message.SerializeAsString(), response);
+  return config.handler->exec(config.data, message, response);
 }
 
@@ -241 +255 @@
     if (!config.target_lookup)
       throw cli_exception("No target interface given when looking for targets");
-    config.data->recipient.import(config.target_lookup->lookup_target(config.data->target_id));
+    config.data->recipient.apply(config.target_lookup->lookup_target(config.data->target_id));
+    //po::store(parsed, vm);
+    po::notify(vm);
   }
 
@@ -250 +266 @@
   nscapi::functions::append_simple_submit_request_payload(message.add_payload(), config.data->command, parse_result(config.data->result), config.data->message);
 
-  return config.handler->submit(config.data, message.mutable_header(), message.SerializeAsString(), result);
+  return config.handler->submit(config.data, message, result);
 }
 void client::command_line_parser::modify_header(configuration &config, ::Plugin::Common_Header* header, nscapi::functions::destination_container &recipient) {
@@ -266 +282 @@
 }
 
-int client::command_line_parser::do_relay_submit(configuration &config, const std::string &request, std::string &response) {
-  Plugin::SubmitRequestMessage message;
-  message.ParseFromString(request);
-  modify_header(config, message.mutable_header(), config.data->recipient);
-  return config.handler->submit(config.data, message.mutable_header(), message.SerializeAsString(), response);
-}
-
+int client::command_line_parser::do_relay_submit(configuration &config, Plugin::SubmitRequestMessage &request_message, std::string &response) {
+  modify_header(config, request_message.mutable_header(), config.data->recipient);
+  return config.handler->submit(config.data, request_message, response);
+}
+

include/client/command_line_parser.hpp

@@ -111 +111 @@
 
   struct clp_handler {
-    virtual int query(configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) = 0;
-    virtual int submit(configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &response) = 0;
-    virtual int exec(configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) = 0;
+    virtual int query(configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) = 0;
+    virtual int submit(configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &response) = 0;
+    virtual int exec(configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) = 0;
   };
   struct command_manager {
@@ -126 +126 @@
     }
 
+    int process_query(std::wstring cmd, client::configuration &config, const Plugin::QueryRequestMessage &message, std::string &result);
+    int process_exec(std::wstring cmd, client::configuration &config, const Plugin::ExecuteRequestMessage &message, std::string &result);
+
+    
   };
 
@@ -138 +142 @@
 
     static int do_execute_command_as_exec(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, std::string &result);
-    static int do_execute_command_as_query(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, const std::string &request, std::string &result);
-    static int do_relay_submit(configuration &config, const std::string &request, std::string &response);
+    static int do_execute_command_as_query(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, std::string &result);
+    static int do_relay_submit(configuration &config, Plugin::SubmitRequestMessage &request_message, std::string &response);
 
     static std::wstring parse_command(std::wstring command, std::wstring prefix) {
@@ -164 +168 @@
 
     static int do_query(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, std::string &result);
-    static int do_forward(configuration &config, const std::string &request, std::string &result);
     static int do_exec(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, std::string &result);
     static int do_submit(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, std::string &result);

include/nsca/server/connection.cpp

@@ -58 +58 @@
     void connection::timeout(const boost::system::error_code& e) {
       if (e != boost::asio::error::operation_aborted) {
-        handler_->log_debug(__FILE__, __LINE__, _T("Timeout <<<-"));
+        handler_->log_debug(__FILE__, __LINE__, _T("Timeout reading:") + strEx::itos(parser_.get_payload_lenght()));
         boost::system::error_code ignored_ec;
         socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);

include/nsca/server/parser.hpp

@@ -45 +45 @@
         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/nscapi/functions.hpp

@@ -326 +326 @@
         if (host.id() == tag) {
           data.id = tag;
-          data.address.import(net::parse(host.address()));
+          if (!host.address().empty())
+            data.address.import(net::parse(host.address()));
           if (!host.comment().empty())
             data.comment = host.comment();
@@ -744 +745 @@
     }
     static decoded_simple_command_data parse_simple_exec_request(const wchar_t* char_command, const std::string &request) {
-      decoded_simple_command_data data;
-
-      data.command = char_command;
       Plugin::ExecuteRequestMessage message;
       message.ParseFromString(request);
+
+      return parse_simple_exec_request(char_command, message);
+    }
+    static decoded_simple_command_data parse_simple_exec_request(const std::wstring cmd, const Plugin::ExecuteRequestMessage &message) {
+      decoded_simple_command_data data;
+      data.command = cmd;
       if (message.has_header())
         data.target = utf8::cvt<std::wstring>(message.header().recipient_id());

modules/NRPEClient/NRPEClient.cpp

@@ -32 +32 @@
 namespace sh = nscapi::settings_helper;
 
+const std::wstring NRPEClient::command_prefix = _T("nrpe");
 /**
  * Default c-tor
@@ -55 +56 @@
 bool NRPEClient::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
 
-  std::wstring certificate;
-  unsigned int timeout = 30, buffer_length = 1024;
-  bool use_ssl = true;
   try {
 
@@ -119 +117 @@
 void NRPEClient::add_target(std::wstring key, std::wstring arg) {
   try {
-    nscapi::targets::target_object t = targets.add(get_settings_proxy(), target_path , key, arg);
+    targets.add(get_settings_proxy(), target_path , key, arg);
   } catch (const std::exception &e) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
@@ -149 +147 @@
 
 NSCAPI::nagiosReturn NRPEClient::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
   Plugin::QueryRequestMessage message;
   message.ParseFromString(request);
-  if (message.payload_size() != 1) {
-    return nscapi::functions::create_simple_query_response_unknown(char_command, _T("Multiple payloads currently not supported"), result);
-  }
-  std::string recipient = message.header().recipient_id();
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(message.payload(0));
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("nrpe"));
+
   client::configuration config;
-  config.data->recipient.id = recipient;
-  setup(config);
-  if (client::command_line_parser::is_command(cmd))
-    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, request, result);
-  return commands.exec_simple(config, data.target, cmd, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_query(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn NRPEClient::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("syslog"));
-  if (!client::command_line_parser::is_command(cmd))
-    return NSCAPI::returnIgnored;
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::ExecuteRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_exec(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn NRPEClient::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  Plugin::SubmitRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_relay_submit(config, request, result);
+  setup(config, message.header());
+
+  return client::command_line_parser::do_relay_submit(config, message, result);
 }
 
@@ -198 +197 @@
 }
 
-void NRPEClient::setup(client::configuration &config) {
+void NRPEClient::setup(client::configuration &config, const ::Plugin::Common_Header& header) {
   boost::shared_ptr<clp_handler_impl> handler = boost::shared_ptr<clp_handler_impl>(new clp_handler_impl(this));
   add_local_options(config.local, config.data);
 
-  config.data->recipient.address = net::parse("nrpe://localhost:5666");
+  config.data->recipient.id = header.recipient_id();
   std::wstring recipient = utf8::cvt<std::wstring>(config.data->recipient.id);
   if (!targets.has_object(recipient)) {
@@ -215 +214 @@
     config.data->recipient.apply(def);
   }
-  config.data->recipient.id = "default";
   config.data->host_self.id = "self";
   //config.data->host_self.host = hostname_;
@@ -233 +231 @@
 //
 
-int NRPEClient::clp_handler_impl::query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::QueryRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = this->instance->parse_header(*header, data);
+int NRPEClient::clp_handler_impl::query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
 
   Plugin::QueryResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   for (int i=0;i<request_message.payload_size();i++) {
@@ -255 +252 @@
 }
 
-int NRPEClient::clp_handler_impl::submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::SubmitRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = this->instance->parse_header(*header, data);
+int NRPEClient::clp_handler_impl::submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
   std::wstring channel = utf8::cvt<std::wstring>(request_message.channel());
   
   Plugin::SubmitResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   for (int i=0;i<request_message.payload_size();++i) {
@@ -277 +273 @@
 }
 
-int NRPEClient::clp_handler_impl::exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::ExecuteRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = this->instance->parse_header(*header, data);
+int NRPEClient::clp_handler_impl::exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
 
   Plugin::ExecuteResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   for (int i=0;i<request_message.payload_size();i++) {

modules/NRPEClient/NRPEClient.h

@@ -40 +40 @@
   std::wstring channel_;
   std::wstring target_path;
+  const static std::wstring command_prefix;
 
   struct custom_reader {
@@ -110 +111 @@
     connection_data(nscapi::functions::destination_container arguments, nscapi::functions::destination_container target) {
       arguments.import(target);
-      cert = arguments.get_string_data("certificate", "");
+      cert = arguments.get_string_data("certificate");
       timeout = arguments.get_int_data("timeout", 30);
       buffer_length = arguments.get_int_data("payload length", 1024);
@@ -140 +141 @@
     clp_handler_impl(NRPEClient *instance) : instance(instance) {}
 
-    int query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
+    int query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply);
+    int submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply);
+    int exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply);
 
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
-      nscapi::targets::optional_target_object t = instance->targets.find_object(id);
-      if (t)
-        return t->to_destination_container();
+      nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
+      if (opt)
+        return opt->to_destination_container();
       nscapi::functions::destination_container ret;
       return ret;
@@ -201 +202 @@
   static nrpe::packet send_ssl(std::string cert, std::string host, std::string port, int timeout, nrpe::packet packet);
 
-  connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
+  static connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:
   void add_local_options(po::options_description &desc, client::configuration::data_type data);
-  void setup(client::configuration &config);
+  void setup(client::configuration &config, const ::Plugin::Common_Header& header);
   void add_command(std::wstring key, std::wstring args);
   void add_target(std::wstring key, std::wstring args);

modules/NSCAClient/NSCAClient.cpp

@@ -33 +33 @@
 namespace sh = nscapi::settings_helper;
 
+const std::wstring NSCAAgent::command_prefix = _T("nsca");
 /**
  * Default c-tor
@@ -53 +54 @@
   return false;
 }
-/*
-DEFINE_SETTING_S(REPORT_MODE, NSCA_SERVER_SECTION, "report", "all");
-DESCRIBE_SETTING(REPORT_MODE, "REPORT MODE", "What to report to the server (any of the following: all, critical, warning, unknown, ok)");
-*/
 
 bool NSCAAgent::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
 
-
-  std::wstring encryption, password, nscahost;
-  std::string delay;
-  unsigned int timeout = 30, payload_length = 512, nscaport = 5666;
   try {
+
     sh::settings_registry settings(get_settings_proxy());
     settings.set_alias(_T("NSCA"), alias, _T("client"));
@@ -90 +84 @@
       ;
 
-    settings.alias().add_path_to_settings(_T("server"))
-      (_T("NSCA SERVER"), _T("Configure the NSCA server to report to."))
-      ;
-
     settings.register_all();
     settings.notify();
 
+    targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
+
+
     get_core()->registerSubmissionListener(get_id(), channel_);
+
+    register_command(_T("nsca_query"), _T("Check remote NRPE host"));
+    register_command(_T("nsca_submit"), _T("Submit (via query) remote NRPE host"));
+    register_command(_T("nsca_forward"), _T("Forward query to remote NRPE host"));
+    register_command(_T("nsca_exec"), _T("Execute (via query) remote NRPE host"));
+    register_command(_T("nsca_help"), _T("Help on using NRPE Client"));
 
     if (hostname_ == "auto") {
@@ -151 +150 @@
 void NSCAAgent::add_target(std::wstring key, std::wstring arg) {
   try {
-    nscapi::targets::target_object t = targets.add(get_settings_proxy(), target_path , key, arg);
+    targets.add(get_settings_proxy(), target_path , key, arg);
+  } catch (const std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
   } catch (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -179 +180 @@
 
 NSCAPI::nagiosReturn NSCAAgent::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("nsca"));
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::QueryRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  if (!client::command_line_parser::is_command(cmd))
-    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, request, result);
-  return commands.exec_simple(config, data.target, char_command, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_query(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn NSCAAgent::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("nsca"));
-  if (!client::command_line_parser::is_command(cmd))
-    return NSCAPI::returnIgnored;
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::ExecuteRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_exec(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn NSCAAgent::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  Plugin::SubmitRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_relay_submit(config, request, result);
+  setup(config, message.header());
+
+  return client::command_line_parser::do_relay_submit(config, message, result);
 }
 
@@ -213 +222 @@
     "Length of payload (has to be same as on the server)")
 
-    ("buffer-length,l", po::value<unsigned int>()->notifier(boost::bind(&nscapi::functions::destination_container::set_int_data, &data->recipient, "payload length", _1)), 
+    ("payload-length,l", po::value<unsigned int>()->notifier(boost::bind(&nscapi::functions::destination_container::set_int_data, &data->recipient, "payload length", _1)), 
     "Length of payload (has to be same as on the server)")
 
@@ -233 +242 @@
 }
 
-void NSCAAgent::setup(client::configuration &config) {
+void NSCAAgent::setup(client::configuration &config, const ::Plugin::Common_Header& header) {
   boost::shared_ptr<clp_handler_impl> handler(new clp_handler_impl(this));
   add_local_options(config.local, config.data);
 
-  config.data->recipient.id = "default";
-  config.data->recipient.address = net::parse("nsca://localhost:5667");
-
-  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
+  config.data->recipient.id = header.recipient_id();
+  std::wstring recipient = utf8::cvt<std::wstring>(config.data->recipient.id);
+  if (!targets.has_object(recipient)) {
+    NSC_LOG_ERROR(_T("Target not found (using default): ") + recipient);
+    recipient = _T("default");
+  }
+  nscapi::targets::optional_target_object opt = targets.find_object(recipient);
+
   if (opt) {
     nscapi::targets::target_object t = *opt;
     nscapi::functions::destination_container def = t.to_destination_container();
-    config.data->recipient.import(def);
+    config.data->recipient.apply(def);
   }
   config.data->host_self.id = "self";
@@ -253 +266 @@
 }
 
-NSCAAgent::connection_data NSCAAgent::parse_header(const ::Plugin::Common_Header &header) {
+NSCAAgent::connection_data NSCAAgent::parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data) {
   nscapi::functions::destination_container recipient, sender;
   nscapi::functions::parse_destination(header, header.recipient_id(), recipient, true);
   nscapi::functions::parse_destination(header, header.sender_id(), sender, true);
-  return connection_data(recipient, sender);
+  return connection_data(recipient, data->recipient, sender);
 }
 
@@ -264 +277 @@
 //
 
-int NSCAAgent::clp_handler_impl::query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::QueryRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+int NSCAAgent::clp_handler_impl::query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
 
   Plugin::QueryResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nsca::packet> list;
@@ -288 +300 @@
 }
 
-int NSCAAgent::clp_handler_impl::submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::SubmitRequestMessage message;
-  message.ParseFromString(request);
-  connection_data con = parse_header(*header);
-  std::wstring channel = utf8::cvt<std::wstring>(message.channel());
+int NSCAAgent::clp_handler_impl::submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
+  std::wstring channel = utf8::cvt<std::wstring>(request_message.channel());
 
   Plugin::SubmitResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nsca::packet> list;
 
-  for (int i=0;i < message.payload_size(); ++i) {
+  for (int i=0;i < request_message.payload_size(); ++i) {
     nsca::packet packet(con.sender_hostname, con.buffer_length, con.time_delta);
     std::wstring alias, msg;
-    packet.code = nscapi::functions::parse_simple_submit_request_payload(message.payload(i), alias, msg);
+    packet.code = nscapi::functions::parse_simple_submit_request_payload(request_message.payload(i), alias, msg);
     if (alias != _T("host_check"))
       packet.service = utf8::cvt<std::string>(alias);
@@ -315 +326 @@
 }
 
-int NSCAAgent::clp_handler_impl::exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::ExecuteRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+int NSCAAgent::clp_handler_impl::exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
 
   Plugin::ExecuteResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nsca::packet> list;

modules/NSCAClient/NSCAClient.h

@@ -40 +40 @@
   std::wstring channel_;
   std::wstring target_path;
+  const static std::wstring command_prefix;
   std::string hostname_;
   bool cacheNscaHost_;
@@ -53 +54 @@
       target.set_property_int(_T("payload length"), 512);
     }
-    static void post_process_target(target_object &target) {}
 
     static void add_custom_keys(sh::settings_registry &settings, boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
@@ -74 +74 @@
         ;
     }
+    static void post_process_target(target_object &target) {
+    }
   };
 
@@ -88 +90 @@
     int time_delta;
 
-    connection_data(nscapi::functions::destination_container recipient, nscapi::functions::destination_container sender) {
+    connection_data(nscapi::functions::destination_container recipient, nscapi::functions::destination_container target, nscapi::functions::destination_container sender) {
+      recipient.import(target);
       timeout = recipient.get_int_data("timeout", 30);
       buffer_length = recipient.get_int_data("payload length", 512);
@@ -126 +129 @@
     clp_handler_impl(NSCAAgent *instance) : instance(instance) {}
 
-    int query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
+    int query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply);
+    int submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply);
+    int exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply);
 
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
@@ -181 +184 @@
   boost::tuple<int,std::wstring> send(connection_data data, const std::list<nsca::packet> packets);
   void add_options(po::options_description &desc, connection_data &command_data);
-  static connection_data parse_header(const ::Plugin::Common_Header &header);
+  static connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:
   void add_local_options(po::options_description &desc, client::configuration::data_type data);
-  void setup(client::configuration &config);
+  void setup(client::configuration &config, const ::Plugin::Common_Header& header);
   void add_command(std::wstring key, std::wstring args);
   void add_target(std::wstring key, std::wstring args);

modules/NSCPClient/NSCPClient.cpp

@@ -34 +34 @@
 namespace sh = nscapi::settings_helper;
 
+const std::wstring NSCPClient::command_prefix = _T("nscp");
 /**
  * Default c-tor
@@ -58 +59 @@
   std::map<std::wstring,std::wstring> commands;
 
-  std::wstring certificate;
-  unsigned int timeout = 30, buffer_length = 1024;
-  bool use_ssl = true;
   try {
 
-    register_command(_T("query_nscp"), _T("Submit a query to a remote host via NSCP"));
-    register_command(_T("submit_nscp"), _T("Submit a query to a remote host via NSCP"));
-    register_command(_T("exec_nscp"), _T("Execute remote command on a remote host via NSCP"));
 
     sh::settings_registry settings(get_settings_proxy());
@@ -91 +86 @@
     settings.notify();
 
+    targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
+
+
     get_core()->registerSubmissionListener(get_id(), channel_);
+    register_command(_T("nscp_query"), _T("Submit a query to a remote host via NSCP"));
+    register_command(_T("nscp_forward"), _T("Forward query to remote NSCP host"));
+    register_command(_T("nscp_submit"), _T("Submit a query to a remote host via NSCP"));
+    register_command(_T("nscp_exec"), _T("Execute remote command on a remote host via NSCP"));
+    register_command(_T("nscp_help"), _T("Help on using NSCP Client"));
 
   } catch (nscapi::nscapi_exception &e) {
@@ -120 +123 @@
   try {
     targets.add(get_settings_proxy(), target_path , key, arg);
+  } catch (const std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
   } catch (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -147 +152 @@
 
 NSCAPI::nagiosReturn NSCPClient::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("syslog"));
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::QueryRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  if (!client::command_line_parser::is_command(cmd))
-    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, request, result);
-  return commands.exec_simple(config, data.target, char_command, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_query(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn NSCPClient::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("syslog"));
-  if (!client::command_line_parser::is_command(cmd))
-    return NSCAPI::returnIgnored;
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::ExecuteRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_exec(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn NSCPClient::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  Plugin::SubmitRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_relay_submit(config, request, result);
+  setup(config, message.header());
+
+  return client::command_line_parser::do_relay_submit(config, message, result);
 }
 
@@ -188 +201 @@
 }
 
-void NSCPClient::setup(client::configuration &config) {
+void NSCPClient::setup(client::configuration &config, const ::Plugin::Common_Header& header) {
   boost::shared_ptr<clp_handler_impl> handler = boost::shared_ptr<clp_handler_impl>(new clp_handler_impl(this));
   add_local_options(config.local, config.data);
 
-  config.data->recipient.id = "default";
-  config.data->recipient.address = net::parse("nscp://localhost:5668");
-  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
+  config.data->recipient.id = header.recipient_id();
+  std::wstring recipient = utf8::cvt<std::wstring>(config.data->recipient.id);
+  if (!targets.has_object(recipient)) {
+    NSC_LOG_ERROR(_T("Target not found (using default): ") + recipient);
+    recipient = _T("default");
+  }
+  nscapi::targets::optional_target_object opt = targets.find_object(recipient);
+
   if (opt) {
-    nscapi::functions::destination_container def = opt->to_destination_container();
-    config.data->recipient.import(def);
+    nscapi::targets::target_object t = *opt;
+    nscapi::functions::destination_container def = t.to_destination_container();
+    config.data->recipient.apply(def);
   }
   config.data->host_self.id = "self";
@@ -206 +225 @@
 }
 
-NSCPClient::connection_data NSCPClient::parse_header(const ::Plugin::Common_Header &header) {
+NSCPClient::connection_data NSCPClient::parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data) {
   nscapi::functions::destination_container recipient;
   nscapi::functions::parse_destination(header, header.recipient_id(), recipient, true);
-  return connection_data(recipient);
+  return connection_data(recipient, data->recipient);
 }
 
@@ -226 +245 @@
   return ret;
 }
-int NSCPClient::clp_handler_impl::query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int NSCPClient::clp_handler_impl::query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
   int ret = NSCAPI::returnUNKNOWN;
-  Plugin::QueryRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+  connection_data con = parse_header(request_header, data);
 
   Plugin::QueryResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nscp::packet> chunks;
   chunks.push_back(nscp::factory::create_envelope_request(1));
-  chunks.push_back(nscp::factory::create_payload(nscp::data::command_request, request, 0));
+  chunks.push_back(nscp::factory::create_payload(nscp::data::command_request, request_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
   BOOST_FOREACH(nscp::packet &chunk, chunks) {
@@ -256 +274 @@
 }
 
-int NSCPClient::clp_handler_impl::submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int NSCPClient::clp_handler_impl::submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
   int ret = NSCAPI::returnUNKNOWN;
-  Plugin::SubmitRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+  connection_data con = parse_header(request_header, data);
   Plugin::SubmitResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nscp::packet> chunks;
-  chunks.push_back(nscp::factory::create_payload(nscp::data::command_response, request, 0));
+  chunks.push_back(nscp::factory::create_payload(nscp::data::command_response, request_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
   BOOST_FOREACH(nscp::packet &chunk, chunks) {
@@ -284 +301 @@
 }
 
-int NSCPClient::clp_handler_impl::exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int NSCPClient::clp_handler_impl::exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
   int ret = NSCAPI::returnOK;
-  Plugin::ExecuteRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+  connection_data con = parse_header(request_header, data);
 
   Plugin::ExecuteResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nscp::packet> chunks;
   chunks.push_back(nscp::factory::create_envelope_request(1));
-  chunks.push_back(nscp::factory::create_payload(nscp::data::exec_request, request, 0));
+  chunks.push_back(nscp::factory::create_payload(nscp::data::exec_request, request_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
   BOOST_FOREACH(nscp::packet &chunk, chunks) {

modules/NSCPClient/NSCPClient.h

@@ -36 +36 @@
 namespace sh = nscapi::settings_helper;
 
-
 class NSCPClient : public nscapi::impl::simple_plugin {
 private:
@@ -42 +41 @@
   std::wstring channel_;
   std::wstring target_path;
+  const static std::wstring command_prefix;
 
   struct custom_reader {
@@ -53 +53 @@
       target.set_property_int(_T("payload length"), 1024);
     }
-
-    //static void post_process_target(target_object &target) {}
 
     static void add_custom_keys(sh::settings_registry &settings, boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
@@ -111 +109 @@
     int timeout;
 
-    connection_data(nscapi::functions::destination_container recipient) {
-      cert = recipient.get_string_data("certificate");
-      timeout = recipient.get_int_data("timeout", 30);
-      use_ssl = recipient.get_bool_data("ssl");
-      if (recipient.has_data("no ssl"))
-        use_ssl = !recipient.get_bool_data("no ssl");
-      host = recipient.address.host;
-      port = recipient.address.get_port(5668);
+    connection_data(nscapi::functions::destination_container arguments, nscapi::functions::destination_container target) {
+      arguments.import(target);
+      cert = arguments.get_string_data("certificate");
+      timeout = arguments.get_int_data("timeout", 30);
+      use_ssl = arguments.get_bool_data("ssl");
+      if (arguments.has_data("no ssl"))
+        use_ssl = !arguments.get_bool_data("no ssl");
+      if (arguments.has_data("use ssl"))
+        use_ssl = arguments.get_bool_data("use ssl");
+
+      host = arguments.address.host;
+      port = arguments.address.get_port(5668);
     }
 
@@ -126 +128 @@
       ss << _T(", port: ") << utf8::cvt<std::wstring>(port);
       ss << _T(", timeout: ") << timeout;
+      ss << _T(", use_ssl: ") << use_ssl;
       ss << _T(", certificate: ") << utf8::cvt<std::wstring>(cert);
-      ss << _T(", use_ssl: ") << use_ssl;
       return ss.str();
     }
@@ -137 +139 @@
     clp_handler_impl(NSCPClient *instance) : instance(instance) {}
 
-    int query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
+    int query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply);
+    int submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply);
+    int exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply);
 
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
-      nscapi::functions::destination_container ret;
       nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
       if (opt)
         return opt->to_destination_container();
+      nscapi::functions::destination_container ret;
       return ret;
     }
@@ -202 +204 @@
   bool submit_nscp(std::list<std::wstring> &arguments, std::wstring &result);
 
-  static connection_data parse_header(const ::Plugin::Common_Header &header);
+  static connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:
   void add_local_options(po::options_description &desc, client::configuration::data_type data);
-  void setup(client::configuration &config);
+  void setup(client::configuration &config, const ::Plugin::Common_Header& header);
   void add_command(std::wstring key, std::wstring args);
   void add_target(std::wstring key, std::wstring args);

modules/PythonScript/script_wrapper.cpp

@@ -128 +128 @@
   }
 }
-void script_wrapper::sleep(unsigned int seconds) {
-  {
-    thread_unlocker unlocker;
-    {
-      boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
+void script_wrapper::sleep(unsigned int ms) {
+  {
+    thread_unlocker unlocker;
+    {
+      boost::this_thread::sleep(boost::posix_time::milliseconds(ms));
 
     }

modules/SMTPClient/SMTPClient.cpp

@@ -35 +35 @@
 namespace sh = nscapi::settings_helper;
 
+const std::wstring SMTPClient::command_prefix = _T("smtp");
 /**
  * Default c-tor
@@ -79 +80 @@
 
       ;
+
     settings.register_all();
     settings.notify();
 
+    targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
+
+
     get_core()->registerSubmissionListener(get_id(), channel_);
+    register_command(_T("smtp_query"), _T("Check remote SMTP host"));
+    register_command(_T("smtp_submit"), _T("Submit (via query) remote SMTP host"));
+    register_command(_T("smtp_forward"), _T("Forward query to remote SMTP host"));
+    register_command(_T("smtp_exec"), _T("Execute (via query) remote SMTP host"));
+    register_command(_T("smtp_help"), _T("Help on using SMTP Client"));
   } catch (nscapi::nscapi_exception &e) {
     NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
@@ -110 +120 @@
   try {
     targets.add(get_settings_proxy(), target_path , key, arg);
+  } catch (const std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
   } catch (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -139 +151 @@
 
 NSCAPI::nagiosReturn SMTPClient::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("syslog"));
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::QueryRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  if (!client::command_line_parser::is_command(cmd))
-    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, request, result);
-  return commands.exec_simple(config, data.target, char_command, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_query(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn SMTPClient::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("syslog"));
-  if (!client::command_line_parser::is_command(cmd))
-    return NSCAPI::returnIgnored;
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::ExecuteRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_exec(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn SMTPClient::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  Plugin::SubmitRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_relay_submit(config, request, result);
+  setup(config, message.header());
+
+  return client::command_line_parser::do_relay_submit(config, message, result);
 }
 
@@ -182 +202 @@
 }
 
-void SMTPClient::setup(client::configuration &config) {
+void SMTPClient::setup(client::configuration &config, const ::Plugin::Common_Header& header) {
   boost::shared_ptr<clp_handler_impl> handler = boost::shared_ptr<clp_handler_impl>(new clp_handler_impl(this));
   add_local_options(config.local, config.data);
 
-  config.data->recipient.id = "default";
-  config.data->recipient.address = net::parse("smtp://localhost:25");
-  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
+  config.data->recipient.id = header.recipient_id();
+  std::wstring recipient = utf8::cvt<std::wstring>(config.data->recipient.id);
+  if (!targets.has_object(recipient)) {
+    NSC_LOG_ERROR(_T("Target not found (using default): ") + recipient);
+    recipient = _T("default");
+  }
+  nscapi::targets::optional_target_object opt = targets.find_object(recipient);
+
   if (opt) {
-    nscapi::functions::destination_container def = opt->to_destination_container();
-    config.data->recipient.import(def);
+    nscapi::targets::target_object t = *opt;
+    nscapi::functions::destination_container def = t.to_destination_container();
+    config.data->recipient.apply(def);
   }
   config.data->host_self.id = "self";
@@ -200 +226 @@
 }
 
-SMTPClient::connection_data SMTPClient::parse_header(const ::Plugin::Common_Header &header) {
+SMTPClient::connection_data SMTPClient::parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data) {
   nscapi::functions::destination_container recipient;
   nscapi::functions::parse_destination(header, header.recipient_id(), recipient, true);
-  return connection_data(recipient);
+  return connection_data(recipient, data->recipient);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // Parser implementations
-int SMTPClient::clp_handler_impl::query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int SMTPClient::clp_handler_impl::query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) {
   NSC_LOG_ERROR_STD(_T("SMTP does not support query patterns"));
   return NSCAPI::hasFailed;
 }
 
-int SMTPClient::clp_handler_impl::submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::SubmitRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+int SMTPClient::clp_handler_impl::submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
   std::wstring channel = utf8::cvt<std::wstring>(request_message.channel());
 
   Plugin::SubmitResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   for (int i=0;i < request_message.payload_size(); ++i) {
@@ -234 +259 @@
     nscapi::functions::append_simple_submit_response_payload(response_message.add_payload(), "TODO", NSCAPI::returnOK, "Message send successfully");
   }
-
   response_message.SerializeToString(&reply);
   return NSCAPI::isSuccess;
@@ -240 +264 @@
 }
 
-int SMTPClient::clp_handler_impl::exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int SMTPClient::clp_handler_impl::exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) {
   NSC_LOG_ERROR_STD(_T("SMTP does not support exec patterns"));
   return NSCAPI::hasFailed;

modules/SMTPClient/SMTPClient.h

@@ -37 +37 @@
   std::wstring channel_;
   std::wstring target_path;
+  const static std::wstring command_prefix;
 
   struct custom_reader {
     typedef nscapi::targets::target_object object_type;
     typedef nscapi::targets::target_object target_object;
-
 
     static void init_default(target_object &target) {
@@ -49 +49 @@
       target.set_property_string(_T("template"), _T("Hello, this is %source% reporting %message%!"));
     }
-    static void post_process_target(target_object &target) {}
 
     static void add_custom_keys(sh::settings_registry &settings, boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
@@ -67 +66 @@
       ;
     }
+    static void post_process_target(target_object &target) {
+    }
   };
 
@@ -80 +81 @@
     int timeout;
 
-    connection_data(nscapi::functions::destination_container recipient) {
-      recipient_str = recipient.get_string_data("recipient");
-      timeout = recipient.get_int_data("timeout", 30);
-      sender = recipient.get_string_data("sender");
-      template_string = recipient.get_string_data("template");
+    connection_data(nscapi::functions::destination_container arguments, nscapi::functions::destination_container target) {
+      arguments.import(target);
+      recipient_str = arguments.get_string_data("recipient");
+      timeout = arguments.get_int_data("timeout", 30);
+      sender = arguments.get_string_data("sender");
+      template_string = arguments.get_string_data("template");
 
-      host = recipient.address.host;
-      port = recipient.address.get_port(25);
+      host = arguments.address.host;
+      port = arguments.address.get_port(25);
     }
 
@@ -107 +109 @@
     clp_handler_impl(SMTPClient *instance) : instance(instance) {}
 
-    int query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
+    int query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply);
+    int submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply);
+    int exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply);
 
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
-      nscapi::functions::destination_container ret;
       nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
       if (opt)
         return opt->to_destination_container();
+      nscapi::functions::destination_container ret;
       return ret;
     }
@@ -156 +158 @@
 
 private:
-  static connection_data parse_header(const ::Plugin::Common_Header &header);
+  static connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:
   void add_local_options(po::options_description &desc, client::configuration::data_type data);
-  void setup(client::configuration &config);
+  void setup(client::configuration &config, const ::Plugin::Common_Header& header);
   void add_command(std::wstring key, std::wstring args);
   void add_target(std::wstring key, std::wstring args);

modules/SyslogClient/SyslogClient.cpp

@@ -35 +35 @@
 namespace ip = boost::asio::ip;
 
+const std::wstring SyslogClient::command_prefix = _T("syslog");
 /**
  * Default c-tor
@@ -90 +91 @@
   severities["debug"] = 7;
 
-  std::wstring severity, facility, tag_syntax, message_syntax;
-  std::wstring ok_severity, warn_severity, crit_severity, unknown_severity;
   try {
     sh::settings_registry settings(get_settings_proxy());
@@ -117 +116 @@
     settings.notify();
 
+    targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
+
+
     get_core()->registerSubmissionListener(get_id(), channel_);
-
+    register_command(_T("syslog_query"), _T("Check remote NRPE host"));
+    register_command(_T("syslog_submit"), _T("Submit (via query) remote NRPE host"));
+    register_command(_T("syslog_forward"), _T("Forward query to remote NRPE host"));
+    register_command(_T("syslog_exec"), _T("Execute (via query) remote NRPE host"));
+    register_command(_T("syslog_help"), _T("Help on using NRPE Client"));
   } catch (nscapi::nscapi_exception &e) {
     NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
@@ -140 +146 @@
   try {
     targets.add(get_settings_proxy(), target_path , key, arg);
+  } catch (const std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
   } catch (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -167 +175 @@
 
 NSCAPI::nagiosReturn SyslogClient::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("syslog"));
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::QueryRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  if (!client::command_line_parser::is_command(cmd))
-    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, request, result);
-  return commands.exec_simple(config, data.target, char_command, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_query(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn SyslogClient::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("syslog"));
-  if (!client::command_line_parser::is_command(cmd))
-    return NSCAPI::returnIgnored;
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::ExecuteRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_exec(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn SyslogClient::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  Plugin::SubmitRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_relay_submit(config, request, result);
+  setup(config, message.header());
+
+  return client::command_line_parser::do_relay_submit(config, message, result);
 }
 
@@ -224 +240 @@
 }
 
-void SyslogClient::setup(client::configuration &config) {
+void SyslogClient::setup(client::configuration &config, const ::Plugin::Common_Header& header) {
   boost::shared_ptr<clp_handler_impl> handler = boost::shared_ptr<clp_handler_impl>(new clp_handler_impl(this));
   add_local_options(config.local, config.data);
 
-  config.data->recipient.id = "default";
-  config.data->recipient.address = net::parse("syslog://localhost:514");
-  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
+  config.data->recipient.id = header.recipient_id();
+  std::wstring recipient = utf8::cvt<std::wstring>(config.data->recipient.id);
+  if (!targets.has_object(recipient)) {
+    NSC_LOG_ERROR(_T("Target not found (using default): ") + recipient);
+    recipient = _T("default");
+  }
+  nscapi::targets::optional_target_object opt = targets.find_object(recipient);
+
   if (opt) {
-    nscapi::functions::destination_container def = opt->to_destination_container();
-    config.data->recipient.import(def);
+    nscapi::targets::target_object t = *opt;
+    nscapi::functions::destination_container def = t.to_destination_container();
+    config.data->recipient.apply(def);
   }
   config.data->host_self.id = "self";
@@ -242 +264 @@
 }
 
-SyslogClient::connection_data SyslogClient::parse_header(const ::Plugin::Common_Header &header) {
+SyslogClient::connection_data SyslogClient::parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data) {
   nscapi::functions::destination_container recipient;
   nscapi::functions::parse_destination(header, header.recipient_id(), recipient, true);
-  return connection_data(recipient);
+  return connection_data(recipient, data->recipient);
 }
 
@@ -252 +274 @@
 //
 
-int SyslogClient::clp_handler_impl::query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int SyslogClient::clp_handler_impl::query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) {
   NSC_LOG_ERROR_STD(_T("SYSLOG does not support query patterns"));
   nscapi::functions::create_simple_query_response_unknown(_T("UNKNOWN"), _T("SYSLOG does not support query patterns"), reply);
@@ -258 +280 @@
 }
 
-int SyslogClient::clp_handler_impl::submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::SubmitRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+int SyslogClient::clp_handler_impl::submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
 
   Plugin::SubmitResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   //TODO: Map seveity!
@@ -295 +316 @@
 }
 
-int SyslogClient::clp_handler_impl::exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int SyslogClient::clp_handler_impl::exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) {
   NSC_LOG_ERROR_STD(_T("SYSLOG does not support exec patterns"));
   nscapi::functions::create_simple_exec_response_unknown("UNKNOWN", "SYSLOG does not support exec patterns", reply);

modules/SyslogClient/SyslogClient.h

@@ -38 +38 @@
   std::wstring channel_;
   std::wstring target_path;
+  const static std::wstring command_prefix;
 
   struct custom_reader {
@@ -54 +55 @@
     }
 
-    static void post_process_target(target_object &target) {}
 
     static void add_custom_keys(sh::settings_registry &settings, boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
@@ -83 +83 @@
         _T("TODO"), _T(""))
         ;
+    }
+    static void post_process_target(target_object &target) {
     }
   };
@@ -103 +105 @@
     std::string ok_severity, warn_severity, crit_severity, unknown_severity;
 
-    connection_data(nscapi::functions::destination_container recipient) {
+    connection_data(nscapi::functions::destination_container recipient, nscapi::functions::destination_container target) {
+      recipient.import(target);
       severity = recipient.data["severity"];
       facility = recipient.data["facility"];
@@ -135 +138 @@
     clp_handler_impl(SyslogClient *instance) : instance(instance) {}
 
-    int query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
+    int query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply);
+    int submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply);
+    int exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply);
 
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
-      nscapi::functions::destination_container ret;
       nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
       if (opt)
         return opt->to_destination_container();
+      nscapi::functions::destination_container ret;
       return ret;
     }
@@ -186 +189 @@
 private:
   boost::tuple<int,std::wstring> send(connection_data con, std::list<std::string> messages);
-  static connection_data parse_header(const ::Plugin::Common_Header &header);
+  static connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:
   void add_local_options(po::options_description &desc, client::configuration::data_type data);
-  void setup(client::configuration &config);
+  void setup(client::configuration &config, const ::Plugin::Common_Header& header);
   void add_command(std::wstring key, std::wstring args);
   void add_target(std::wstring key, std::wstring args);

scripts/python/test_all.py

@@ -1 @@
-from NSCP import Settings, Registry, Core, log, status, log_error, sleep
+from NSCP import Settings, Registry, Core, log, status, log_error
 from test_helper import BasicTest, TestResult, Callable, setup_singleton, install_testcases, init_testcases, shutdown_testcases
 

scripts/python/test_eventlog.py

@@ -73 +73 @@
     result = TestResult()
     result.add_message(self.test_create('Application Error', 1000, '0', 'error', ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']), 'Testing to create a log message')
-    sleep(1)
+    sleep(500)
     log(self.last_message)
     log('%s'%self.last_message)

scripts/python/test_nrpe.py

@@ -187 +187 @@
       else:
         log('Waiting for %s (%s/%s)'%(uid,alias,target))
-        sleep(1)
+        sleep(500)
     if found:
       return result
@@ -194 +194 @@
   def test_one(self, ssl=True, length=1024, state = status.UNKNOWN, tag = 'TODO'):
     result = TestResult('Testing NRPE: %s/%s/%s with various targets'%(ssl, length, tag))
-    result.add(self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '', "valid"))
-    result.add(self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '', "test_rp"))
-    result.add(self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '', "invalid"))
+    for t in ['valid', 'test_rp', 'invalid']:
+      result.add(self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '', t))
     return result
 
@@ -207 +206 @@
     core.reload('test_nrpe_server')
 
-    #                /settings/NRPE/test_nrpe_client/targets/default
     conf.set_string('/settings/NRPE/test_nrpe_client/targets/default', 'address', 'nrpe://127.0.0.1:35666')
     conf.set_bool('/settings/NRPE/test_nrpe_client/targets/default', 'use ssl', not ssl)

scripts/python/test_nsca.py

@@ -151 +151 @@
       if not self.has_response(uuid):
         log('Waiting for %s (%d/10)'%(uuid, i+1))
-        sleep(1)
+        sleep(200)
       else:
         log('Got response %s'%uuid)
@@ -164 +164 @@
       if not rmsg.got_simple_response or not rmsg.got_response:
         log('Waiting for delayed response %s s/m: %s/%s - (%d/10)'%(uuid, rmsg.got_simple_response, rmsg.got_response, i+1))
-        sleep(1)
+        sleep(500)
       else:
         log('Got delayed response %s'%uuid)
@@ -179 +179 @@
     return True
 
-  def submit_payload(self, encryption, source, status, msg, perf, tag):
+  def submit_payload(self, encryption, target, length, source, status, msg, perf, tag):
     message = plugin_pb2.SubmitRequestMessage()
     
     message.header.version = plugin_pb2.Common.VERSION_1
-    message.header.recipient_id = "test_rp"
+    message.header.recipient_id = target
     message.channel = 'nsca_test_outbox'
     host = message.header.hosts.add()
-    host.address = "127.0.0.1:15667"
-    host.id = "test_rp"
-    enc = host.metadata.add()
-    enc.key = "encryption"
-    enc.value = encryption
-    enc = host.metadata.add()
-    enc.key = "password"
-    enc.value = 'pwd-%s'%encryption
+    host.id = target
+    if (target == 'valid'):
+      pass
+    else:
+      host.address = "127.0.0.1:15667"
+      enc = host.metadata.add()
+      enc.key = "encryption"
+      enc.value = encryption
+      enc = host.metadata.add()
+      enc.key = "password"
+      enc.value = 'pwd-%s'%encryption
+      enc = host.metadata.add()
+      enc.key = "payload length"
+      enc.value = '%d'%length
 
     uid = str(uuid.uuid4())
@@ -208 +214 @@
     return result
     
-  def submit_via_exec(self, encryption, source, status, msg, perf, tag):
+  def submit_via_exec(self, encryption, target, length, source, status, msg, perf, tag):
     uid = str(uuid.uuid4())
   
@@ -216 +222 @@
       '--result', '%d'%status, 
       '--message', '%s - %s'%(uid, msg), 
-      '--encryption', encryption,
-      '--password', 'pwd-%s'%encryption,
-      '--address', '127.0.0.1:15667'
+      '--target', target,
       ]
+    if (target == 'valid'):
+      pass
+    else:
+      args.extend([
+        '--address', '127.0.0.1:15667',
+        '--encryption', encryption,
+        '--password', 'pwd-%s'%encryption,
+        '--payload-length', '%d'%length,
+      ])
     (result_code, result_message) = core.simple_exec('any', 'nsca_submit', args)
     result = TestResult('Testing payload submission (via command line exec): %s'%tag)
@@ -232 +245 @@
     return result
 
-  def test_one_crypto_full(self, encryption, state, key):
+  def test_one_crypto_full(self, encryption, state, key, target, length):
     result = TestResult('Testing %s/%s'%(encryption, key))
-    result.add(self.submit_payload(encryption, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '', '%s/%s'%(state, encryption)))
-    result.add(self.submit_via_exec(encryption, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '', '%s/%s'%(state, encryption)))
-    return result
-
-  def test_one_crypto(self, crypto):
+    result.add(self.submit_payload(encryption, target, length, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '', '%s/%s/%d/%s'%(state, encryption, length, target)))
+    result.add(self.submit_via_exec(encryption, target, length, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '', '%s/%s/%d/%s'%(state, encryption, length, target)))
+    return result
+
+  def test_one_crypto(self, crypto, length=512):
     conf = Settings.get()
     conf.set_string('/settings/NSCA/test_nsca_server', 'encryption', '%s'%crypto)
     conf.set_string('/settings/NSCA/test_nsca_server', 'password', 'pwd-%s'%crypto)
+    conf.set_int('/settings/NSCA/test_nsca_server', 'payload length', length)
     core.reload('test_nsca_server')
-    result = TestResult('Testing encryption algorith: %s'%crypto)
+    
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/default', 'address', 'nsca://127.0.0.1:35667')
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/default', 'encryption', '%s'%crypto)
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/default', 'password', 'default-%s'%crypto)
+    conf.set_int('/settings/NSCA/test_nsca_client/targets/default', 'payload length', length*3)
+
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/invalid', 'address', 'nsca://127.0.0.1:25667')
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/invalid', 'encryption', 'none')
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/invalid', 'password', 'invalid-%s'%crypto)
+    conf.set_int('/settings/NSCA/test_nsca_client/targets/invalid', 'payload length', length*2)
+
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/valid', 'address', 'nsca://127.0.0.1:15667')
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/valid', 'encryption', '%s'%crypto)
+    conf.set_string('/settings/NSCA/test_nsca_client/targets/valid', 'password', 'pwd-%s'%crypto)
+    conf.set_int('/settings/NSCA/test_nsca_client/targets/valid', 'payload length', length)
+    core.reload('test_nsca_client')
+
+    
+    
+    result = TestResult('Testing: %s/%d'%(crypto, length))
     result.add_message(isOpen('localhost', 15667), 'Checking that port is open')
-    result.add(self.test_one_crypto_full(crypto, status.UNKNOWN, 'unknown'))
-    result.add(self.test_one_crypto_full(crypto, status.OK, 'ok'))
-    result.add(self.test_one_crypto_full(crypto, status.WARNING, 'warn'))
-    result.add(self.test_one_crypto_full(crypto, status.CRITICAL, 'crit'))
+    for target in ['valid', 'test_rp', 'invalid']:
+      result.add(self.test_one_crypto_full(crypto, status.UNKNOWN, 'unknown', target, length))
+      result.add(self.test_one_crypto_full(crypto, status.OK, 'ok', target, length))
+      result.add(self.test_one_crypto_full(crypto, status.WARNING, 'warn', target, length))
+      result.add(self.test_one_crypto_full(crypto, status.CRITICAL, 'crit', target, length))
     return result
 
@@ -255 +289 @@
     cryptos = ["none", "xor", "des", "3des", "cast128", "xtea", "blowfish", "twofish", "rc2", "aes", "aes256", "aes192", "aes128", "serpent", "gost", "3way"]
     for c in cryptos:
-      result.add_message(True, 'Testing crypto: %s'%c)
-      result.add(self.test_one_crypto(c))
+      for l in [128, 512, 1024, 4096]:
+        result.add(self.test_one_crypto(c, l))
+      #result.add(self.test_one_crypto(c))
     
     return result

scripts/python/test_python.py

@@ -58 +58 @@
       old_stress_count = self.stress_count
       old_noop_count = self.noop_count
-      sleep(5)
+      sleep(5000)
       result.add_message(True, 'Commands/second: %d/%d'%( (self.stress_count-old_stress_count)/5, (self.noop_count-old_noop_count)/5 ) )
     elapsed = (time() - start)

scripts/python/test_stress.py

@@ -113 +113 @@
         old_stress_count = self.results_count
         old_noop_count = self.check_count
-        sleep(5)
+        sleep(5000)
         result.add_message(True, 'Commands/second: %d/%d'%( (self.results_count-old_stress_count)/5, (self.check_count-old_noop_count)/5 ) )
         if (self.results_count*100/total_count) > last_major + 10:

scripts/python/test_w32_system.py

@@ -57 +57 @@
       log('Starting notepad...')
       handle = subprocess.Popen('notepad.exe', shell=False)
-      sleep(1)
+      sleep(500)
       pids.append(handle.pid)
       for j in range(0,3):