Changeset c6a974c in nscp

Timestamp:

06/17/12 22:15:11 (11 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.1, 0.4.2

Children:

6090c98

Parents:

49187ce

Message:

• Initial (rather crude) NRDP support.

Files:

• CMakeLists.txt (modified) (2 diffs)
• build.cmake (modified) (1 diff)
• build/cmake/FindTinyXML2.cmake (added)
• changelog (modified) (1 diff)
• include/http/client.hpp (modified) (2 diffs)
• modules/NRDPClient/CMakeLists.txt (added)
• modules/NRDPClient/NRDPClient.cpp (added)
• modules/NRDPClient/NRDPClient.def (added)
• modules/NRDPClient/NRDPClient.h (added)
• modules/NRDPClient/module.cmake (added)
• modules/NRDPClient/nrdp.cpp (added)
• modules/NRDPClient/nrdp.hpp (added)
• modules/NRDPClient/stdafx.cpp (added)
• modules/NRDPClient/stdafx.h (added)
• modules/NSCAClient/NSCAClient.cpp (modified) (1 diff)
• modules/NSCAClient/NSCAClient.h (modified) (5 diffs)
• modules/NSCPServer/CMakeLists.txt (modified) (1 diff)

CMakeLists.txt

@@ -101 +101 @@
   MESSAGE(STATUS "Found python (lib) in: ${PYTHON_LIBRARY}")
 ENDIF (PYTHONLIBSEX_FOUND)
+
+FIND_PACKAGE(TINYXML2)
+IF (TINYXML2_FOUND)
+  MESSAGE(STATUS "Found tinyxml2 in: ${TINYXML2_INCLUDE_DIR}")
+ENDIF (TINYXML2_FOUND)
 
 
@@ -186 +191 @@
 elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
   # Update if necessary
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-long-long -pedantic -Wno-unused-parameter")
 endif()
 

build.cmake

@@ -7 +7 @@
   SET(INC_PSDK_61 "C:/Program Files/Microsoft SDKs/Windows/v6.1/")
   SET(INC_PSDK_2003 "C:/Program Files/Microsoft Platform SDK/")
+  SET(TINYXML2_DIR "D:/source/libraries/tinyxml2")
 
   if(CMAKE_CL_64)

changelog

@@ -4 +4 @@
  * Fix dependonservice LanManWorkStation (old win)
  * Fix RtlStringFromGUID problem on NT4
+
+2012-06-16 MickeM
+ * Initial (rather crude) NRDP support.
 
 2012-06-16 MickeM

include/http/client.hpp

@@ -5 +5 @@
 #include <ostream>
 #include <string>
+
 #include <boost/asio.hpp>
+#include <boost/tuple/tuple.hpp>
 
 #include <strEx.h>
+#include <socket/socket_helpers.hpp>
 
 using boost::asio::ip::tcp;
@@ -13 +16 @@
 namespace http {
   class client {
+
+    boost::asio::io_service io_service;
+    tcp::socket socket;
+
+
+    static std::string charToHex(char c) {
+      std::string result;
+      char first, second;
+
+      first = (c & 0xF0) / 16;
+      first += first > 9 ? 'A' - 10 : '0';
+      second = c & 0x0F;
+      second += second > 9 ? 'A' - 10 : '0';
+
+      result.append(1, first);
+      result.append(1, second);
+
+      return result;
+    }
+
+    static std::string uri_encode(const std::string& src)
+    {
+      std::string result;
+      std::string::const_iterator iter;
+
+      for(iter = src.begin(); iter != src.end(); ++iter) {
+        switch(*iter) {
+  case ' ':
+    result.append(1, '+');
+    break;
+    // alnum
+  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
+  case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
+  case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
+  case 'V': case 'W': case 'X': case 'Y': case 'Z':
+  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
+  case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
+  case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
+  case 'v': case 'w': case 'x': case 'y': case 'z':
+  case '0': case '1': case '2': case '3': case '4': case '5': case '6':
+  case '7': case '8': case '9':
+    // mark
+  case '-': case '_': case '.': case '!': case '~': case '*': case '\'': 
+  case '(': case ')':
+    result.append(1, *iter);
+    break;
+    // escape
+  default:
+    result.append(1, '%');
+    result.append(charToHex(*iter));
+    break;
+        }
+      }
+
+      return result;
+    }
+
+
   public:
+    client()
+      : io_service()
+      , socket(io_service)
+    {
+    }
+
+    void connect() {
+
+    }
+    struct response_type {
+      unsigned int code;
+      std::list<std::string> headers;
+      std::string payload;
+      std::string version;
+      std::string message;
+
+      void add_header(const std::string &header) 
+      {
+        headers.push_back(header);
+      }
+
+
+    };
+    struct request_type {
+      typedef std::map<std::string,std::string> post_map_type;
+      std::string verb;
+      std::list<std::string> headers;
+      std::string payload;
+      void add_default_headers() {
+        add_header("Accept:", "*/*");
+        add_header("Connection:", "close");
+      }
+      void add_header(std::string key, std::string value) {
+        headers.push_back(key + ": " + value);
+      }
+      void add_header(std::string value) {
+        headers.push_back(value);
+      }
+      void build_request(std::string verb, std::string server, std::string path, std::ostream &os) const {
+        const char* crlf = "\r\n";
+        os << verb << " " << path << " HTTP/1.0" << crlf;
+        os << "Host: " << server << crlf;
+        BOOST_FOREACH(const std::string &s, headers) {
+          os << s << crlf;
+        }
+        os << crlf;
+        if (!payload.empty()) 
+          os << payload;
+        os << crlf;
+        os << crlf;
+      }
+      void add_post_payload(const post_map_type &payload_map) {
+        std::string data;
+        BOOST_FOREACH(const post_map_type::value_type &v, payload_map) {
+          if (!data.empty())
+            data += "&";
+          data += uri_encode(v.first);
+          data += "=";
+          data += uri_encode(v.second);
+        }
+        add_header("Content-Length", strEx::s::xtos(data.size()));
+        add_header("Content-Type", "application/x-www-form-urlencoded");
+        verb = "POST";
+        payload = data;
+      }
+    };
+
+    void connect(std::string server, std::string port) {
+      tcp::resolver resolver(io_service);
+      tcp::resolver::query query(server, port);
+      tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
+      tcp::resolver::iterator end;
+
+      boost::system::error_code error = boost::asio::error::host_not_found;
+      while (error && endpoint_iterator != end) {
+        socket.close();
+        socket.connect(*endpoint_iterator++, error);
+      }
+      if (error)
+        throw boost::system::system_error(error);
+    }
+    void send_request(std::string server, std::string path, request_type &request) {
+      boost::asio::streambuf requestbuf;
+      std::ostream request_stream(&requestbuf);
+      request.build_request(request.verb, server, path, request_stream);
+      boost::asio::write(socket, requestbuf);
+    }
+    boost::tuple<std::string,unsigned int,std::string> read_result() {
+      const char* crlf = "\r\n";
+      boost::asio::streambuf response;
+      std::string http_version, status_message;
+      unsigned int status_code;
+      boost::asio::read_until(socket, response, crlf);
+
+      std::istream response_stream(&response);
+      if (response_stream)
+        throw socket_helpers::socket_exception("Invalid response");
+      response_stream >> http_version;
+      response_stream >> status_code;
+      std::getline(response_stream, status_message);
+      return boost::make_tuple(http_version, status_code, status_message);
+    }
+
+
+    response_type execute(std::string server, std::string port, std::string path, request_type &request) {
+      response_type response;
+      connect(server, port);
+      send_request(server, path, request);
+
+      boost::tie(response.version, response.code, response.message) = read_result();
+
+      if (response.version.substr(0, 5) != "HTTP/")
+        throw socket_helpers::socket_exception("Invalid response: " + response.version);
+      if (response.code != 200)
+        throw socket_helpers::socket_exception("Response returned with status code " + strEx::s::xtos(response.code));
+
+      boost::asio::streambuf responsebuffer;
+      std::istream response_stream(&responsebuffer);
+      boost::asio::read_until(socket, responsebuffer, "\r\n\r\n");
+
+      std::string header;
+      while (std::getline(response_stream, header) && header != "\r")
+        response.add_header(header);
+
+      std::ostringstream os;
+      if (responsebuffer.size() > 0)
+        os << &responsebuffer;
+
+      boost::system::error_code error;
+      while (boost::asio::read(socket, responsebuffer, boost::asio::transfer_at_least(1), error))
+        os << &responsebuffer;
+      if (error != boost::asio::error::eof)
+        throw boost::system::system_error(error);
+      response.payload = os.str();
+      return response;
+    }
+
     static bool download(std::string protocol, std::string server, std::string path, std::ostream &os, std::string &error_msg) {
       try {
-
-        boost::asio::io_service io_service;
-
-        // Get a list of endpoints corresponding to the server name.
-        tcp::resolver resolver(io_service);
-        tcp::resolver::query query(server, protocol);
-        tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
-        tcp::resolver::iterator end;
-
-        // Try each endpoint until we successfully establish a connection.
-        tcp::socket socket(io_service);
-        boost::system::error_code error = boost::asio::error::host_not_found;
-        while (error && endpoint_iterator != end) {
-          socket.close();
-          socket.connect(*endpoint_iterator++, error);
-        }
-        if (error)
-          throw boost::system::system_error(error);
-
-        // Form the request. We specify the "Connection: close" header so that the
-        // server will close the socket after transmitting the response. This will
-        // allow us to treat all data up until the EOF as the content.
-        boost::asio::streambuf request;
-        std::ostream request_stream(&request);
-        request_stream << "GET " << path << " HTTP/1.0\r\n";
-        request_stream << "Host: " << server << "\r\n";
-        request_stream << "Accept: */*\r\n";
-        request_stream << "Connection: close\r\n\r\n";
-
-        // Send the request.
-        boost::asio::write(socket, request);
-
-        // Read the response status line.
-        boost::asio::streambuf response;
-        boost::asio::read_until(socket, response, "\r\n");
-
-        // Check that response is OK.
-        std::istream response_stream(&response);
-        std::string http_version;
-        response_stream >> http_version;
-        unsigned int status_code;
-        response_stream >> status_code;
-        std::string status_message;
-        std::getline(response_stream, status_message);
-        if (!response_stream || http_version.substr(0, 5) != "HTTP/") {
-          error_msg = "Invalid response";
-          return false;
-        }
-        if (status_code != 200) {
-          error_msg = "Response returned with status code " + strEx::wstring_to_string(strEx::itos(status_code));
-          return false;
-        }
-
-        // Read the response headers, which are terminated by a blank line.
-        boost::asio::read_until(socket, response, "\r\n\r\n");
-
-        // Process the response headers.
-        std::string header;
-        while (std::getline(response_stream, header) && header != "\r")
-          ;
-          //std::cout << "HDR: " << header << "\n";
-
-        // Write whatever content we already have to output.
-        if (response.size() > 0)
-          os << &response;
-
-        // Read until EOF, writing data to output as we go.
-        while (boost::asio::read(socket, response, boost::asio::transfer_at_least(1), error))
-          os << &response;
-        if (error != boost::asio::error::eof)
-          throw boost::system::system_error(error);
+        request_type rq;
+        rq.verb = "GET";
+        rq.add_default_headers();
+        client c;
+        response_type rs = c.execute(server, protocol, path, rq);
+        os << rs.payload;
+        return true;
       } catch (std::exception& e) {
         error_msg = std::string("Exception: ") + e.what();
         return false;
       }
-      return true;
     }
   };

modules/NSCAClient/NSCAClient.cpp

@@ -422 +422 @@
     }
     client.shutdown();
-/*
-    boost::asio::io_service io_service;
-    nsca::socket socket(io_service);
-    socket.connect(data.host, data.port);
-    if (!socket.recv_iv(data.password, data.get_encryption(), boost::posix_time::seconds(data.timeout<5?30:data.timeout))) {
-      NSC_LOG_ERROR_STD(_T("Failed to read iv"));
-      return NSCAPI::hasFailed;
-    }
-    NSC_DEBUG_MSG_STD(_T("Got IV sending packets: ") + strEx::itos(packets.size()));
-    BOOST_FOREACH(const nsca::packet &packet, packets) {
-      NSC_DEBUG_MSG_STD(_T("Sending (data): ") + utf8::cvt<std::wstring>(packet.to_string()));
-      socket.send_nsca(packet, boost::posix_time::seconds(data.timeout));
-    }
-    socket.shutdown();
-    */
     return boost::make_tuple(NSCAPI::returnUNKNOWN, _T(""));
   } catch (const nsca::nsca_encrypt::encryption_exception &e) {

modules/NSCAClient/NSCAClient.h

@@ -86 +86 @@
     std::string password;
     std::string encryption;
-    std::string host, port;
+    std::string host;
+    std::string port;
     std::string sender_hostname;
     int timeout;
@@ -92 +93 @@
     int time_delta;
 
-    connection_data(nscapi::protobuf::types::destination_container recipient, nscapi::protobuf::types::destination_container target, nscapi::protobuf::types::destination_container sender) {
-      recipient.import(target);
-      timeout = recipient.get_int_data("timeout", 30);
-      buffer_length = recipient.get_int_data("payload length", 512);
-      password = recipient.get_string_data("password");
-      encryption = recipient.get_string_data("encryption");
-      std::string tmp = recipient.get_string_data("time offset");
+    connection_data(nscapi::protobuf::types::destination_container arguments, nscapi::protobuf::types::destination_container target, nscapi::protobuf::types::destination_container sender) {
+      arguments.import(target);
+      timeout = arguments.get_int_data("timeout", 30);
+      buffer_length = arguments.get_int_data("payload length", 512);
+      password = arguments.get_string_data("password");
+      encryption = arguments.get_string_data("encryption");
+      std::string tmp = arguments.get_string_data("time offset");
       if (!tmp.empty())
-        time_delta = strEx::stol_as_time_sec(recipient.get_string_data("time offset"));
+        time_delta = strEx::stol_as_time_sec(arguments.get_string_data("time offset"));
       else
         time_delta = 0;
-      host = recipient.address.get_host();
-      port = strEx::s::xtos(recipient.address.get_port(5667));
+      host = arguments.address.get_host();
+      port = strEx::s::xtos(arguments.address.get_port(5667));
       sender_hostname = sender.address.host;
       if (sender.has_data("host"))
@@ -113 +114 @@
     }
 
-    std::wstring to_wstring() {
-      std::wstringstream ss;
-      ss << _T("host: ") << utf8::cvt<std::wstring>(host);
-      ss << _T(", port: ") << utf8::cvt<std::wstring>(port);
-      ss << _T(", timeout: ") << timeout;
-      ss << _T(", buffer_length: ") << buffer_length;
-      ss << _T(", time_delta: ") << time_delta;
-      ss << _T(", password: ") << utf8::cvt<std::wstring>(password);
-      ss << _T(", encryption: ") << utf8::cvt<std::wstring>(encryption);
+    std::wstring to_wstring() const {
+      return utf8::cvt<std::wstring>(to_string());
+    }
+
+    std::string to_string() const {
+      std::stringstream ss;
+      ss << "host: " << host;
+      ss << ", port: " << port;
+      ss << ", timeout: " << timeout;
+      ss << ", buffer_length: " << buffer_length;
+      ss << ", time_delta: " << time_delta;
+      ss << ", password: " << password;
+      ss << ", encryption: " << encryption;
       return ss.str();
     }
@@ -158 +163 @@
   */
   static std::wstring getModuleName() {
-#ifdef HAVE_LIBCRYPTOPP
     return _T("NSCAClient");
-#else
-    return _T("NSCAClient (without encryption support)");
-#endif
   }
   /**
@@ -173 +174 @@
   }
   static std::wstring getModuleDescription() {
-    return std::wstring(_T("Passive check support (needs NSCA on nagios server).\nAvalible crypto are: ")) + getCryptos();
+    return std::wstring(_T("Passive check support over NSCA.\nAvalible crypto are: ")) + getCryptos();
   }
 

modules/NSCPServer/CMakeLists.txt

@@ -51 +51 @@
 
 INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake)
+SOURCE_GROUP("Socket" REGULAR_EXPRESSION .*include/socket/.*)
 SOURCE_GROUP("Server" REGULAR_EXPRESSION .*include/nscp/.*)