Changeset 5735dda in nscp for modules/NRPEClient

Timestamp:

06/13/10 22:02:07 (3 years ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

f0607c4

Parents:

5cd6bcf (diff), f1d6990 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merged back all (some?) of the new changes from 0.3.8

Location:

modules/NRPEClient

Files:

• NRPEClient.h (modified) (1 diff)
• CMakeLists.txt (added)
• Jamfile (deleted)
• NRPEClient-2005.vcproj (deleted)
• NRPEClient.cpp (modified) (8 diffs)
• NRPEClient.def (modified) (1 diff)
• stdafx.h (modified) (1 diff)

modules/NRPEClient/NRPEClient.h

@@ -110 +110 @@
   std::wstring getModuleDescription() {
     return _T("A simple client for checking remote NRPE servers (think proxy).\n")
+#ifndef USE_BOOST
+    _T("BOOST support is missing (this is probably very bad)!\n")
+#endif
 #ifndef USE_SSL
     _T("SSL support is missing (so you cant use encryption)!")

modules/NRPEClient/NRPEClient.cpp

@@ -25 +25 @@
 #include <config.h>
 #include <msvc_wrappers.h>
-#include <execute_process.hpp>
-#ifdef USE_BOOST
-#include <program_options_ex.hpp>
-#endif
+//#include <execute_process.hpp>
 #include <strEx.h>
+#include <boost/filesystem.hpp>
+#include <strEx.h>
+#include <nrpe/nrpe_socket.hpp>
+
 
 NRPEClient gNRPEClient;
 
-BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
-{
-  NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
-  return TRUE;
-}
-
-NRPEClient::NRPEClient() : buffer_length_(0), bInitSSL(false) {
+NRPEClient::NRPEClient() : buffer_length_(0) {
 }
 
@@ -45 +40 @@
 }
 
-bool NRPEClient::loadModule() {
-  buffer_length_ = NSCModuleHelper::getSettingsInt(NRPE_SECTION_TITLE, NRPE_SETTINGS_STRLEN, NRPE_SETTINGS_STRLEN_DEFAULT);
-
-  std::list<std::wstring> commands = NSCModuleHelper::getSettingsSection(NRPE_CLIENT_HANDLER_SECTION_TITLE);
-  NSC_DEBUG_MSG_STD(_T("humm..."));
+bool NRPEClient::loadModule(NSCAPI::moduleLoadMode mode) {
+  std::list<std::wstring> commands;
+  buffer_length_ = SETTINGS_GET_INT(nrpe::PAYLOAD_LENGTH);
+  try {
+    SETTINGS_REG_PATH(nrpe::CH_SECTION);
+    commands = GET_CORE()->getSettingsSection(setting_keys::nrpe::CH_SECTION_PATH);
+  } catch (nscapi::nscapi_exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_);
+  } catch (...) {
+    NSC_LOG_ERROR_STD(_T("Failed to register command."));
+  }
+
+  boost::filesystem::wpath p = GET_CORE()->getBasePath() + std::wstring(_T("security/nrpe_dh_512.pem"));
+  cert_ = p.string();
+  if (boost::filesystem::is_regular(p)) {
+    NSC_DEBUG_MSG_STD(_T("Using certificate: ") + cert_);
+  } else {
+    NSC_LOG_ERROR_STD(_T("Certificate not found: ") + cert_);
+  }
+
+
   for (std::list<std::wstring>::const_iterator it = commands.begin(); it != commands.end(); ++it) {
     NSC_DEBUG_MSG_STD(*it);
-    std::wstring s = NSCModuleHelper::getSettingsString(NRPE_CLIENT_HANDLER_SECTION_TITLE, (*it), _T(""));
+    std::wstring s = GET_CORE()->getSettingsString(setting_keys::nrpe::CH_SECTION_PATH, (*it), _T(""));
     if (s.empty()) {
       NSC_LOG_ERROR_STD(_T("Invalid NRPE-client entry: ") + (*it));
@@ -61 +72 @@
   return true;
 }
-void NRPEClient::initSSL() {
-  if (bInitSSL)
-    return;
-#ifdef USE_SSL
-  simpleSSL::SSL_init();
-#endif
-  bInitSSL = true;
-}
+
+void NRPEClient::add_options(po::options_description &desc, nrpe_connection_data &command_data) {
+  desc.add_options()
+    ("help,h", "Show this help message.")
+    ("host,H", po::wvalue<std::wstring>(&command_data.host), "The address of the host running the NRPE daemon")
+    ("port,p", po::value<int>(&command_data.port), "The port on which the daemon is running (default=5666)")
+    ("command,c", po::wvalue<std::wstring>(&command_data.command), "The name of the command that the remote daemon should run")
+    ("timeout,t", po::value<int>(&command_data.timeout), "Number of seconds before connection times out (default=10)")
+    ("buffer-length,l", po::value<unsigned int>(&command_data.buffer_length), std::string("Length of payload (has to be same as on the server (default=" + to_string(buffer_length_) + ")").c_str())
+    ("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 plaintext.")
+    ("arguments,a", po::wvalue<std::vector<std::wstring> >(&command_data.argument_vector), "list of arguments")
+    ;
+}
+
 
 void NRPEClient::addCommand(strEx::blindstr key, std::wstring args) {
@@ -75 +92 @@
 #else
   try {
-    boost::program_options::options_description desc = get_optionDesc();
-    boost::program_options::positional_options_description p = get_optionsPositional();
-
+
+    NRPEClient::nrpe_connection_data command_data;
     boost::program_options::variables_map vm;
-    boost::program_options::store(
-      basic_command_line_parser_ex<TCHAR>(args).options(desc).positional(p).run()
-      , vm);
-    boost::program_options::notify(vm); 
-    nrpe_connection_data cd = get_ConectionData(vm);
-    NSC_DEBUG_MSG_STD(_T("Added NRPE Client: ") + key.c_str() + _T(" = ") + cd.toString());
-    commands[key] = cd;
+
+    po::options_description desc("Allowed options");
+    buffer_length_ = SETTINGS_GET_INT(nrpe::PAYLOAD_LENGTH);
+    add_options(desc, command_data);
+
+    po::positional_options_description p;
+    p.add("arguments", -1);
+
+    std::vector<std::wstring> list;
+    //explicit escaped_list_separator(Char e = '\\', Char c = ',',Char q = '\"')
+    boost::escaped_list_separator<wchar_t> sep(L'\\', L' ', L'\"');
+    typedef boost::tokenizer<boost::escaped_list_separator<wchar_t>,std::wstring::const_iterator, std::wstring > tokenizer_t;
+    tokenizer_t tok(args, sep);
+    for(tokenizer_t::iterator beg=tok.begin(); beg!=tok.end();++beg){
+      list.push_back(*beg);
+    }
+
+    po::wparsed_options parsed = po::basic_command_line_parser<wchar_t>(list).options(desc).positional(p).run();
+    po::store(parsed, vm);
+    po::notify(vm);
+    command_data.parse_arguments();
+
+    NSC_DEBUG_MSG_STD(_T("Added NRPE Client: ") + key.c_str() + _T(" = ") + command_data.toString());
+    commands[key] = command_data;
+
+    NSCModuleHelper::registerCommand(key.c_str(), command_data.toString());
+
   } catch (boost::program_options::validation_error &e) {
     NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str() + strEx::string_to_wstring(e.what()));
@@ -104 +140 @@
   return false;
 }
-NSCAPI::nagiosReturn NRPEClient::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf)
+NSCAPI::nagiosReturn NRPEClient::handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf)
 {
-  command_list::const_iterator cit = commands.find(command);
+  command_list::const_iterator cit = commands.find(strEx::blindstr(command.c_str()));
   if (cit == commands.end())
     return NSCAPI::returnIgnored;
 
   std::wstring args = (*cit).second.arguments;
-  if (NSCModuleHelper::getSettingsInt(NRPE_SECTION_TITLE, NRPE_SETTINGS_ALLOW_ARGUMENTS, NRPE_SETTINGS_ALLOW_ARGUMENTS_DEFAULT) == 1) {
-    arrayBuffer::arrayList arr = arrayBuffer::arrayBuffer2list(argLen, char_args);
-    arrayBuffer::arrayList::const_iterator cit2 = arr.begin();
+  if (SETTINGS_GET_BOOL(nrpe::ALLOW_ARGS) == 1) {
     int i=1;
-
-    for (;cit2!=arr.end();cit2++,i++) {
-      if (NSCModuleHelper::getSettingsInt(NRPE_SECTION_TITLE, NRPE_SETTINGS_ALLOW_NASTY_META, NRPE_SETTINGS_ALLOW_NASTY_META_DEFAULT) == 0) {
-        if ((*cit2).find_first_of(NASTY_METACHARS) != std::wstring::npos) {
+    BOOST_FOREACH(std::wstring arg, arguments)
+    {
+      if (SETTINGS_GET_INT(nrpe::ALLOW_NASTY) == 0) {
+        if (arg.find_first_of(NASTY_METACHARS) != std::wstring::npos) {
           NSC_LOG_ERROR(_T("Request string contained illegal metachars!"));
           return NSCAPI::returnIgnored;
         }
       }
-      strEx::replace(args, _T("$ARG") + strEx::itos(i) + _T("$"), (*cit2));
+      strEx::replace(args, _T("$ARG") + strEx::itos(i++) + _T("$"), arg);
     }
   }
@@ -133 +167 @@
 }
 
-#ifdef USE_BOOST
-boost::program_options::options_description NRPEClient::get_optionDesc() {
-  boost::program_options::options_description desc("Allowed options");
-  buffer_length_ = NSCModuleHelper::getSettingsInt(NRPE_SECTION_TITLE, NRPE_SETTINGS_STRLEN, NRPE_SETTINGS_STRLEN_DEFAULT);
-  desc.add_options()
-    ("help,h", "Show this help message.")
-    ("host,H", boost::program_options::wvalue<std::wstring>(), "The address of the host running the NRPE daemon")
-    ("port,p", boost::program_options::value<int>(), "The port on which the daemon is running (default=5666)")
-    ("command,c", boost::program_options::wvalue<std::wstring>(), "The name of the command that the remote daemon should run")
-    ("timeout,t", boost::program_options::value<int>(), "Number of seconds before connection times out (default=10)")
-    ("buffer-length,l", boost::program_options::value<int>(), std::string("Length of payload (has to be same as on the server (default=" + strEx::s::itos(buffer_length_) + ")").c_str())
-    ("no-ssl,n", "Do not initial an ssl handshake with the server, talk in plaintext.")
-    ("arguments,a", boost::program_options::wvalue<std::vector<std::wstring>>(), "list of arguments")
-    ;
-  return desc;
-}
-boost::program_options::positional_options_description NRPEClient::get_optionsPositional() {
-  boost::program_options::positional_options_description p;
-  p.add("arguments", -1);
-  return p;
-}
-NRPEClient::nrpe_connection_data NRPEClient::get_ConectionData(boost::program_options::variables_map &vm) {
-  nrpe_connection_data ret(buffer_length_);
-  if (vm.count("host"))
-    ret.host = vm["host"].as<std::wstring>();
-  if (vm.count("port"))
-    ret.port = vm["port"].as<int>();
-  if (vm.count("timeout"))
-    ret.timeout = vm["timeout"].as<int>();
-  if (vm.count("buffer-length"))
-    ret.buffer_length = vm["buffer-length"].as<int>();
-  if (vm.count("command"))
-    ret.command = vm["command"].as<std::wstring>();
-  if (vm.count("arguments")) {
-    std::vector<std::wstring> v = vm["arguments"].as<std::vector<std::wstring>>();
-    for (std::vector<std::wstring>::const_iterator cit = v.begin(); cit != v.end(); ++cit) {
-      if (!ret.arguments.empty())
-        ret.arguments += _T("!");
-      ret.arguments += *cit;
-    }
-  }
-  if (vm.count("no-ssl"))
-    ret.ssl = false;
-  return ret;
-}
-#endif
-int NRPEClient::commandLineExec(const TCHAR* command, const unsigned int argLen, TCHAR** args) {
-#ifndef USE_BOOST
-  NSC_LOG_ERROR_STD(_T("Could not execute ") + std::wstring(command) + _T(" boost not avalible!"));
-  return NSCAPI::returnUNKNOWN;
-#else
-  try {
-    boost::program_options::options_description desc = get_optionDesc();
-    boost::program_options::positional_options_description p = get_optionsPositional();
-    
+int NRPEClient::commandLineExec(const unsigned int argLen, TCHAR** args) {
+  try {
+
+    NRPEClient::nrpe_connection_data command_data;
     boost::program_options::variables_map vm;
-    boost::program_options::store(
-      basic_command_line_parser_ex<TCHAR>(command, argLen, args).options(desc).positional(p).run()
-      , vm);
-    boost::program_options::notify(vm);    
+
+    po::options_description desc("Allowed options");
+    buffer_length_ = SETTINGS_GET_INT(nrpe::PAYLOAD_LENGTH);
+    add_options(desc, command_data);
+
+    po::positional_options_description p;
+    p.add("arguments", -1);
+    po::wparsed_options parsed = basic_command_line_parser_ex<wchar_t>(argLen, args).options(desc).positional(p).run();
+    po::store(parsed, vm);
+    po::notify(vm);
+    command_data.parse_arguments();
 
     if (vm.count("help")) {
@@ -198 +188 @@
       return 1;
     }
-
-    NRPEClient::nrpe_connection_data command = get_ConectionData(vm);
-    nrpe_result_data result = execute_nrpe_command(command, command.arguments);
+    nrpe_result_data result = execute_nrpe_command(command_data, command_data.arguments);
     std::wcout << result.text << std::endl;
     return result.result;
@@ -209 +197 @@
   }
   return NSCAPI::returnUNKNOWN;
-#endif
 }
 NRPEClient::nrpe_result_data NRPEClient::execute_nrpe_command(nrpe_connection_data con, std::wstring arguments) {
   try {
-    NRPEPacket packet;
-    if (con.ssl) {
+    nrpe::packet packet;
+    if (!con.no_ssl) {
 #ifdef USE_SSL
-      packet = send_ssl(con.host, con.port, con.timeout, NRPEPacket::make_request(con.get_cli(arguments), con.buffer_length));
+      packet = send_ssl(con.host, con.port, con.timeout, nrpe::packet::make_request(con.get_cli(arguments), con.buffer_length));
 #else
       return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("SSL support not available (compiled without USE_SSL)!"));
 #endif
     } else
-      packet = send_nossl(con.host, con.port, con.timeout, NRPEPacket::make_request(con.get_cli(arguments), con.buffer_length));
+      packet = send_nossl(con.host, con.port, con.timeout, nrpe::packet::make_request(con.get_cli(arguments), con.buffer_length));
     return nrpe_result_data(packet.getResult(), packet.getPayload());
-  } catch (NRPEPacket::NRPEPacketException &e) {
+  } catch (nrpe::nrpe_packet_exception &e) {
     return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("NRPE Packet errro: ") + e.getMessage());
-  } catch (simpleSocket::SocketException &e) {
-    return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("Socket error: ") + e.getMessage());
+  } catch (std::runtime_error &e) {
+    return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("Socket error: ") + boost::lexical_cast<std::wstring>(e.what()));
+  } catch (...) {
+    return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("Unknown error -- REPORT THIS!"));
+  }
+}
+
+
 #ifdef USE_SSL
-  } catch (simpleSSL::SSLException &e) {
-    return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("SSL Socket error: ") + e.getMessage());
+nrpe::packet NRPEClient::send_ssl(std::wstring host, int port, int timeout, nrpe::packet packet) {
+  boost::asio::io_service io_service;
+  boost::asio::ssl::context ctx(io_service, boost::asio::ssl::context::sslv23);
+  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);
+  nrpe::ssl_socket socket(io_service, ctx, host, port);
+  socket.send(packet, boost::posix_time::seconds(timeout));
+  return socket.recv(packet, boost::posix_time::seconds(timeout));
+}
 #endif
-  } catch (...) {
-    return nrpe_result_data(NSCAPI::returnUNKNOWN, _T("Unknown error -- REPORT THIS!"));
-  }
-}
-NRPEPacket NRPEClient::send_ssl(std::wstring host, int port, int timeout, NRPEPacket packet)
-{
-#ifndef USE_SSL
-  return send_nossl(host, port, timeout, packet);
-#else
-  initSSL();
-  simpleSSL::Socket socket(true);
-  socket.connect(host, port);
-  NSC_DEBUG_MSG_STD(_T(">>>length: ") + strEx::itos(packet.getBufferLength()));
-  socket.sendAll(packet.getBuffer(), packet.getBufferLength());
-  simpleSocket::DataBuffer buffer;
-  socket.readAll(buffer, packet.getBufferLength());
-  NSC_DEBUG_MSG_STD(_T("<<<length: ") + strEx::itos(buffer.getLength()));
-  packet.readFrom(buffer.getBuffer(), buffer.getLength());
-  return packet;
-#endif
-}
+
+nrpe::packet NRPEClient::send_nossl(std::wstring host, int port, int timeout, nrpe::packet packet) {
+  boost::asio::io_service io_service;
+  nrpe::socket socket(io_service, host, port);
+  socket.send(packet, boost::posix_time::seconds(timeout));
+  return socket.recv(packet, boost::posix_time::seconds(timeout));
+}
+
+/*
 NRPEPacket NRPEClient::send_nossl(std::wstring host, int port, int timeout, NRPEPacket packet)
 {
-  simpleSocket::Socket socket(true);
-  socket.connect(host, port);
-  socket.sendAll(packet.getBuffer(), packet.getBufferLength());
-  simpleSocket::DataBuffer buffer;
-  socket.readAll(buffer);
-  packet.readFrom(buffer.getBuffer(), buffer.getLength());
-  return packet;
-}
-
-
-
-
-
-
+  unsigned char dh512_p[] = {
+    0xCF, 0xFF, 0x65, 0xC2, 0xC8, 0xB4, 0xD2, 0x68, 0x8C, 0xC1, 0x80, 0xB1,
+    0x7B, 0xD6, 0xE8, 0xB3, 0x62, 0x59, 0x62, 0xED, 0xA7, 0x45, 0x6A, 0xF8,
+    0xE9, 0xD8, 0xBE, 0x3F, 0x38, 0x42, 0x5F, 0xB2, 0xA5, 0x36, 0x03, 0xD3,
+    0x06, 0x27, 0x81, 0xC8, 0x9B, 0x88, 0x50, 0x3B, 0x82, 0x3D, 0x31, 0x45,
+    0x2C, 0xB4, 0xC5, 0xA5, 0xBE, 0x6A, 0xE3, 0x2E, 0xA6, 0x86, 0xFD, 0x6A,
+    0x7E, 0x1E, 0x6A, 0x73,
+  };
+  unsigned char dh512_g[] = { 0x02, };
+
+  DH *dh_2 = DH_new();
+  dh_2->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
+  dh_2->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
+
+  FILE *outfile = fopen("d:\\nrpe_512.pem", "w");
+  PEM_write_DHparams(outfile, dh_2);
+  PEM_write_DHparams(stdout, dh_2);
+  fclose(outfile);
+
+  nrpe_socket socket(host, port);
+  socket.send(packet, boost::posix_time::seconds(timeout));
+  return socket.recv(packet, boost::posix_time::seconds(timeout));
+}
+*/
+
+
+
+
+
+NSC_WRAP_DLL();
 NSC_WRAPPERS_MAIN_DEF(gNRPEClient);
 NSC_WRAPPERS_IGNORE_MSG_DEF();
 NSC_WRAPPERS_HANDLE_CMD_DEF(gNRPEClient);
