Changeset 2018659 in nscp


Ignore:
Timestamp:
01/31/10 11:45:02 (3 years ago)
Author:
Michael Medin <michael@…>
Branches:
master, 0.4.0, 0.4.1, 0.4.2
Children:
920626f
Parents:
c4d4219
Message:

Added protocol buffers for internal channels (only command as of now) this means this builds lacks "performance data" (as it has yet to be re-added) as well as requires changes to plugins as the API is NEW!

Files:
3 added
27 edited

Legend:

Unmodified
Added
Removed

  • CMakeLists.txt

    r9b3f53c r2018659  
    2626 
    2727SET(NSCP_INCLUDE_PATH "${NSCP_SOURCE_DIR}/include" CACHE PATH "directory containing NSCP specific includes") 
     28SET(PBUF_INCLUDE_PATH "${NSCP_SOURCE_DIR}/proto" CACHE PATH "directory containing NSCP specific protocol buffer files") 
    2829INCLUDE_DIRECTORIES(${NSCP_INCLUDE_PATH}) 
     30INCLUDE_DIRECTORIES(${PBUF_INCLUDE_PATH}) 
    2931 
    3032SET(BOOST_LIBRARYDIR ${BOOST_LIBRARYDIR} CACHE PATH "") 
    … …  
    8284endif(Boost_FOUND) 
    8385 
     86INCLUDE(cmake/NSCPPBuffer.cmake) 
     87 
     88if(PROTOBUF_FOUND) 
     89  message(STATUS, "Found proto in: ${PROTOBUF_LIBRARY}") 
     90  INCLUDE_DIRECTORIES(${PROTOBUF_INCLUDE_DIR}) 
     91  #LINK_DIRECTORIES(${BOOST_LIB_DIRS}) 
     92else(PROTOBUF_FOUND) 
     93  message(FATAL_ERROR, "Protocol buffers NOT found (${PROTOBUF_LIBRARYDIR}, )") 
     94endif(PROTOBUF_FOUND) 
     95 
     96 
    8497#INCLUDE(cmake/WtFindAsio.txt) 
    8598#INCLUDE(cmake/WtFindSsl.txt) 
    8699#INCLUDE(cmake/FindICU.cmake) 
    87  
    88100 
    89101 
    … …  
    135147ENDIF(NOT CMAKE_BUILD_TYPE) 
    136148 
     149 
     150SET(NSCP_DEF_PLUGIN_CPP 
     151  ${NSCP_INCLUDE_PATH}/NSCHelper.cpp 
     152  ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp 
     153  ${NSCP_INCLUDE_PATH}/simpleini/ConvertUTF.c 
     154  ${NSCP_INCLUDE_PATH}/b64/b64.c 
     155  ${PBUF_INCLUDE_PATH}/plugin.pb.cc 
     156  ${NSCP_INCLUDE_PATH}/utils.cpp 
     157  ) 
     158 
     159SET(NSCP_DEF_PLUGIN_HPP 
     160    ${PBUF_INCLUDE_PATH}/plugin.pb.h 
     161    ${NSCP_INCLUDE_PATH}/NSCHelper.h 
     162    ${NSCP_INCLUDE_PATH}/strEx.h 
     163    ${NSCP_INCLUDE_PATH}/config.h 
     164    ${NSCP_INCLUDE_PATH}/utils.h 
     165    ${NSCP_INCLUDE_PATH}/NSCAPI.h 
     166    ${NSCP_INCLUDE_PATH}/NSCHelper.h 
     167    ${NSCP_INCLUDE_PATH}/nsc_module_wrapper.hpp 
     168  ) 
     169 
     170SET(NSCP_DEF_PLUGIN_LIB 
     171    ${Boost_LIBRARIES} 
     172    ${CMAKE_THREAD_LIBS_INIT} 
     173    ${EXTRA_LIBS} 
     174    ${PROTOBUF_LIBRARY} 
     175  ) 
     176 
     177 
    137178# Compile time constants & make sure our build finds it 
    138179CONFIGURE_FILE( 

  • build.cmake

    r79e734f r2018659  
    1212SET(OPENSSL_INCLUDE_DIR c:/src/include/) 
    1313SET(CMAKE_LIBRARY_PATH c:/src/lib/x86/) 
     14 
     15SET(PROTOBUF_INCLUDE_DIR d:/source/protobuf-2.3.0/src) 
     16SET(PROTOBUF_LIBRARYDIR d:/source/protobuf-2.3.0/vsprojects/Debug) 
     17SET(PROTOBUF_BINARYDIR d:/source/protobuf-2.3.0/vsprojects/Debug) 
     18 

  • changelog

    r5da0459 r2018659  
    66 * Fixa dependonservice LanManWorkStation (old win) 
    77 * Fix RtlStringFromGUID problem on NT4 
    8  
     8  
     92010-01-31 MickeM 
     10 + Added google protocol buffers 
     11 ! Changed internal handle command logic (now uses protocol buffers) 
     12 - Removed (temporarily) performance data (due to protocol buffer changes) 
     13 
     142010-01-19 MickeM 
     15 + Rename NRPEListener to NRPEServer 
     16 + Added NRPEServer to CMake build 
     17 
     182010-01-xx MickeM 
     19 + Added Scheduling module 
     20  
    9212009-10-11 MickeM 
    1022 + Added argument support to NRPE Client 

  • include/NSCHelper.cpp

    r50a5db2 r2018659  
    2828#include <strEx.h> 
    2929 
     30#include <boost/foreach.hpp> 
     31#include <boost/tokenizer.hpp> 
     32 
    3033#ifdef DEBUG 
    3134/** 
    … …  
    205208  lpNSAPIExit fNSAPIExit = NULL; 
    206209  lpNSAPIInject fNSAPIInject = NULL; 
     210  lpNSAPIDestroyBuffer fNSAPIDestroyBuffer = NULL; 
    207211  lpNSAPINotify fNSAPINotify = NULL; 
    208212  lpNSAPICheckLogMessages fNSAPICheckLogMessages = NULL; 
    … …  
    274278 * @return The returned status of the command 
    275279 */ 
    276 NSCAPI::nagiosReturn NSCModuleHelper::InjectCommandRAW(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen)  
     280NSCAPI::nagiosReturn NSCModuleHelper::InjectCommandRAW(const wchar_t* command, const char *request, const unsigned int request_len, char **response, unsigned int *response_len)  
    277281{ 
    278282  if (!fNSAPIInject) 
    279283    throw NSCMHExcpetion(_T("NSCore has not been initiated...")); 
    280   return fNSAPIInject(command, argLen, argument, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
     284  return fNSAPIInject(command, request, request_len, response, response_len); 
     285} 
     286 
     287void NSCModuleHelper::DestroyBuffer(char**buffer) { 
     288  if (!fNSAPIDestroyBuffer) 
     289    throw NSCMHExcpetion(_T("NSCore has not been initiated...")); 
     290  return fNSAPIDestroyBuffer(buffer); 
    281291} 
    282292 
    … …  
    296306 * @return The return of the command 
    297307 */ 
    298 NSCAPI::nagiosReturn NSCModuleHelper::InjectCommand(const wchar_t* command, const unsigned int argLen, wchar_t **argument, std::wstring & message, std::wstring & perf)  
     308/* 
     309NSCAPI::nagiosReturn NSCModuleHelper::InjectSimpleCommand(const wchar_t* command, const unsigned int argLen, wchar_t **argument, std::wstring & message, std::wstring & perf)  
    299310{ 
    300311  if (!fNSAPIInject) 
    … …  
    329340  return retC; 
    330341} 
    331  
     342*/ 
    332343/** 
    333344* Inject a request command in the core (this will then be sent to the plug-in stack for processing) 
    … …  
    339350* @return The return of the command 
    340351*/ 
    341 NSCAPI::nagiosReturn NSCModuleHelper::InjectCommand(const wchar_t* command, std::list<std::wstring> argument, std::wstring & message, std::wstring & perf)  
     352NSCAPI::nagiosReturn NSCModuleHelper::InjectSimpleCommand(const std::wstring command, const std::list<std::wstring> argument, std::wstring & msg, std::wstring & perf)  
    342353{ 
    343354  if (!fNSAPIInject) 
    344355    throw NSCMHExcpetion(_T("NSCore has not been initiated...")); 
    345   unsigned int buf_len = getBufferLength(); 
    346  
    347  
    348   unsigned int argLen; 
    349   wchar_t ** aBuffer = arrayBuffer::list2arrayBuffer(argument, argLen); 
    350   wchar_t *msgBuffer = new wchar_t[buf_len+1]; 
    351   wchar_t *perfBuffer = new wchar_t[buf_len+1]; 
    352   msgBuffer[0] = 0; 
    353   perfBuffer[0] = 0; 
    354   NSCAPI::nagiosReturn retC = InjectCommandRAW(command, argLen, aBuffer, msgBuffer, buf_len, perfBuffer, buf_len); 
    355   arrayBuffer::destroyArrayBuffer(aBuffer, argLen); 
     356 
     357 
     358  PluginCommand::RequestMessage message; 
     359  PluginCommand::Header *hdr = message.mutable_header(); 
     360  hdr->set_type(PluginCommand::Header_Type_REQUEST); 
     361  hdr->set_version(PluginCommand::Header_Version_VERSION_1); 
     362 
     363  PluginCommand::Request *req = message.add_payload(); 
     364  req->set_command(to_string(command)); 
     365  req->set_version(PluginCommand::Request_Version_VERSION_1); 
     366 
     367  BOOST_FOREACH(std::wstring s, argument) 
     368    req->add_arguments(to_string(s)); 
     369 
     370  std::string request; 
     371  message.SerializeToString(&request); 
     372 
     373  char *buffer = NULL; 
     374  unsigned int buffer_size = 0; 
     375 
     376  NSCAPI::nagiosReturn retC = InjectCommandRAW(command.c_str(), request.c_str(), request.size(), &buffer, &buffer_size); 
     377 
     378  if (buffer_size > 0 && buffer != NULL) { 
     379    PluginCommand::ResponseMessage rsp_msg; 
     380    std::string response(buffer, buffer_size); 
     381    rsp_msg.ParseFromString(response); 
     382    if (rsp_msg.payload_size() != 1) { 
     383      NSC_LOG_ERROR_STD(_T("Failed to extract return message not 1 payload: ") + strEx::itos(rsp_msg.payload_size())); 
     384      return NSCAPI::returnUNKNOWN; 
     385    } 
     386    msg = to_wstring(rsp_msg.payload(0).message()); 
     387  } 
     388 
     389  DestroyBuffer(&buffer); 
    356390  switch (retC) { 
    357391    case NSCAPI::returnIgnored: 
    358392      NSC_LOG_MESSAGE_STD(_T("No handler for command '") + command + _T("'.")); 
    359       break; 
    360     case NSCAPI::returnInvalidBufferLen: 
    361       NSC_LOG_ERROR(_T("Inject buffer to small, increase the value of: string_length.")); 
    362393      break; 
    363394    case NSCAPI::returnOK: 
    … …  
    365396    case NSCAPI::returnWARN: 
    366397    case NSCAPI::returnUNKNOWN: 
    367       message = msgBuffer; 
    368       perf = perfBuffer; 
    369398      break; 
    370399    default: 
    371       delete [] msgBuffer; 
    372       delete [] perfBuffer; 
    373400      throw NSCMHExcpetion(_T("Unknown return code when injecting: ") + std::wstring(command)); 
    374401  } 
    375   delete [] msgBuffer; 
    376   delete [] perfBuffer; 
    377402  return retC; 
    378403} 
    … …  
    392417  if (!fNSAPIInject) 
    393418    throw NSCMHExcpetion(_T("NSCore has not been initiated...")); 
    394   unsigned int argLen = 0; 
    395   wchar_t ** aBuffer; 
    396   if (buffer) 
    397     aBuffer= arrayBuffer::split2arrayBuffer(buffer, splitChar, argLen); 
    398   else 
    399     aBuffer= arrayBuffer::createEmptyArrayBuffer(argLen); 
    400   NSCAPI::nagiosReturn ret = InjectCommand(command, argLen, aBuffer, message, perf); 
    401   arrayBuffer::destroyArrayBuffer(aBuffer, argLen); 
    402   return ret; 
     419 
     420  std::wstring args = std::wstring(buffer); 
     421  boost::tokenizer<boost::escaped_list_separator<wchar_t>, std::wstring::const_iterator, std::wstring > tok(args, boost::escaped_list_separator<wchar_t>(L'\\', splitChar, L'\"')); 
     422  std::list<std::wstring> arglist; 
     423  BOOST_FOREACH(wstring s, tok) 
     424    arglist.push_back(s); 
     425  return InjectSimpleCommand(command, arglist, message, perf); 
    403426} 
    404427/** 
    … …  
    416439  if (!fNSAPIInject) 
    417440    throw NSCMHExcpetion(_T("NSCore has not been initiated...")); 
    418   unsigned int argLen = 0; 
    419   wchar_t ** aBuffer; 
    420   if (buffer.empty()) 
    421     aBuffer= arrayBuffer::createEmptyArrayBuffer(argLen); 
    422   else 
    423     aBuffer= arrayBuffer::split2arrayBuffer(buffer, spliwchar_t, argLen, escape); 
    424   NSCAPI::nagiosReturn ret = InjectCommand(command.c_str(), argLen, aBuffer, message, perf); 
    425   arrayBuffer::destroyArrayBuffer(aBuffer, argLen); 
    426   return ret; 
     441  boost::tokenizer<boost::escaped_list_separator<wchar_t>, std::wstring::const_iterator, std::wstring > tok(buffer, boost::escaped_list_separator<wchar_t>(L'\\', spliwchar_t, L'\"')); 
     442  std::list<std::wstring> arglist; 
     443  BOOST_FOREACH(wstring s, tok) 
     444    arglist.push_back(s); 
     445  return InjectSimpleCommand(command.c_str(), arglist, message, perf); 
    427446} 
    428447} 
    … …  
    796815  //NSCModuleHelper::fNSAPIExit = (NSCModuleHelper::lpNSAPIExit)f(_T("NSAPIExit")); 
    797816  NSCModuleHelper::fNSAPIInject = (NSCModuleHelper::lpNSAPIInject)f(_T("NSAPIInject")); 
     817  NSCModuleHelper::fNSAPIDestroyBuffer = (NSCModuleHelper::lpNSAPIDestroyBuffer)f(_T("NSAPIDestroyBuffer")); 
    798818  NSCModuleHelper::fNSAPINotify = (NSCModuleHelper::lpNSAPINotify)f(_T("NSAPINotify")); 
    799819  NSCModuleHelper::fNSAPIGetBasePath = (NSCModuleHelper::lpNSAPIGetBasePath)f(_T("NSAPIGetBasePath")); 
    … …  
    882902 * @return the return code 
    883903 */ 
    884 NSCAPI::nagiosReturn NSCModuleWrapper::wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::wstring retMessage, const std::wstring retPerformance, wchar_t *returnBufferMessage, unsigned int returnBufferMessageLen, wchar_t *returnBufferPerf, unsigned int returnBufferPerfLen) { 
    885   if (retMessage.empty()) 
    886     return NSCAPI::returnIgnored; 
    887   NSCAPI::nagiosReturn ret = NSCHelper::wrapReturnString(returnBufferMessage, returnBufferMessageLen, retMessage, retResult); 
    888   if (!NSCHelper::isMyNagiosReturn(ret)) { 
     904NSCAPI::nagiosReturn NSCModuleWrapper::wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::string &reply, char **reply_buffer, unsigned int *size) { 
     905  // TODO: Make this global to allow remote deletion!!! 
     906  unsigned int buf_len = reply.size(); 
     907  *reply_buffer = new char[buf_len + 10]; 
     908  memcpy(*reply_buffer, reply.c_str(), buf_len+1); 
     909  (*reply_buffer)[buf_len] = 0; 
     910  (*reply_buffer)[buf_len+1] = 0; 
     911  *size = buf_len; 
     912  if (!NSCHelper::isMyNagiosReturn(retResult)) { 
    889913    NSC_LOG_ERROR(_T("A module returned an invalid return code")); 
    890914  } 
    891   return NSCHelper::wrapReturnString(returnBufferPerf, returnBufferPerfLen, retPerformance, ret); 
     915  return retResult; 
    892916} 
    893917 
    … …  
    912936  return NSCAPI::hasFailed; 
    913937} 
    914  
    915  
    916  
     938void NSCModuleWrapper::wrapDeleteBuffer(char**buffer) { 
     939  delete [] *buffer; 
     940} 
     941 
     942 

  • include/NSCHelper.h

    r1bfe6f0 r2018659  
    2929#include <arrayBuffer.h> 
    3030#include <types.hpp> 
     31 
     32#include <unicode_char.hpp> 
     33#include <strEx.h> 
     34 
     35#include "../proto/plugin.pb.h" 
     36 
    3137#ifdef WIN32 
    3238//#include <windows.h> 
    … …  
    129135  typedef NSCAPI::errorReturn (*lpNSAPIStopServer)(void); 
    130136  typedef NSCAPI::errorReturn (*lpNSAPIExit)(void); 
    131   typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const wchar_t*, const unsigned int, wchar_t **, wchar_t *, unsigned int, wchar_t *, unsigned int); 
     137  typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const wchar_t* command, const char *request, const unsigned int request_len, char **response, unsigned int *response_len); 
     138  typedef void (*lpNSAPIDestroyBuffer)(char**); 
    132139 
    133140  typedef NSCAPI::errorReturn (*lpNSAPINotify)(const wchar_t*, const wchar_t*, NSCAPI::nagiosReturn, const wchar_t*, const wchar_t*); 
    … …  
    163170 
    164171  void Message(int msgType, std::wstring file, int line, std::wstring message); 
    165   NSCAPI::nagiosReturn InjectCommandRAW(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen); 
    166   NSCAPI::nagiosReturn InjectCommand(const wchar_t* command, const unsigned int argLen, wchar_t **argument, std::wstring & message, std::wstring & perf); 
    167   NSCAPI::nagiosReturn InjectCommand(const wchar_t* command, std::list<std::wstring> argument, std::wstring & message, std::wstring & perf); 
     172  NSCAPI::nagiosReturn InjectCommandRAW(const wchar_t* command, const char *request, const unsigned int request_len, char **response, unsigned int *response_len); 
     173  void DestroyBuffer(char**buffer); 
     174  NSCAPI::nagiosReturn InjectSimpleCommand(const std::wstring command, const std::list<std::wstring> argument, std::wstring & message, std::wstring & perf); 
    168175  NSCAPI::errorReturn NotifyChannel(std::wstring channel, std::wstring command, NSCAPI::nagiosReturn code, std::wstring message, std::wstring perf); 
    169176  NSCAPI::nagiosReturn InjectSplitAndCommand(const wchar_t* command, wchar_t* buffer, wchar_t splitChar, std::wstring & message, std::wstring & perf); 
    … …  
    187194  void registerCommand(std::wstring command, std::wstring description); 
    188195  unsigned int getBufferLength(); 
     196 
     197 
     198  class SimpleCommand { 
     199 
     200  public: 
     201    NSCAPI::nagiosReturn handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &response) { 
     202 
     203      std::wstring command = char_command; 
     204      PluginCommand::RequestMessage request_message; 
     205      request_message.ParseFromString(request); 
     206 
     207      if (request_message.payload_size() != 1) { 
     208        //NSC_LOG_ERROR_STD(_T("Unsupported payload size: ") + to_wstring(request_message.payload_size())); 
     209        return NSCAPI::returnIgnored; 
     210      } 
     211      ::PluginCommand::Request payload = request_message.payload().Get(0); 
     212      std::list<std::wstring> args; 
     213      for (int i=0;i<payload.arguments_size();i++) { 
     214        args.push_back(to_wstring(payload.arguments(i))); 
     215      } 
     216      std::wstring msg, perf; 
     217      NSCAPI::nagiosReturn ret = handleCommand(command, args, msg, perf); 
     218       
     219      PluginCommand::ResponseMessage response_message; 
     220      ::PluginCommand::Header* hdr = response_message.mutable_header(); 
     221 
     222      hdr->set_type(PluginCommand::Header_Type_RESPONSE); 
     223      hdr->set_version(PluginCommand::Header_Version_VERSION_1); 
     224 
     225      PluginCommand::Response *resp = response_message.add_payload(); 
     226      resp->set_command(to_string(command)); 
     227      resp->set_message(to_string(msg)); 
     228      resp->set_version(PluginCommand::Response_Version_VERSION_1); 
     229      if (ret == NSCAPI::returnOK) 
     230        resp->set_result(PluginCommand::Response_Code_OK); 
     231      else if (ret == NSCAPI::returnWARN) 
     232        resp->set_result(PluginCommand::Response_Code_WARNING); 
     233      else if (ret == NSCAPI::returnCRIT) 
     234        resp->set_result(PluginCommand::Response_Code_CRITCAL); 
     235      else  
     236        resp->set_result(PluginCommand::Response_Code_UNKNOWN); 
     237 
     238      response_message.SerializeToString(&response); 
     239      return ret; 
     240    } 
     241 
     242    virtual NSCAPI::nagiosReturn handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf) = 0; 
     243      //(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) = 0; 
     244    //(const std::wstring command, const std::list<std::wstring> arguments) = 0; 
     245 
     246  }; 
    189247}; 
    190248 

  • include/nsc_module_wrapper.hpp

    r031acbf r2018659  
    2424  NSCAPI::boolReturn wrapHasMessageHandler(bool has); 
    2525  int wrapUnloadModule(bool success); 
    26   NSCAPI::nagiosReturn wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::wstring retMessage, const std::wstring retPerformance, wchar_t *returnBufferMessage, unsigned int returnBufferMessageLen, wchar_t *returnBufferPerf, unsigned int returnBufferPerfLen); 
     26  NSCAPI::nagiosReturn wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::string &reply, char **reply_buffer, unsigned int *size); 
     27  void wrapDeleteBuffer(char**buffer); 
    2728} 
    2829 
    … …  
    3233  extern "C" int NSModuleHelperInit(unsigned int id, NSCModuleHelper::lpNSAPILoader f); \ 
    3334  extern "C" int NSLoadModule(int mode); \ 
     35  extern "C" void NSDeleteBuffer(char**buffer); \ 
    3436  extern "C" int NSGetModuleName(wchar_t* buf, int buflen); \ 
    3537  extern "C" int NSGetModuleDescription(wchar_t* buf, int buflen); \ 
    … …  
    3840  extern "C" NSCAPI::boolReturn NSHasMessageHandler(); \ 
    3941  extern "C" void NSHandleMessage(int msgType, wchar_t* file, int line, wchar_t* message); \ 
    40   extern "C" NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* IN_cmd, const unsigned int IN_argsLen, wchar_t **IN_args, \ 
    41     wchar_t *OUT_retBufMessage, unsigned int IN_retBufMessageLen, wchar_t *OUT_retBufPerf, unsigned int IN_retBufPerfLen); \ 
     42  extern "C" NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* command, const char* request_buffer, const unsigned int request_buffer_len, char** reply_buffer, unsigned int *reply_buffer_len); \ 
    4243  extern "C" int NSUnloadModule(); \ 
    4344  extern "C" int NSGetConfigurationMeta(int IN_retBufLen, wchar_t *OUT_retBuf) 
    … …  
    139140      return NSCAPI::hasFailed; \ 
    140141    } \ 
     142  } \ 
     143  extern void NSDeleteBuffer(char**buffer) { \ 
     144    try { \ 
     145      NSCModuleWrapper::wrapDeleteBuffer(buffer); \ 
     146    } catch (...) { \ 
     147      NSC_LOG_CRITICAL(_T("Unknown exception in: wrapModuleHelperInit(...)")); \ 
     148    } \ 
    141149  } 
    142150#define NSC_WRAPPERS_HANDLE_MSG_DEF(toObject) \ 
    … …  
    160168  extern NSCAPI::boolReturn NSHasMessageHandler() { return NSCAPI::isfalse; } 
    161169#define NSC_WRAPPERS_HANDLE_CMD_DEF(toObject) \ 
    162   extern NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* IN_cmd, const unsigned int IN_argsLen, wchar_t **IN_args, \ 
    163                   wchar_t *OUT_retBufMessage, unsigned int IN_retBufMessageLen, wchar_t *OUT_retBufPerf, unsigned int IN_retBufPerfLen) \ 
     170  extern NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* command, const char* request_buffer, const unsigned int request_buffer_len, char** reply_buffer, unsigned int *reply_buffer_len) \ 
    164171  { \ 
    165172    try { \ 
    166       std::wstring message, perf; \ 
    167       NSCAPI::nagiosReturn retCode = toObject.handleCommand(IN_cmd, IN_argsLen, IN_args, message, perf); \ 
    168       return NSCModuleWrapper::wrapHandleCommand(retCode, message, perf, OUT_retBufMessage, IN_retBufMessageLen, OUT_retBufPerf, IN_retBufPerfLen); \ 
     173      std::string request(request_buffer, request_buffer_len), reply; \ 
     174      NSCAPI::nagiosReturn retCode = (&toObject)->handleRAWCommand(command, request, reply); \ 
     175      return NSCModuleWrapper::wrapHandleCommand(retCode, reply, reply_buffer, reply_buffer_len); \ 
    169176    } catch (...) { \ 
    170177      NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHandleCommand(...)")); \ 

  • include/strEx.h

    r1bfe6f0 r2018659  
    2020***************************************************************************/ 
    2121#pragma once 
    22 #include <unicode_char.hpp> 
     22#include <types.hpp> 
     23 
     24#include <string> 
    2325#include <sstream> 
    2426#include <iomanip> 
    25 #include <string> 
    2627#include <utility> 
    2728#include <list> 
    … …  
    3132#include <locale> 
    3233#include <iostream> 
    33 #include <string> 
     34 
     35#include <unicode_char.hpp> 
     36 
    3437#include <boost/lexical_cast.hpp> 
    3538#include <boost/date_time.hpp> 
    36 #include <boost/lexical_cast.hpp> 
    3739#include <boost/algorithm/string.hpp> 
     40#include <boost/foreach.hpp> 
    3841//#include <boost/date_time/local_time/local_date_time.hpp> 
    3942//#include <boost/date_time/gregorian/conversion.hpp> 
    … …  
    101104      return ss.str(); 
    102105    } 
     106  } 
     107 
     108  inline std::wstring strip_hex(std::wstring str) { 
     109    std::wstring ret; ret.reserve(str.size()); 
     110    BOOST_FOREACH(wchar_t c, str) 
     111    { 
     112      if (c==0||c==7||c==10||c==11||c==12||c==13||c==127) 
     113        ret.push_back(L'?'); 
     114      else 
     115        ret.push_back(c); 
     116    } 
     117    return ret; 
    103118  } 
    104119 

  • modules/CheckHelpers/CMakeLists.txt

    rd05c3f0 r2018659  
    66  stdafx.cpp 
    77  CheckHelpers.cpp 
    8   ${NSCP_INCLUDE_PATH}/NSCHelper.cpp 
    9   ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp 
     8  ${NSCP_DEF_PLUGIN_CPP} 
    109) 
    1110 
    … …  
    1514  SET(CheckHelpers_SRCS ${CheckHelpers_SRCS} 
    1615    stdafx.h 
    17     ${NSCP_INCLUDE_PATH}/strEx.h 
    18     ${NSCP_INCLUDE_PATH}/config.h 
    19     ${NSCP_INCLUDE_PATH}/utils.h 
    20     ${NSCP_INCLUDE_PATH}/NSCAPI.h 
    21     ${NSCP_INCLUDE_PATH}/NSCHelper.h 
    22     ${NSCP_INCLUDE_PATH}/nsc_module_wrapper.hpp 
    2316    CheckHelpers.def 
     17    ${NSCP_DEF_PLUGIN_HPP} 
     18 
    2419  ) 
    2520ENDIF(WIN32) 
    … …  
    2823 
    2924target_link_libraries(CheckHelpers 
    30   ${Boost_FILESYSTEM_LIBRARY} 
    31   ${Boost_LIBRARIES} 
    32   ${CMAKE_THREAD_LIBS_INIT} 
    33   ${EXTRA_LIBS} 
     25  ${Boost_FILESYSTEM_LIBRARY} 
     26  ${NSCP_DEF_PLUGIN_LIB} 
    3427) 
    3528 

  • modules/CheckHelpers/CheckHelpers.cpp

    r50a5db2 r2018659  
    6868  return false; 
    6969} 
    70 NSCAPI::nagiosReturn CheckHelpers::checkSimpleStatus(NSCAPI::nagiosReturn status, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf)  
     70NSCAPI::nagiosReturn CheckHelpers::checkSimpleStatus(NSCAPI::nagiosReturn status, const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf)  
    7171{ 
    7272  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    73   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    74   if (args.empty()) { 
    75     msg = NSCHelper::translateReturn(status) + _T(": Lets pretend everything is going to be ok."); 
     73  if (arguments.empty()) { 
     74    message = NSCHelper::translateReturn(status) + _T(": Lets pretend everything is going to be ok."); 
    7675    return status; 
    7776  } 
    7877  std::list<std::wstring>::const_iterator cit; 
    79   for (cit=args.begin();cit!=args.end();++cit) 
    80     msg += *cit; 
     78  for (cit=arguments.begin();cit!=arguments.end();++cit) 
     79    message += *cit; 
    8180  return status; 
    8281} 
    8382 
    84 NSCAPI::nagiosReturn CheckHelpers::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) { 
    85   if (command == _T("CheckAlwaysOK")) { 
    86     if (argLen < 2) { 
    87       msg = _T("ERROR: Missing arguments."); 
     83NSCAPI::nagiosReturn CheckHelpers::handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf) { 
     84  if (command == _T("CheckVersion")) { 
     85    message = NSCModuleHelper::getApplicationVersionString(); 
     86    return NSCAPI::returnOK; 
     87  } else if (command == _T("CheckAlwaysOK")) { 
     88    if (arguments.size() < 1) { 
     89      message = _T("ERROR: Missing arguments."); 
    8890      return NSCAPI::returnUNKNOWN; 
    8991    } 
    90     NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], msg, perf); 
     92    std::wstring new_command = arguments.front(); arguments.pop_front(); 
     93    NSCModuleHelper::InjectSimpleCommand(new_command, arguments, message, perf); 
    9194    return NSCAPI::returnOK; 
    92   } else if (command == _T("CheckVersion")) { 
    93     msg = NSCModuleHelper::getApplicationVersionString(); 
    94     return NSCAPI::returnOK; 
    95   } else if (command == _T("CheckOK")) { 
    96     return checkSimpleStatus(NSCAPI::returnOK, argLen, char_args, msg, perf); 
    97   } else if (command == _T("check_ok")) { 
    98     return checkSimpleStatus(NSCAPI::returnOK, argLen, char_args, msg, perf); 
    99   } else if (command == _T("CheckWARNING")) { 
    100     return checkSimpleStatus(NSCAPI::returnWARN, argLen, char_args, msg, perf); 
    101   } else if (command == _T("CheckCRITICAL")) { 
    102     return checkSimpleStatus(NSCAPI::returnCRIT, argLen, char_args, msg, perf); 
    10395  } else if (command == _T("CheckAlwaysCRITICAL")) { 
    104     if (argLen < 2) { 
    105       msg = _T("ERROR: Missing arguments."); 
     96    if (arguments.size() < 1) { 
     97      message = _T("ERROR: Missing arguments."); 
    10698      return NSCAPI::returnUNKNOWN; 
    10799    } 
    108     NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], msg, perf); 
     100    std::wstring new_command = arguments.front(); arguments.pop_front(); 
     101    NSCModuleHelper::InjectSimpleCommand(new_command, arguments, message, perf); 
    109102    return NSCAPI::returnCRIT; 
    110103  } else if (command == _T("CheckAlwaysWARNING")) { 
    111     if (argLen < 2) { 
    112       msg = _T("ERROR: Missing arguments."); 
     104    if (arguments.size() < 1) { 
     105      message = _T("ERROR: Missing arguments."); 
    113106      return NSCAPI::returnUNKNOWN; 
    114107    } 
    115     NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], msg, perf); 
     108    std::wstring new_command = arguments.front(); arguments.pop_front(); 
     109    NSCModuleHelper::InjectSimpleCommand(new_command, arguments, message, perf); 
    116110    return NSCAPI::returnWARN; 
     111  } else if (command == _T("CheckOK")) { 
     112    return checkSimpleStatus(NSCAPI::returnOK, arguments, message, perf); 
     113  } else if (command == _T("check_ok")) { 
     114    return checkSimpleStatus(NSCAPI::returnOK, arguments, message, perf); 
     115  } else if (command == _T("CheckWARNING")) { 
     116    return checkSimpleStatus(NSCAPI::returnWARN, arguments, message, perf); 
     117  } else if (command == _T("CheckCRITICAL")) { 
     118    return checkSimpleStatus(NSCAPI::returnCRIT, arguments, message, perf); 
    117119  } else if (command == _T("CheckMultiple")) { 
    118     return checkMultiple(argLen, char_args, msg, perf); 
     120    return checkMultiple(arguments, message, perf); 
    119121  } 
    120122  return NSCAPI::returnIgnored; 
    121123} 
    122 NSCAPI::nagiosReturn CheckHelpers::checkMultiple(const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf)  
     124NSCAPI::nagiosReturn CheckHelpers::checkMultiple(const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf)  
    123125{ 
    124126  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    125   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    126   if (args.empty()) { 
    127     msg = _T("Missing argument(s)."); 
     127  if (arguments.empty()) { 
     128    message = _T("Missing argument(s)."); 
    128129    return NSCAPI::returnCRIT; 
    129130  } 
    … …  
    132133  sub_command currentCommand; 
    133134  std::list<std::wstring>::const_iterator cit; 
    134   for (cit=args.begin();cit!=args.end();++cit) { 
     135  for (cit=arguments.begin();cit!=arguments.end();++cit) { 
    135136    std::wstring arg = *cit; 
    136137    std::pair<std::wstring,std::wstring> p = strEx::split(arg,_T("=")); 
    … …  
    148149  std::list<sub_command>::iterator cit2; 
    149150  for (cit2 = commands.begin(); cit2 != commands.end(); ++cit2) { 
    150     unsigned int length = 0; 
    151     TCHAR ** args = arrayBuffer::list2arrayBuffer((*cit2).second, length); 
     151    std::list<std::wstring> sub_args; 
    152152    std::wstring tMsg, tPerf; 
    153     NSCAPI::nagiosReturn tRet = NSCModuleHelper::InjectCommand((*cit2).first.c_str(), length, args, tMsg, tPerf); 
    154     arrayBuffer::destroyArrayBuffer(args, length); 
     153    NSCAPI::nagiosReturn tRet = NSCModuleHelper::InjectSimpleCommand((*cit2).first.c_str(), (*cit2).second, tMsg, tPerf); 
    155154    returnCode = NSCHelper::maxState(returnCode, tRet); 
    156     if (!msg.empty()) 
    157       msg += _T(", "); 
    158     msg += tMsg; 
     155    if (!message.empty()) 
     156      message += _T(", "); 
     157    message += tMsg; 
    159158    perf += tPerf; 
    160159  } 

  • modules/CheckHelpers/CheckHelpers.def

    re26cfe0 r2018659  
    1212  NSUnloadModule 
    1313  NSGetModuleDescription 
     14  NSDeleteBuffer 

  • modules/CheckHelpers/CheckHelpers.h

    r739db5a r2018659  
    2323#include <strEx.h> 
    2424 
    25 class CheckHelpers { 
     25class CheckHelpers : public NSCModuleHelper::SimpleCommand { 
    2626private: 
    2727 
    … …  
    4747  bool hasCommandHandler(); 
    4848  bool hasMessageHandler(); 
    49   NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     49  NSCAPI::nagiosReturn handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5050 
    5151  // Check commands 
    52   NSCAPI::nagiosReturn checkMultiple(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    53   NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf); 
     52  NSCAPI::nagiosReturn checkMultiple(const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
     53  NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5454}; 

  • modules/NRPEClient/CMakeLists.txt

    r9b3f53c r2018659  
    88  stdafx.cpp 
    99  "${TARGET}.cpp" 
    10   ${NSCP_INCLUDE_PATH}/NSCHelper.cpp 
    11   ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp 
    12   ${NSCP_INCLUDE_PATH}/utils.cpp 
    1310  ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.cpp 
     11 
     12  ${NSCP_DEF_PLUGIN_CPP} 
    1413) 
    1514 
    … …  
    2019    stdafx.h 
    2120    "${TARGET}.h" 
    22     ${NSCP_INCLUDE_PATH}/strEx.h 
    23     ${NSCP_INCLUDE_PATH}/config.h 
    24     ${NSCP_INCLUDE_PATH}/utils.h 
    25     ${NSCP_INCLUDE_PATH}/NSCAPI.h 
    26     ${NSCP_INCLUDE_PATH}/NSCHelper.h 
    27     ${NSCP_INCLUDE_PATH}/nsc_module_wrapper.hpp 
    2821    ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.hpp 
    2922    ${NSCP_INCLUDE_PATH}/socket_helpers.hpp 
    3023    "${TARGET}.def" 
     24 
     25    ${NSCP_DEF_PLUGIN_HPP} 
    3126  ) 
    3227ENDIF(WIN32) 
    … …  
    3530 
    3631target_link_libraries(${TARGET} 
    37   ${Boost_FILESYSTEM_LIBRARY} 
    38   ${Boost_LIBRARIES} 
    39   ${CMAKE_THREAD_LIBS_INIT} 
    40   ${OPENSSL_LIBRARIES} 
    41   ${EXTRA_LIBS} 
     32  ${Boost_FILESYSTEM_LIBRARY} 
     33  ${PROTOBUF_LIBRARY} 
     34  ${OPENSSL_LIBRARIES} 
    4235) 
    4336 

  • modules/NRPEClient/NRPEClient.cpp

    r79e734f r2018659  
    129129  return false; 
    130130} 
    131 NSCAPI::nagiosReturn NRPEClient::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) 
    132 { 
    133   command_list::const_iterator cit = commands.find(command); 
     131NSCAPI::nagiosReturn NRPEClient::handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf) 
     132{ 
     133  command_list::const_iterator cit = commands.find(strEx::blindstr(command.c_str())); 
    134134  if (cit == commands.end()) 
    135135    return NSCAPI::returnIgnored; 
    … …  
    137137  std::wstring args = (*cit).second.arguments; 
    138138  if (SETTINGS_GET_BOOL(nrpe::ALLOW_ARGS) == 1) { 
    139     arrayBuffer::arrayList arr = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    140     arrayBuffer::arrayList::const_iterator cit2 = arr.begin(); 
    141139    int i=1; 
    142  
    143     for (;cit2!=arr.end();cit2++,i++) { 
     140    BOOST_FOREACH(wstring arg, arguments) 
     141    { 
    144142      if (SETTINGS_GET_INT(nrpe::ALLOW_NASTY) == 0) { 
    145         if ((*cit2).find_first_of(NASTY_METACHARS) != std::wstring::npos) { 
     143        if (arg.find_first_of(NASTY_METACHARS) != std::wstring::npos) { 
    146144          NSC_LOG_ERROR(_T("Request string contained illegal metachars!")); 
    147145          return NSCAPI::returnIgnored; 
    148146        } 
    149147      } 
    150       strEx::replace(args, _T("$ARG") + strEx::itos(i) + _T("$"), (*cit2)); 
     148      strEx::replace(args, _T("$ARG") + strEx::itos(i++) + _T("$"), arg); 
    151149    } 
    152150  } 

  • modules/NRPEClient/NRPEClient.def

    r394f7a1 r2018659  
    1414  NSGetModuleDescription 
    1515  NSCommandLineExec 
     16  NSDeleteBuffer 

  • modules/NRPEClient/NRPEClient.h

    r9b3f53c r2018659  
    2525 
    2626 
    27 class NRPEClient { 
     27class NRPEClient : public NSCModuleHelper::SimpleCommand { 
    2828private: 
    2929  typedef enum { 
    … …  
    117117  bool hasCommandHandler(); 
    118118  bool hasMessageHandler(); 
    119   NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     119  NSCAPI::nagiosReturn handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    120120  int commandLineExec(const unsigned int argLen,TCHAR** args); 
    121121  std::wstring getConfigurationMeta(); 

  • modules/NRPEServer/CMakeLists.txt

    rf029bc2 r2018659  
    1111  nrpe_connection.cpp 
    1212  nrpe_handler.cpp 
    13   ${NSCP_INCLUDE_PATH}/NSCHelper.cpp 
    14   ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp 
    15   ${NSCP_INCLUDE_PATH}/utils.cpp 
    1613  ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.cpp 
     14 
     15  ${NSCP_DEF_PLUGIN_CPP} 
    1716) 
    1817 
    … …  
    2726    nrpe_handler.hpp 
    2827    nrpe_parser.hpp 
    29     ${NSCP_INCLUDE_PATH}/strEx.h 
    30     ${NSCP_INCLUDE_PATH}/config.h 
    31     ${NSCP_INCLUDE_PATH}/utils.h 
    32     ${NSCP_INCLUDE_PATH}/NSCAPI.h 
    33     ${NSCP_INCLUDE_PATH}/NSCHelper.h 
    34     ${NSCP_INCLUDE_PATH}/nsc_module_wrapper.hpp 
    3528    ${NSCP_INCLUDE_PATH}/nrpe/nrpepacket.hpp 
    3629    ${NSCP_INCLUDE_PATH}/socket_helpers.hpp 
    3730    "${TARGET}.def" 
     31 
     32    ${NSCP_DEF_PLUGIN_HPP} 
    3833  ) 
    3934ENDIF(WIN32) 
    … …  
    4237 
    4338target_link_libraries(${TARGET} 
    44   ${Boost_FILESYSTEM_LIBRARY} 
    45   ${Boost_LIBRARIES} 
    46   ${CMAKE_THREAD_LIBS_INIT} 
    47   ${OPENSSL_LIBRARIES} 
    48   ${EXTRA_LIBS} 
     39  ${Boost_FILESYSTEM_LIBRARY} 
     40  ${PROTOBUF_LIBRARY}  ${Boost_LIBRARIES} 
     41  ${OPENSSL_LIBRARIES} 
    4942) 
    5043 

  • modules/Scheduler/CMakeLists.txt

    r031acbf r2018659  
    77  Scheduler.cpp 
    88  simple_scheduler.cpp 
    9   ${NSCP_INCLUDE_PATH}/NSCHelper.cpp 
    10   ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp 
     9  ${NSCP_DEF_PLUGIN_CPP} 
    1110) 
    1211 
    … …  
    1716    stdafx.h 
    1817    simple_scheduler.hpp 
    19     ${NSCP_INCLUDE_PATH}/strEx.h 
    20     ${NSCP_INCLUDE_PATH}/config.h 
    21     ${NSCP_INCLUDE_PATH}/utils.h 
    22     ${NSCP_INCLUDE_PATH}/NSCAPI.h 
    23     ${NSCP_INCLUDE_PATH}/NSCHelper.h 
    24     ${NSCP_INCLUDE_PATH}/nsc_module_wrapper.hpp 
    25     Scheduler.def 
     18    ${NSCP_DEF_PLUGIN_HPP} 
    2619  ) 
    2720ENDIF(WIN32) 
    … …  
    3023 
    3124target_link_libraries(Scheduler 
    32   ${Boost_FILESYSTEM_LIBRARY} 
    33   ${Boost_LIBRARIES} 
    34   ${CMAKE_THREAD_LIBS_INIT} 
    35   ${EXTRA_LIBS} 
     25  ${Boost_FILESYSTEM_LIBRARY} 
     26  ${NSCP_DEF_PLUGIN_LIB} 
    3627) 

  • modules/Scheduler/Scheduler.cpp

    ref0e24b r2018659  
    122122  try { 
    123123    std::wstring msg, perf; 
    124     NSCAPI::nagiosReturn code = NSCModuleHelper::InjectCommand(item.command.c_str(), item.arguments, msg, perf); 
     124    NSCAPI::nagiosReturn code = NSCModuleHelper::InjectSimpleCommand(item.command.c_str(), item.arguments, msg, perf); 
    125125    if (NSCHelper::report::matches(item.report, code)) { 
    126126      NSCModuleHelper::NotifyChannel(item.channel, item.alias, code, msg, perf); 

  • modules/Scheduler/Scheduler.def

    r031acbf r2018659  
    1212  NSUnloadModule 
    1313  NSGetModuleDescription 
     14  NSDeleteBuffer 

  • service/CMakeLists.txt

    r753ea6d r2018659  
    1515  settings_manager_impl.cpp 
    1616 
    17   ${NSCP_INCLUDE_PATH}/NSCHelper.cpp 
    18   ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp 
     17  ${NSCP_DEF_PLUGIN_CPP} 
     18 
    1919  ${NSCP_INCLUDE_PATH}/simpleini/ConvertUTF.c 
    2020  ${NSCP_INCLUDE_PATH}/b64/b64.c 
    … …  
    4949    ${NSCP_INCLUDE_PATH}/settings/settings_registry.hpp 
    5050    ${NSCP_INCLUDE_PATH}/settings/Settings.h 
    51     ${NSCP_INCLUDE_PATH}/NSCHelper.h 
    5251    ${NSCP_INCLUDE_PATH}/com_helpers.hpp 
    5352    ${NSCP_INCLUDE_PATH}/dll/dll.hpp 
    … …  
    5857    ${NSCP_INCLUDE_PATH}/service/system_service.hpp 
    5958    ${NSCP_INCLUDE_PATH}/service/win32_service.hpp 
     59 
     60    ${NSCP_DEF_PLUGIN_HPP} 
     61 
    6062  ) 
    6163  SET(service_SRCS ${service_SRCS} 
    … …  
    7072 
    7173target_link_libraries(nsclient++  
    72   ${Boost_FILESYSTEM_LIBRARY} 
    73   ${Boost_LIBRARIES} 
    74   ${CMAKE_THREAD_LIBS_INIT} 
    75   ${EXTRA_LIBS} 
     74  ${Boost_FILESYSTEM_LIBRARY} 
     75  ${PROTOBUF_LIBRARY} 
    7676) 
    7777 

  • service/NSCPlugin.cpp

    r753ea6d r2018659  
    4141  ,fHasMessageHandler(NULL) 
    4242  ,fHandleMessage(NULL) 
     43  ,fDeleteBuffer(NULL) 
    4344  ,fGetDescription(NULL) 
    4445  ,fGetConfigurationMeta(NULL) 
    … …  
    220221 * @throws NSPluginException if the module is not loaded. 
    221222 */ 
    222 NSCAPI::nagiosReturn NSCPlugin::handleCommand(const wchar_t* command, const unsigned int argLen, wchar_t **arguments, wchar_t* returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t* returnPerfBuffer, unsigned int returnPerfBufferLen) { 
     223NSCAPI::nagiosReturn NSCPlugin::handleCommand(const wchar_t* command, const char* dataBuffer, unsigned int dataBuffer_len, char** returnBuffer, unsigned int *returnBuffer_len) { 
    223224  if (!isLoaded()) 
    224225    throw NSPluginException(module_, _T("Library is not loaded")); 
    225226  try { 
    226     return fHandleCommand(command, argLen, arguments, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
     227    return fHandleCommand(command, dataBuffer, dataBuffer_len, returnBuffer, returnBuffer_len); 
    227228  } catch (...) { 
    228229    throw NSPluginException(module_, _T("Unhandled exception in handleCommand.")); 
    229230  } 
    230231} 
     232 
     233 
     234void NSCPlugin::deleteBuffer(char** buffer) { 
     235  if (!isLoaded()) 
     236    throw NSPluginException(module_, _T("Library is not loaded")); 
     237  try { 
     238    fDeleteBuffer(buffer); 
     239  } catch (...) { 
     240    throw NSPluginException(module_, _T("Unhandled exception in deleteBuffer.")); 
     241  } 
     242} 
     243NSCAPI::nagiosReturn NSCPlugin::handleCommand(const wchar_t *command, std::string &request, std::string &reply) { 
     244  char *buffer = NULL; 
     245  unsigned int len = 0; 
     246  NSCAPI::nagiosReturn ret = handleCommand(command, request.c_str(), request.size(), &buffer, &len); 
     247  if (buffer != NULL) { 
     248    reply = std::string(buffer, len); 
     249    deleteBuffer(&buffer); 
     250  } 
     251  return ret; 
     252} 
     253 
    231254/** 
    232255 * Handle a message from the core (or any other (or even potentially self) plug in). 
    … …  
    349372      throw NSPluginException(module_, _T("Could not load NSHandleCommand")); 
    350373 
     374    fDeleteBuffer = (lpDeleteBuffer)module_.load_proc("NSDeleteBuffer"); 
     375    if (!fDeleteBuffer) 
     376      throw NSPluginException(module_, _T("Could not load NSDeleteBuffer")); 
     377 
    351378    fHandleMessage = (lpHandleMessage)module_.load_proc("NSHandleMessage"); 
    352379    if (!fHandleMessage) 

  • service/NSCPlugin.h

    r1e0bbec r2018659  
    118118  typedef int (*lpHasCommandHandler)(); 
    119119  typedef int (*lpHasMessageHandler)(); 
    120   typedef NSCAPI::nagiosReturn (*lpHandleCommand)(const wchar_t*,const unsigned int, wchar_t**,wchar_t*,unsigned int,wchar_t *,unsigned int); 
     120  typedef NSCAPI::nagiosReturn (*lpHandleCommand)(const wchar_t*,const char*,const unsigned int,char**,unsigned int*); 
     121  typedef int (*lpDeleteBuffer)(char**); 
    121122  typedef int (*lpCommandLineExec)(const unsigned int,wchar_t**); 
    122123  typedef int (*lpHandleMessage)(int,const wchar_t*,const int,const wchar_t*); 
    … …  
    135136  lpHasMessageHandler fHasMessageHandler; 
    136137  lpHandleCommand fHandleCommand; 
     138  lpDeleteBuffer fDeleteBuffer; 
    137139  lpHandleMessage fHandleMessage; 
    138140  lpUnLoadModule fUnLoadModule; 
    … …  
    156158  bool hasCommandHandler(void); 
    157159  bool hasMessageHandler(void); 
    158   NSCAPI::nagiosReturn handleCommand(const wchar_t *command, const unsigned int argLen, wchar_t **arguments, wchar_t* returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t* returnPerfBuffer, unsigned int returnPerfBufferLen); 
     160  NSCAPI::nagiosReturn handleCommand(const wchar_t *command, const char* dataBuffer, const unsigned int dataBuffer_len, char** returnBuffer, unsigned int *returnBuffer_len); 
     161  NSCAPI::nagiosReturn handleCommand(const wchar_t* command, std::string &request, std::string &reply); 
     162  void deleteBuffer(char**buffer); 
    159163  void handleMessage(int msgType, const wchar_t* file, const int line, const wchar_t *message); 
    160164  void unload(void); 

  • service/NSClient++.cpp

    r50a5db2 r2018659  
    3939#include "settings_client.hpp" 
    4040#include "service_manager.hpp" 
     41 
     42#include "../proto/plugin.pb.h" 
    4143 
    4244NSClient mainClient(SZSERVICENAME); // Global core instance. 
    … …  
    373375        args += argv[i]; 
    374376      } 
    375       nRetCode = mainClient.inject(command, args, L' ', true, msg, perf); 
     377      nRetCode = mainClient.inject(command, args, msg, perf); 
    376378      std::wcout << msg << _T("|") << perf << std::endl; 
    377379      mainClient.exitCore(true); 
    … …  
    10221024} 
    10231025 
    1024 NSCAPI::nagiosReturn NSClientT::inject(std::wstring command, std::wstring arguments, wchar_t splitter, bool escape, std::wstring &msg, std::wstring & perf) { 
     1026NSCAPI::nagiosReturn NSClientT::inject(std::wstring command, std::wstring arguments, std::wstring &msg, std::wstring & perf) { 
    10251027  /*if (shared_client_.get() != NULL && shared_client_->hasMaster()) { 
    10261028    try { 
    … …  
    10341036    } 
    10351037  } else */{ 
    1036     unsigned int aLen = 0; 
    1037     wchar_t ** aBuf = arrayBuffer::split2arrayBuffer(arguments, splitter, aLen, escape); 
    1038     unsigned int buf_len = getBufferLength(); 
    1039     wchar_t * mBuf = new wchar_t[buf_len+1]; mBuf[0] = '\0'; 
    1040     wchar_t * pBuf = new wchar_t[buf_len+1]; pBuf[0] = '\0'; 
    1041     NSCAPI::nagiosReturn ret = injectRAW(command.c_str(), aLen, aBuf, mBuf, buf_len, pBuf, buf_len); 
    1042     arrayBuffer::destroyArrayBuffer(aBuf, aLen); 
     1038    PluginCommand::RequestMessage message; 
     1039    PluginCommand::Header *hdr = message.mutable_header(); 
     1040    hdr->set_type(PluginCommand::Header_Type_REQUEST); 
     1041    hdr->set_version(PluginCommand::Header_Version_VERSION_1); 
     1042 
     1043    PluginCommand::Request *req = message.add_payload(); 
     1044    req->set_command(to_string(command)); 
     1045    req->set_version(PluginCommand::Request_Version_VERSION_1); 
     1046 
     1047    std::string args = to_string(arguments); 
     1048    boost::tokenizer<boost::escaped_list_separator<char> > tok(args, boost::escaped_list_separator<char>('\\', ' ', '\"')); 
     1049    BOOST_FOREACH(string s, tok) 
     1050      req->add_arguments(s); 
     1051 
     1052    std::string request, response; 
     1053    message.SerializeToString(&request); 
     1054 
     1055 
     1056 
     1057    NSCAPI::nagiosReturn ret = injectRAW(command.c_str(), request, response); 
     1058    if (response.empty()) { 
     1059      LOG_ERROR(_T("No data retutned from command")); 
     1060      return NSCAPI::returnUNKNOWN; 
     1061    } 
     1062 
     1063    PluginCommand::ResponseMessage rsp_msg; 
     1064    rsp_msg.ParseFromString(response); 
     1065    if (rsp_msg.payload_size() != 1) { 
     1066      LOG_ERROR_STD(_T("Failed to extract return message not 1 payload: ") + strEx::itos(rsp_msg.payload_size())); 
     1067      return NSCAPI::returnUNKNOWN; 
     1068    } 
     1069    msg = to_wstring(rsp_msg.payload(0).message()); 
    10431070    if ( (ret == NSCAPI::returnInvalidBufferLen) || (ret == NSCAPI::returnIgnored) ) { 
    1044       delete [] mBuf; 
    1045       delete [] pBuf; 
    10461071      return ret; 
    10471072    } 
    1048     msg = mBuf; 
    1049     perf = pBuf; 
    1050     delete [] mBuf; 
    1051     delete [] pBuf; 
    10521073    return ret; 
    10531074  } 
    … …  
    10661087 * @return The command status 
    10671088 */ 
    1068 NSCAPI::nagiosReturn NSClientT::injectRAW(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen) { 
     1089NSCAPI::nagiosReturn NSClientT::injectRAW(const wchar_t* command, std::string &request, std::string &response) { 
    10691090  if (logDebug()) { 
    1070     LOG_DEBUG_STD(_T("Injecting: ") + (std::wstring) command + _T(": ") + arrayBuffer::arrayBuffer2string(argument, argLen, _T(", "))); 
     1091    LOG_DEBUG_STD(_T("Injecting: ") + std::wstring(command) + _T(": {{{") + strEx::strip_hex(to_wstring(request)) + _T("}}}")); 
    10711092  } 
    10721093  /*if (shared_client_.get() != NULL && shared_client_->hasMaster()) { 
    … …  
    10931114    for (pluginList::size_type i = 0; i < commandHandlers_.size(); i++) { 
    10941115      try { 
    1095         NSCAPI::nagiosReturn c = commandHandlers_[i]->handleCommand(command, argLen, argument, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
     1116        NSCAPI::nagiosReturn c = commandHandlers_[i]->handleCommand(command, request, response); 
    10961117        switch (c) { 
    10971118          case NSCAPI::returnInvalidBufferLen: 
    … …  
    11041125          case NSCAPI::returnCRIT: 
    11051126          case NSCAPI::returnUNKNOWN: 
    1106             LOG_DEBUG_STD(_T("Injected Result: ") + NSCHelper::translateReturn(c) + _T(" '") + (std::wstring)(returnMessageBuffer) + _T("'")); 
    1107             LOG_DEBUG_STD(_T("Injected Performance Result: '") +(std::wstring)(returnPerfBuffer) + _T("'")); 
     1127            LOG_DEBUG_STD(_T("Result ") + std::wstring(command) + _T(": ") + NSCHelper::translateReturn(c) + _T(" {{{") + strEx::strip_hex(to_wstring(response)) + _T("}}}")); 
    11081128            return c; 
    11091129          default: 

  • service/NSClient++.h

    rcc2efd6 r2018659  
    163163  // Member functions 
    164164  boost::filesystem::wpath getBasePath(void); 
    165   NSCAPI::nagiosReturn injectRAW(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen); 
    166   NSCAPI::nagiosReturn inject(std::wstring command, std::wstring arguments, wchar_t splitter, bool escape, std::wstring &msg, std::wstring & perf); 
     165  NSCAPI::nagiosReturn injectRAW(const wchar_t* command, std::string &request, std::string &response); 
     166  NSCAPI::nagiosReturn inject(std::wstring command, std::wstring arguments, std::wstring &msg, std::wstring & perf); 
    167167//  std::wstring inject(const std::wstring buffer); 
    168168  std::wstring execute(std::wstring password, std::wstring cmd, std::list<std::wstring> args); 
    … …  
    193193  } 
    194194  int session_inject(std::wstring command, std::wstring arguments, wchar_t splitter, bool escape, std::wstring &msg, std::wstring & perf) { 
    195     return inject(command, arguments, splitter, escape, msg, perf); 
     195    return 0; // TODO: Readd this!!! inject(command, arguments, splitter, escape, msg, perf); 
    196196  } 
    197197  std::pair<std::wstring,std::wstring> session_get_name() { 

  • service/core_api.cpp

    r1bfe6f0 r2018659  
    8282#endif 
    8383} 
    84 NSCAPI::nagiosReturn NSAPIInject(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen) { 
    85   return mainClient.injectRAW(command, argLen, argument, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
     84NSCAPI::nagiosReturn NSAPIInject(const wchar_t* command, const char *request_buffer, const unsigned int request_buffer_len, char **response_buffer, unsigned int *response_buffer_len) { 
     85  std::string request (request_buffer, request_buffer_len), response; 
     86  NSCAPI::nagiosReturn ret = mainClient.injectRAW(command, request, response); 
     87  *response_buffer_len = response.size(); 
     88  if (response.empty()) 
     89    *response_buffer = NULL; 
     90  else { 
     91    *response_buffer = new char[*response_buffer_len + 10]; 
     92    memcpy(*response_buffer, response.c_str(), *response_buffer_len); 
     93  } 
     94  return ret; 
    8695} 
    8796NSCAPI::errorReturn NSAPIGetSettingsSection(const wchar_t* section, wchar_t*** aBuffer, unsigned int * bufLen) { 
    … …  
    415424  if (wcscasecmp(buffer, _T("NSAPINotify")) == 0) 
    416425    return reinterpret_cast<LPVOID>(&NSAPINotify); 
     426  if (wcscasecmp(buffer, _T("NSAPIDestroyBuffer")) == 0) 
     427    return reinterpret_cast<LPVOID>(&NSAPIDestroyBuffer); 
    417428 
    418429  LOG_ERROR_STD(_T("Function not found: ") + buffer); 
    … …  
    425436} 
    426437 
     438void NSAPIDestroyBuffer(char**buffer) { 
     439  delete [] *buffer; 
     440} 

  • service/core_api.h

    r1bfe6f0 r2018659  
    3838void NSAPIMessage(int msgType, const wchar_t* file, const int line, const wchar_t* message); 
    3939void NSAPIStopServer(void); 
    40 NSCAPI::nagiosReturn NSAPIInject(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen); 
     40NSCAPI::nagiosReturn NSAPIInject(const wchar_t* command, const char *request_buffer, const unsigned int request_buffer_len, char **response_buffer, unsigned int *response_buffer_len); 
    4141NSCAPI::errorReturn NSAPIGetSettingsSection(const wchar_t*, wchar_t***, unsigned int *); 
    4242NSCAPI::errorReturn NSAPIReleaseSettingsSectionBuffer(wchar_t*** aBuffer, unsigned int * bufLen); 
    … …  
    5959NSCAPI::errorReturn NSAPISettingsSave(void); 
    6060NSCAPI::errorReturn NSAPINotify(const wchar_t*, const wchar_t*, NSCAPI::nagiosReturn, const wchar_t*, const wchar_t*); 
     61void NSAPIDestroyBuffer(char**); 

  • service/simple_client.hpp

    r031acbf r2018659  
    5555          strEx::token t = strEx::getToken(buff, ' '); 
    5656          std::wstring msg, perf; 
    57           NSCAPI::nagiosReturn ret = core_->inject(t.first, t.second, ' ', true, msg, perf); 
     57          NSCAPI::nagiosReturn ret = core_->inject(t.first, t.second, msg, perf); 
    5858          if (ret == NSCAPI::returnIgnored) { 
    5959            std::wcout << _T("No handler for command: ") << t.first << std::endl; 
Note: See TracChangeset for help on using the changeset viewer.