Changeset 465866c in nscp for modules/NSCPClient/NSCPClient.cpp

Timestamp:

06/05/12 07:35:30 (12 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.1, 0.4.2

Children:

742b035

Parents:

695f240

Message:

2012-06-05 MickeM

• Tweaked all servers to use the new internals and added first testcase for NSCP socket

2012-05-24 MickeM

• Reworked real time event log support to be a lot more flexible You can now specify all options on a "filter" level.
• WARNING* Old syntax NOT supported (and will not upgrade) but hopefully not to many will be affected.
• Added support for ipv6 allowed hosts validation

2012-05-21 MickeM

• Sofia Born (My second daughter)

File:

• modules/NSCPClient/NSCPClient.cpp (modified) (9 diffs)

modules/NSCPClient/NSCPClient.cpp

@@ -21 +21 @@
 #include "stdafx.h"
 #include "NSCPClient.h"
+
 #include <time.h>
-#include <boost/filesystem.hpp>
-
 #include <strEx.h>
-#include <net/net.hpp>
-#include <nscp/client/socket.hpp>
 
 #include <protobuf/plugin.pb.h>
@@ -64 +61 @@
 
     sh::settings_registry settings(get_settings_proxy());
-    settings.set_alias(_T("NSCP"), alias, _T("client"));
+    settings.set_alias(_T("nscp"), alias, _T("client"));
     target_path = settings.alias().get_settings_path(_T("targets"));
 
@@ -75 +72 @@
       (_T("targets"), sh::fun_values_path(boost::bind(&NSCPClient::add_target, this, _1, _2)), 
       _T("REMOTE TARGET DEFINITIONS"), _T(""))
-
       ;
 
@@ -96 +92 @@
     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) {
     NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
@@ -193 +188 @@
   desc.add_options()
     ("certificate,c", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "certificate", _1)), 
-      "Length of payload (has to be same as on the server)")
-/*
-    ("no-ssl,n", po::value<bool>(&command_data.no_ssl)->zero_tokens()->default_value(false), "Do not initial an ssl handshake with the server, talk in plain text.")
-
-    ("cert,c", po::value<std::wstring>(&command_data.cert)->default_value(cert_), "Certificate to use.")
-    */
+    "Length of payload (has to be same as on the server)")
+
+    ("no-ssl,n", po::value<bool>()->zero_tokens()->default_value(false)->notifier(boost::bind(&nscapi::functions::destination_container::set_bool_data, &data->recipient, "no ssl", _1)), 
+    "Do not initial an ssl handshake with the server, talk in plaintext.")
     ;
 }
@@ -209 +202 @@
   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");
   }
@@ -255 +247 @@
 
   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_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
@@ -311 +302 @@
 
   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_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
@@ -334 +324 @@
 // Protocol implementations
 //
+struct client_handler : public socket_helpers::client::client_handler {
+  client_handler(NSCPClient::connection_data &con) 
+    : socket_helpers::client::client_handler(con.host, con.port, con.timeout, con.use_ssl, con.cert)
+  {
+
+  }
+  void log_debug(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, utf8::to_unicode(msg));
+    }
+  }
+  void log_error(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, utf8::to_unicode(msg));
+    }
+  }
+};
 
 std::list<nscp::packet> NSCPClient::send(connection_data con, std::list<nscp::packet> &chunks) {
-  NSC_DEBUG_MSG_STD(_T("NRPE Connection details: ") + con.to_wstring());
-  chunks.push_front(nscp::factory::create_envelope_request(1));
-  std::list<nscp::packet> tmp, result;
-  if (con.use_ssl) {
-#ifdef USE_SSL
-    tmp = send_ssl(con.host, con.port, con.cert, con.timeout, chunks);
-#else
-    NSC_LOG_ERROR_STD(_T("SSL not avalible (not compiled with USE_SSL)"));
-    result.push_back(nscp::factory::create_error(_T("SSL support not available (compiled without USE_SSL)!")));
+  std::list<nscp::packet> response;
+  try {
+    NSC_DEBUG_MSG_STD(_T("NSCP Connection details: ") + con.to_wstring());
+    //NSC_DEBUG_MSG_STD(_T("NSCP data: ") + utf8::cvt<std::wstring>(data));
+    if (con.use_ssl) {
+#ifndef USE_SSL
+      NSC_LOG_ERROR_STD(_T("SSL not avalible (compiled without USE_SSL)"));
+      return response;
 #endif
-  } else {
-    tmp = send_nossl(con.host, con.port, con.timeout, chunks);
-  }
-  BOOST_FOREACH(nscp::packet &p, tmp) {
-    if (nscp::checks::is_envelope_response(p)) {
-    } else {
-      result.push_back(p);
-    }
-  }
-  return result;
-}
-
-#ifdef USE_SSL
-std::list<nscp::packet> NSCPClient::send_ssl(std::string host, std::string port, std::wstring cert, int timeout, const std::list<nscp::packet> &chunks) {
-  NSC_DEBUG_MSG_STD(_T("Connecting SSL to: ") + utf8::cvt<std::wstring>(host + ":" + port));
-  boost::asio::io_service io_service;
-  boost::asio::ssl::context ctx(io_service, boost::asio::ssl::context::sslv23);
-  SSL_CTX_set_cipher_list(ctx.impl(), "ADH");
-  ctx.use_tmp_dh_file(to_string(cert));
-  ctx.set_verify_mode(boost::asio::ssl::context::verify_none);
-  nscp::client::ssl_socket socket(io_service, ctx, host, port);
-  socket.send(chunks, boost::posix_time::seconds(timeout));
-  return socket.recv(boost::posix_time::seconds(timeout));
-}
-#endif
-
-std::list<nscp::packet> NSCPClient::send_nossl(std::string host, std::string port, int timeout, const std::list<nscp::packet> &chunks) {
-  NSC_DEBUG_MSG_STD(_T("Connecting to: ") + utf8::cvt<std::wstring>(host + ":" + port));
-  boost::asio::io_service io_service;
-  nscp::client::socket socket(io_service, host, port);
-  socket.send(chunks, boost::posix_time::seconds(timeout));
-  return socket.recv(boost::posix_time::seconds(timeout));
+    }
+    socket_helpers::client::client<nscp::client::protocol> client(boost::shared_ptr<client_handler>(new client_handler(con)));
+    client.connect();
+    BOOST_FOREACH(nscp::packet packet, chunks) {
+      response.push_back(client.process_request(packet));
+    }
+    client.shutdown();
+    return response;
+  } catch (std::runtime_error &e) {
+    NSC_LOG_ERROR_STD(_T("Socket error: ") + utf8::to_unicode(e.what()));
+    return response;
+  } catch (std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Error: ") + utf8::to_unicode(e.what()));
+    return response;
+  } catch (...) {
+    return response;
+  }
 }