-NSC_WRAPPERS_HANDLE_CONFIGURATION(gNRPEClient);
 NSC_WRAPPERS_CLI_DEF(gNRPEClient);
 
-
-MODULE_SETTINGS_START(NRPEClient, _T("NRPE Listener configuration"), _T("...")) 
-
-PAGE(_T("NRPE Listsner configuration")) 
-
-ITEM_EDIT_TEXT(_T("port"), _T("This is the port the NRPEClient.dll will listen to.")) 
-ITEM_MAP_TO(_T("basic_ini_text_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("port")) 
-OPTION(_T("default"), _T("5666")) 
-ITEM_END()
-
-ITEM_CHECK_BOOL(_T("allow_arguments"), _T("This option determines whether or not the NRPE daemon will allow clients to specify arguments to commands that are executed.")) 
-ITEM_MAP_TO(_T("basic_ini_bool_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("allow_arguments")) 
-OPTION(_T("default"), _T("false")) 
-OPTION(_T("true_value"), _T("1")) 
-OPTION(_T("false_value"), _T("0")) 
-ITEM_END()
-
-ITEM_CHECK_BOOL(_T("allow_nasty_meta_chars"), _T("This might have security implications (depending on what you do with the options)")) 
-ITEM_MAP_TO(_T("basic_ini_bool_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("allow_nasty_meta_chars")) 
-OPTION(_T("default"), _T("false")) 
-OPTION(_T("true_value"), _T("1")) 
-OPTION(_T("false_value"), _T("0")) 
-ITEM_END()
-
-ITEM_CHECK_BOOL(_T("use_ssl"), _T("This option will enable SSL encryption on the NRPE data socket (this increases security somwhat.")) 
-ITEM_MAP_TO(_T("basic_ini_bool_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("use_ssl")) 
-OPTION(_T("default"), _T("true")) 
-OPTION(_T("true_value"), _T("1")) 
-OPTION(_T("false_value"), _T("0")) 
-ITEM_END()
-
-PAGE_END()
-ADVANCED_PAGE(_T("Access configuration")) 
-
-ITEM_EDIT_OPTIONAL_LIST(_T("Allow connection from:"), _T("This is the hosts that will be allowed to poll performance data from the NRPE server.")) 
-OPTION(_T("disabledCaption"), _T("Use global settings (defined previously)")) 
-OPTION(_T("enabledCaption"), _T("Specify hosts for NRPE server")) 
-OPTION(_T("listCaption"), _T("Add all IP addresses (not hosts) which should be able to connect:")) 
-OPTION(_T("separator"), _T(",")) 
-OPTION(_T("disabled"), _T("")) 
-ITEM_MAP_TO(_T("basic_ini_text_mapper")) 
-OPTION(_T("section"), _T("NRPE")) 
-OPTION(_T("key"), _T("allowed_hosts")) 
-OPTION(_T("default"), _T("")) 
-ITEM_END()
-
-PAGE_END()
-MODULE_SETTINGS_END()

modules/NRPEClient/NRPEClient.def

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

modules/NRPEClient/stdafx.h

@@ -21 +21 @@
 #pragma once
 
-#define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers
-// Windows Header Files:
-#include <windows.h>
-
 #include <string>
 #include <functional>
 
+#include <boost/array.hpp>
+#include <boost/optional.hpp>
+#include <boost/bind.hpp>
+#include <program_options_ex.hpp>
+
+#include <boost/asio.hpp>
+#ifdef USE_SSL
+#include <boost/asio/ssl.hpp>
+#endif
+
+
 #include <config.h>
 #include <utils.h>
+#include <types.hpp>
 
 #include <NSCAPI.h>
-#include <NSCHelper.h>
+#include <nscapi/plugin.hpp>
+namespace po = boost::program_options;
 
-#ifdef MEMCHECK
-#include <vld.h>
-#endif
+