Changeset 1eef1ee in nscp


Ignore:
Timestamp:
03/20/05 20:54:25 (8 years ago)
Author:
Michael Medin <michael@…>
Branches:
master, 0.4.0, 0.4.1, 0.4.2, stable
Children:
c6e008c
Parents:
2a94f3f
Message:

*OBS* This might no longer work! (expect updated code in the next few days if things are broken)

  • Fundamental API changes (due to NRPE compatibility)
    • HandleCommand? has changed
    • Inject has changed
    • Most API calls have new "return codes" (typedef:ed INT to allow for return code compiler checks)
    • A lot of the old return codes have changed
  • Preliminary NRPE support (can parse and execute incoming requests, cant return data yet, and no encryption)
  • New SimpleSocket? in include/ will be used as base class for Listeners
  • A lot of rewrite to the NSC API
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • NSCPlugin.cpp

    r36c340d r1eef1ee  
    114114 * @todo Implement return status as an enum to make it simpler for clients to see potential return stats? 
    115115 */ 
    116 int NSCPlugin::handleCommand(const char *command, const unsigned int argLen, char **arguments, char* returnBuffer, unsigned int returnBufferLen) { 
     116NSCAPI::nagiosReturn NSCPlugin::handleCommand(const char *command, const unsigned int argLen, char **arguments, char* returnMessageBuffer, unsigned int returnMessageBufferLen, char* returnPerfBuffer, unsigned int returnPerfBufferLen) { 
    117117  if (!isLoaded()) 
    118118    throw NSPluginException(file_, "Library is not loaded"); 
    119   return fHandleCommand(command, argLen, arguments, returnBuffer, returnBufferLen); 
     119  return fHandleCommand(command, argLen, arguments, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
    120120} 
    121121/** 

  • NSCPlugin.h

    r36c340d r1eef1ee  
    9393  typedef INT (*lpHasCommandHandler)(); 
    9494  typedef INT (*lpHasMessageHandler)(); 
    95   typedef INT (*lpHandleCommand)(const char*, const unsigned int, char**,char*,unsigned int); 
     95  typedef NSCAPI::nagiosReturn (*lpHandleCommand)(const char*,const unsigned int, char**,char*,unsigned int,char *,unsigned int); 
    9696  typedef INT (*lpHandleMessage)(int,const char*,const int,const char*); 
    9797  typedef int (*lpUnLoadModule)(); 
    … …  
    115115  bool hasCommandHandler(void); 
    116116  bool hasMessageHandler(void); 
    117   int handleCommand(const char *command, const unsigned int, char **arguments, char* returnBuffer, unsigned int returnBufferLen); 
     117  NSCAPI::nagiosReturn handleCommand(const char *command, const unsigned int argLen, char **arguments, char* returnMessageBuffer, unsigned int returnMessageBufferLen, char* returnPerfBuffer, unsigned int returnPerfBufferLen); 
    118118  void handleMessage(int msgType, const char* file, const int line, const char *message); 
    119119  void unload(void); 

  • NSClient++.cpp

    r2a94f3f r1eef1ee  
    220220 * @return The result, empty string if no result 
    221221 */ 
    222 int NSClientT::injectRAW(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen) { 
     222NSCAPI::nagiosReturn NSClientT::injectRAW(const char* command, const unsigned int argLen, char **argument, char *returnMessageBuffer, unsigned int returnMessageBufferLen, char *returnPerfBuffer, unsigned int returnPerfBufferLen) { 
    223223  MutexLock lock(pluginMutex); 
    224224 
    … …  
    228228  for (plit = commandHandlers_.begin(); plit != commandHandlers_.end(); ++plit) { 
    229229    try { 
    230       int c = (*plit)->handleCommand(command, argLen, argument, returnBuffer, returnBufferLen); 
    231       if (c == NSCAPI::handled) {         // module handled the message "we are done..." 
    232         LOG_DEBUG_STD("Injected Result: " +(std::string) returnBuffer); 
    233         return c; 
    234       } else if (c == NSCAPI::isfalse) {      // Module ignored the message 
    235         LOG_DEBUG("A module ignored this message"); 
    236       } else if (c == NSCAPI::invalidBufferLen) { // Buffer is to small 
    237         LOG_ERROR("Return buffer to small to handle this command."); 
    238         return c; 
    239       } else if (c == NSCAPI::isError) {      // Error 
    240         LOG_ERROR("An error occured while handling this command."); 
    241         return c; 
    242       } else {                  // Something else went wrong... 
    243         LOG_ERROR_STD("Unknown error from handleCommand: " + strEx::itos(c)); 
    244         return c; 
     230      NSCAPI::nagiosReturn c = (*plit)->handleCommand(command, argLen, argument, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
     231      switch (c) { 
     232        case NSCAPI::returnInvalidBufferLen: 
     233          LOG_ERROR("Return buffer to small to handle this command."); 
     234          return c; 
     235        case NSCAPI::returnIgnored: 
     236          LOG_DEBUG("A module ignored this message"); 
     237          break; 
     238        case NSCAPI::returnOK: 
     239        case NSCAPI::returnWARN: 
     240        case NSCAPI::returnCRIT: 
     241        case NSCAPI::returnUNKNOWN: 
     242          LOG_DEBUG_STD("Injected Result: " +(std::string) returnMessageBuffer); 
     243          LOG_DEBUG_STD("Injected Performance Result: " +(std::string) returnPerfBuffer); 
     244          return c; 
     245        default: 
     246          LOG_ERROR_STD("Unknown error from handleCommand: " + strEx::itos(c)); 
     247          return c; 
    245248      } 
    246249    } catch(const NSPluginException& e) { 
    247250      LOG_ERROR_STD("Exception raised: " + e.error_ + " in module: " + e.file_); 
    248       return NSCAPI::isError; 
     251      return NSCAPI::returnCRIT; 
    249252    } 
    250253  } 
    251254  LOG_MESSAGE_STD("No handler for command: " + command); 
    252   return NSCAPI::isfalse; 
     255  return NSCAPI::returnIgnored; 
    253256} 
    254257/** 
    … …  
    271274 * ie. pair<int,string> 
    272275 */ 
     276/* 
    273277std::string NSClientT::execute(std::string password, std::string cmd, std::list<std::string> args) { 
    274278  MutexLock lock(pluginMutex); 
    … …  
    312316  return ret; 
    313317} 
     318*/ 
    314319/** 
    315320 * Report a message to all logging enabled modules. 
    … …  
    372377 
    373378 
    374 int NSAPIGetSettingsString(const char* section, const char* key, const char* defaultValue, char* buffer, unsigned int bufLen) { 
    375   return NSCHelper::wrapReturnString(buffer, bufLen, Settings::getInstance()->getString(section, key, defaultValue)); 
     379NSCAPI::errorReturn NSAPIGetSettingsString(const char* section, const char* key, const char* defaultValue, char* buffer, unsigned int bufLen) { 
     380  return NSCHelper::wrapReturnString(buffer, bufLen, Settings::getInstance()->getString(section, key, defaultValue), NSCAPI::isSuccess); 
    376381} 
    377382int NSAPIGetSettingsInt(const char* section, const char* key, int defaultValue) { 
    378383  return Settings::getInstance()->getInt(section, key, defaultValue); 
    379384} 
    380 int NSAPIGetBasePath(char*buffer, unsigned int bufLen) { 
    381   return NSCHelper::wrapReturnString(buffer, bufLen, mainClient.getBasePath()); 
    382 } 
    383 int NSAPIGetApplicationName(char*buffer, unsigned int bufLen) { 
    384   return NSCHelper::wrapReturnString(buffer, bufLen, SZAPPNAME); 
    385 } 
    386 int NSAPIGetApplicationVersionStr(char*buffer, unsigned int bufLen) { 
    387   return NSCHelper::wrapReturnString(buffer, bufLen, SZVERSION); 
     385NSCAPI::errorReturn NSAPIGetBasePath(char*buffer, unsigned int bufLen) { 
     386  return NSCHelper::wrapReturnString(buffer, bufLen, mainClient.getBasePath(), NSCAPI::isSuccess); 
     387} 
     388NSCAPI::errorReturn NSAPIGetApplicationName(char*buffer, unsigned int bufLen) { 
     389  return NSCHelper::wrapReturnString(buffer, bufLen, SZAPPNAME, NSCAPI::isSuccess); 
     390} 
     391NSCAPI::errorReturn NSAPIGetApplicationVersionStr(char*buffer, unsigned int bufLen) { 
     392  return NSCHelper::wrapReturnString(buffer, bufLen, SZVERSION, NSCAPI::isSuccess); 
    388393} 
    389394void NSAPIMessage(int msgType, const char* file, const int line, const char* message) { 
    … …  
    393398  serviceControll::Stop(SZSERVICENAME); 
    394399} 
    395 int NSAPIInject(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen) { 
    396   return mainClient.injectRAW(command, argLen, argument, returnBuffer, returnBufferLen); 
     400NSCAPI::nagiosReturn NSAPIInject(const char* command, const unsigned int argLen, char **argument, char *returnMessageBuffer, unsigned int returnMessageBufferLen, char *returnPerfBuffer, unsigned int returnPerfBufferLen) { 
     401  return mainClient.injectRAW(command, argLen, argument, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
    397402} 
    398403 

  • NSClient++.h

    r2a94f3f r1eef1ee  
    5959  static std::string getPassword(void); 
    6060  std::string getBasePath(void); 
    61   int injectRAW(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen); 
     61  NSCAPI::nagiosReturn injectRAW(const char* command, const unsigned int argLen, char **argument, char *returnMessageBuffer, unsigned int returnMessageBufferLen, char *returnPerfBuffer, unsigned int returnPerfBufferLen); 
    6262//  std::string inject(const std::string buffer); 
    6363  std::string execute(std::string password, std::string cmd, std::list<std::string> args); 
    … …  
    8383 
    8484LPVOID NSAPILoader(char*buffer); 
    85 int NSAPIGetApplicationName(char*buffer, unsigned int bufLen); 
    86 int NSAPIGetBasePath(char*buffer, unsigned int bufLen); 
    87 int NSAPIGetApplicationVersionStr(char*buffer, unsigned int bufLen); 
    88 int NSAPIGetSettingsString(const char* section, const char* key, const char* defaultValue, char* buffer, unsigned int bufLen); 
     85NSCAPI::errorReturn NSAPIGetApplicationName(char*buffer, unsigned int bufLen); 
     86NSCAPI::errorReturn NSAPIGetBasePath(char*buffer, unsigned int bufLen); 
     87NSCAPI::errorReturn NSAPIGetApplicationVersionStr(char*buffer, unsigned int bufLen); 
     88NSCAPI::errorReturn NSAPIGetSettingsString(const char* section, const char* key, const char* defaultValue, char* buffer, unsigned int bufLen); 
    8989int NSAPIGetSettingsInt(const char* section, const char* key, int defaultValue); 
    9090void NSAPIMessage(int msgType, const char* file, const int line, const char* message); 
    9191void NSAPIStopServer(void); 
    92 int NSAPIInject(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen); 
     92NSCAPI::nagiosReturn NSAPIInject(const char* command, const unsigned int argLen, char **argument, char *returnMessageBuffer, unsigned int returnMessageBufferLen, char *returnPerfBuffer, unsigned int returnPerfBufferLen); 
    9393 
    9494////////////////////////////////////////////////////////////////////////// 

  • changelog

    r2a94f3f r1eef1ee  
     12005-03-20 MickeM 
     2 * Fundamental API changes (due to NRPE compatibility) 
     3   - HandleCommand has changed 
     4   - Inject has changed 
     5   - Most API calls have new "return codes" (typedef:ed INT to allow for return code compiler checks) 
     6   - A lot of the old return codes have changed 
     7 * Preliminary NRPE support (can parse and execute incoming requests, cant return data yet, and no encryption) 
     8 * New SimpleSocket in include/ will be used as base class for Listeners 
     9 * A lot of rewrite to the NSC API 
     10 
    1112005-03-19 MickeM 
    212 * Refactored out NSCLient Listener as a separate module 

  • include/NSCAPI.h

    r2a94f3f r1eef1ee  
    33namespace NSCAPI { 
    44 
     5  typedef enum { 
     6    returnCRIT = 2, 
     7    returnOK = 0, 
     8    returnWARN = 1, 
     9    returnUNKNOWN = 4, 
     10    returnInvalidBufferLen = -2, 
     11    returnIgnored = -1 
     12  } nagiosReturn; 
     13 
     14  typedef enum { 
     15    istrue = 1,  
     16    isfalse = 0 
     17  } boolReturn; 
     18 
     19  typedef enum { 
     20    isSuccess = 1,  
     21    hasFailed = 0, 
     22    isInvalidBufferLen = -2 
     23  } errorReturn; 
     24 
     25 
     26 
    527  // Various Nagios codes 
     28  /* 
    629  const int returnCRIT = 2; 
    730  const int returnOK = 0; 
    831  const int returnWARN = 1; 
    932  const int returnUNKNOWN = 4; 
    10   typedef int returnCodes; 
     33  */ 
     34  // Various NSCP extensions 
    1135 
    12   // Various Return codes 
    13   const int success = 1;      // Everything went fine 
    14   const int failed = 0;     // EVerything went to hell :) 
    15   const int istrue = 1;     // Should be interpreted as "true" 
    16   const int isfalse = 0;      // Should be interpreted as "false" 
    17   const int isError = -1;     // Should be interpreted as "ERROR" 
    18   const int handled = 2;      // The command was handled by this module 
    19   const int invalidBufferLen = -2;// The return buffer was to small (might wanna call again with a larger one) 
     36//  const int returnInvalidBufferLen = -2;  // The return buffer was to small (might wanna call again with a larger one) 
     37 
     38 
     39//  typedef int returnCodes; 
     40 
     41  // Various function Return codes 
     42//  const int isSuccess = 1;    // Everything went fine 
     43//  const int hasFailed = 0;    // EVerything went to hell :) 
     44//  const int isTrue = 1;     // Should be interpreted as "true" 
     45//  const int isFalse = 0;      // Should be interpreted as "false" 
     46//  const int isError = -1;     // Should be interpreted as "ERROR" 
     47//  const int handled = 2;      // The command was handled by this module 
    2048 
    2149  // Various message Types 

  • include/NSCHelper.cpp

    r2a94f3f r1eef1ee  
    77 
    88/** 
    9  * Wrap a return string. 
    10  * This function copies a string to a char buffer making sure the buffer has the correct length. 
    11  * 
    12  * @param *buffer Buffer to copy the string to. 
    13  * @param bufLen Length of the buffer 
    14  * @param str Th string to copy 
    15  * @return NSCAPI::success unless the buffer is to short then it will be NSCAPI::invalidBufferLen 
    16  */ 
    17 int NSCHelper::wrapReturnString(char *buffer, unsigned int bufLen, std::string str, int defaultReturnCode /* = NSCAPI::success */) { 
     9* Wrap a return string. 
     10* This function copies a string to a char buffer making sure the buffer has the correct length. 
     11* 
     12* @param *buffer Buffer to copy the string to. 
     13* @param bufLen Length of the buffer 
     14* @param str Th string to copy 
     15* @return NSCAPI::success unless the buffer is to short then it will be NSCAPI::invalidBufferLen 
     16*/ 
     17/* 
     18int NSCHelper::wrapReturnString(char *buffer, unsigned int bufLen, std::string str, int defaultReturnCode ) { 
     19  // @todo deprecate this 
    1820  if (str.length() >= bufLen) 
    19     return NSCAPI::invalidBufferLen; 
     21    return -1; 
     22  strncpy(buffer, str.c_str(), bufLen); 
     23  return defaultReturnCode; 
     24} 
     25*/ 
     26NSCAPI::nagiosReturn NSCHelper::wrapReturnString(char *buffer, unsigned int bufLen, std::string str, NSCAPI::nagiosReturn defaultReturnCode /* = NSCAPI::success */) { 
     27  if (str.length() >= bufLen) 
     28    return NSCAPI::returnInvalidBufferLen; 
     29  strncpy(buffer, str.c_str(), bufLen); 
     30  return defaultReturnCode; 
     31} 
     32NSCAPI::errorReturn NSCHelper::wrapReturnString(char *buffer, unsigned int bufLen, std::string str, NSCAPI::errorReturn defaultReturnCode /* = NSCAPI::success */) { 
     33  if (str.length() >= bufLen) 
     34    return NSCAPI::isInvalidBufferLen; 
    2035  strncpy(buffer, str.c_str(), bufLen); 
    2136  return defaultReturnCode; 
    … …  
    149164  return "unknown"; 
    150165} 
    151 std::string NSCHelper::translateReturn(NSCAPI::returnCodes returnCode) { 
     166std::string NSCHelper::translateReturn(NSCAPI::nagiosReturn returnCode) { 
    152167  if (returnCode == NSCAPI::returnOK) 
    153168    return "OK"; 
    … …  
    197212 * @throws NSCMHExcpetion When core pointer set is unavailable or an unknown inject error occurs. 
    198213 */ 
    199 int NSCModuleHelper::InjectCommandRAW(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen)  
     214NSCAPI::nagiosReturn NSCModuleHelper::InjectCommandRAW(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen)  
    200215{ 
    201216  if (!fNSAPIInject) 
    … …  
    203218  return fNSAPIInject(command, argLen, argument, returnBuffer, returnBufferLen); 
    204219} 
    205 std::string NSCModuleHelper::InjectCommand(const char* command, const unsigned int argLen, char **argument)  
     220NSCAPI::nagiosReturn NSCModuleHelper::InjectCommand(const char* command, const unsigned int argLen, char **argument, std::string & message, std::string & perf)  
    206221{ 
    207222  if (!fNSAPIInject) 
    … …  
    209224  char *buffer = new char[BUFF_LEN+1]; 
    210225  buffer[0] = 0; 
    211   std::string ret; 
    212   int err; 
    213   if ((err = InjectCommandRAW(command, argLen, argument, buffer, BUFF_LEN)) != NSCAPI::handled) { 
    214     if (err == NSCAPI::invalidBufferLen) 
     226  // @todo message here ! 
     227  NSCAPI::nagiosReturn retC = InjectCommandRAW(command, argLen, argument, buffer, BUFF_LEN); 
     228  switch (retC) { 
     229    case NSCAPI::returnIgnored: 
     230      NSC_LOG_MESSAGE("No handler for this message."); 
     231      break; 
     232    case NSCAPI::returnInvalidBufferLen: 
    215233      NSC_LOG_ERROR("Inject command resulted in an invalid buffer size."); 
    216     else if (err == NSCAPI::isfalse) 
    217       NSC_LOG_MESSAGE("No handler for this message."); 
    218     else 
     234      break; 
     235    case NSCAPI::returnOK: 
     236    case NSCAPI::returnCRIT: 
     237    case NSCAPI::returnWARN: 
     238    case NSCAPI::returnUNKNOWN: 
     239      message = buffer; 
     240      // @todo perf data  
     241      break; 
     242    default: 
    219243      throw NSCMHExcpetion("Unknown inject error."); 
    220   } else { 
    221     ret = buffer; 
    222244  } 
    223245  delete [] buffer; 
    224   return ret; 
     246  return retC; 
    225247} 
    226248/** 
    … …  
    233255 * @return The result of the command 
    234256 */ 
    235 std::string NSCModuleHelper::InjectSplitAndCommand(const char* command, char* buffer, char splitChar) 
     257NSCAPI::nagiosReturn NSCModuleHelper::InjectSplitAndCommand(const char* command, char* buffer, char splitChar, std::string & message, std::string & perf) 
    236258{ 
    237259  if (!fNSAPIInject) 
    … …  
    243265  else 
    244266    aBuffer= NSCHelper::createEmptyArrayBuffer(argLen); 
    245   std::string s = InjectCommand(command, argLen, aBuffer); 
     267  NSCAPI::nagiosReturn ret = InjectCommand(command, argLen, aBuffer, message, perf); 
    246268  NSCHelper::destroyArrayBuffer(aBuffer, argLen); 
    247   return s; 
     269  return ret; 
    248270} 
    249271/** 
    … …  
    269291    throw NSCMHExcpetion("NSCore has not been initiated..."); 
    270292  char *buffer = new char[BUFF_LEN+1]; 
    271   if (fNSAPIGetSettingsString(section.c_str(), key.c_str(), defaultValue.c_str(), buffer, BUFF_LEN) != NSCAPI::success) { 
     293  if (fNSAPIGetSettingsString(section.c_str(), key.c_str(), defaultValue.c_str(), buffer, BUFF_LEN) != NSCAPI::isSuccess) { 
    272294    delete [] buffer; 
    273295    throw NSCMHExcpetion("Settings could not be retrieved."); 
    … …  
    301323    throw NSCMHExcpetion("NSCore has not been initiated..."); 
    302324  char *buffer = new char[BUFF_LEN+1]; 
    303   if (fNSAPIGetApplicationName(buffer, BUFF_LEN) != NSCAPI::success) { 
     325  if (fNSAPIGetApplicationName(buffer, BUFF_LEN) != NSCAPI::isSuccess) { 
    304326    delete [] buffer; 
    305327    throw NSCMHExcpetion("Application name could not be retrieved"); 
    … …  
    318340    throw NSCMHExcpetion("NSCore has not been initiated..."); 
    319341  char *buffer = new char[BUFF_LEN+1]; 
    320   if (fNSAPIGetBasePath(buffer, BUFF_LEN) != NSCAPI::success) { 
     342  if (fNSAPIGetBasePath(buffer, BUFF_LEN) != NSCAPI::isSuccess) { 
    321343    delete [] buffer; 
    322344    throw NSCMHExcpetion("Base path could not be retrieved"); 
    … …  
    390412  NSCModuleHelper::fNSAPIInject = (NSCModuleHelper::lpNSAPIInject)f("NSAPIInject"); 
    391413  NSCModuleHelper::fNSAPIGetBasePath = (NSCModuleHelper::lpNSAPIGetBasePath)f("NSAPIGetBasePath"); 
    392   return NSCAPI::success; 
     414  return NSCAPI::isSuccess; 
    393415} 
    394416/** 
    … …  
    399421* @return buffer copy status 
    400422*/ 
    401 int NSCModuleWrapper::wrapGetModuleName(char* buf, unsigned int bufLen, std::string str) { 
    402   return NSCHelper::wrapReturnString(buf, bufLen, str); 
     423NSCAPI::errorReturn NSCModuleWrapper::wrapGetModuleName(char* buf, unsigned int bufLen, std::string str) { 
     424  return NSCHelper::wrapReturnString(buf, bufLen, str, NSCAPI::isSuccess); 
    403425} 
    404426/** 
    … …  
    410432 * @return NSCAPI::success 
    411433 */ 
    412 int NSCModuleWrapper::wrapGetModuleVersion(int *major, int *minor, int *revision, module_version version) { 
     434NSCAPI::errorReturn NSCModuleWrapper::wrapGetModuleVersion(int *major, int *minor, int *revision, module_version version) { 
    413435  *major = version.major; 
    414436  *minor = version.minor; 
    415437  *revision = version.revision; 
    416   return NSCAPI::success; 
     438  return NSCAPI::isSuccess; 
    417439} 
    418440/** 
    … …  
    421443 * @return NSCAPI::istrue or NSCAPI::isfalse 
    422444 */ 
    423 int NSCModuleWrapper::wrapHasCommandHandler(bool has) { 
     445NSCAPI::boolReturn NSCModuleWrapper::wrapHasCommandHandler(bool has) { 
    424446  if (has) 
    425447    return NSCAPI::istrue; 
    … …  
    431453 * @return NSCAPI::istrue or NSCAPI::isfalse 
    432454 */ 
    433 int NSCModuleWrapper::wrapHasMessageHandler(bool has) { 
     455NSCAPI::boolReturn NSCModuleWrapper::wrapHasMessageHandler(bool has) { 
    434456  if (has) 
    435457    return NSCAPI::istrue; 
    … …  
    443465 * @return copy status or NSCAPI::isfalse if retStr is empty 
    444466 */ 
    445 int NSCModuleWrapper::wrapHandleCommand(const std::string retStr, char *returnBuffer, unsigned int returnBufferLen) { 
    446   if (retStr.empty()) 
    447     return NSCAPI::isfalse; 
    448   return NSCHelper::wrapReturnString(returnBuffer, returnBufferLen, retStr, NSCAPI::handled); 
     467NSCAPI::nagiosReturn NSCModuleWrapper::wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::string retMessage, const std::string retPerformance, char *returnBufferMessage, unsigned int returnBufferMessageLen, char *returnBufferPerf, unsigned int returnBufferPerfLen) { 
     468  if (retMessage.empty()) 
     469    return NSCAPI::returnIgnored; 
     470  NSCAPI::nagiosReturn ret = NSCHelper::wrapReturnString(returnBufferMessage, returnBufferMessageLen, retMessage, retResult); 
     471  return NSCHelper::wrapReturnString(returnBufferPerf, returnBufferPerfLen, retPerformance, ret); 
    449472} 
    450473/** 
    … …  
    455478int NSCModuleWrapper::wrapLoadModule(bool success) { 
    456479  if (success) 
    457     return NSCAPI::success; 
    458   return NSCAPI::failed; 
     480    return NSCAPI::isSuccess; 
     481  return NSCAPI::hasFailed; 
    459482} 
    460483/** 
    … …  
    465488int NSCModuleWrapper::wrapUnloadModule(bool success) { 
    466489  if (success) 
    467     return NSCAPI::success; 
    468   return NSCAPI::failed; 
    469 } 
    470  
    471  
    472  
     490    return NSCAPI::isSuccess; 
     491  return NSCAPI::hasFailed; 
     492} 
     493 
     494 
     495 

  • include/NSCHelper.h

    r2a94f3f r1eef1ee  
    99namespace NSCHelper 
    1010{ 
    11   int wrapReturnString(char *buffer, unsigned int bufLen, std::string str, int defaultReturnCode = NSCAPI::success); 
     11//  int wrapReturnString(char *buffer, unsigned int bufLen, std::string str, int defaultReturnCode); 
     12  NSCAPI::nagiosReturn wrapReturnString(char *buffer, unsigned int bufLen, std::string str, NSCAPI::nagiosReturn defaultReturnCode); 
     13  NSCAPI::errorReturn wrapReturnString(char *buffer, unsigned int bufLen, std::string str, NSCAPI::errorReturn defaultReturnCode); 
    1214 
    1315  std::list<std::string> arrayBuffer2list(const unsigned int argLen, char **argument); 
    … …  
    1921 
    2022  std::string translateMessageType(NSCAPI::messageTypes msgType); 
    21   std::string translateReturn(NSCAPI::returnCodes returnCode); 
    22   inline std::string returnNSCP(NSCAPI::returnCodes returnCode, std::string str) { 
    23     return translateReturn(returnCode) + "&" + str; 
    24   } 
     23  std::string translateReturn(NSCAPI::nagiosReturn returnCode); 
    2524 
    2625  /* 
    … …  
    5352 
    5453 
    55   inline void escalteReturnCode(NSCAPI::returnCodes &currentReturnCode, NSCAPI::returnCodes newReturnCode) { 
     54  inline void escalteReturnCode(NSCAPI::nagiosReturn &currentReturnCode, NSCAPI::nagiosReturn newReturnCode) { 
    5655    if (newReturnCode == NSCAPI::returnCRIT) 
    5756      currentReturnCode = NSCAPI::returnCRIT; 
    … …  
    6362      currentReturnCode = NSCAPI::returnUNKNOWN; 
    6463  } 
    65   inline void escalteReturnCodeToCRIT(NSCAPI::returnCodes &currentReturnCode) { 
     64  inline void escalteReturnCodeToCRIT(NSCAPI::nagiosReturn &currentReturnCode) { 
    6665    currentReturnCode = NSCAPI::returnCRIT; 
    6766  } 
    68   inline void escalteReturnCodeToWARN(NSCAPI::returnCodes &currentReturnCode) { 
     67  inline void escalteReturnCodeToWARN(NSCAPI::nagiosReturn &currentReturnCode) { 
    6968    if (currentReturnCode != NSCAPI::returnCRIT) 
    7069      currentReturnCode = NSCAPI::returnWARN; 
    … …  
    8180  }; 
    8281  // Types for the Callbacks into the main program 
    83   typedef int (*lpNSAPIGetBasePath)(char*,unsigned int); 
    84   typedef int (*lpNSAPIGetApplicationName)(char*,unsigned int); 
    85   typedef int (*lpNSAPIGetApplicationVersionStr)(char*,unsigned int); 
    86   typedef int (*lpNSAPIGetSettingsString)(const char*,const char*,const char*,char*,unsigned int); 
    87   typedef int (*lpNSAPIGetSettingsInt)(const char*, const char*, int); 
     82  typedef NSCAPI::errorReturn (*lpNSAPIGetBasePath)(char*,unsigned int); 
     83  typedef NSCAPI::errorReturn (*lpNSAPIGetApplicationName)(char*,unsigned int); 
     84  typedef NSCAPI::errorReturn (*lpNSAPIGetApplicationVersionStr)(char*,unsigned int); 
     85  typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsString)(const char*,const char*,const char*,char*,unsigned int); 
     86  typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsInt)(const char*, const char*, int); 
    8887  typedef void (*lpNSAPIMessage)(int, const char*, const int, const char*); 
    89   typedef int (*lpNSAPIStopServer)(void); 
    90   typedef int (*lpNSAPIInject)(const char*, const unsigned int, char **, char *, unsigned int ); 
     88  typedef NSCAPI::errorReturn (*lpNSAPIStopServer)(void); 
     89  typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const char*, const unsigned int, char **, char *, unsigned int ); 
    9190  typedef LPVOID (*lpNSAPILoader)(char*); 
    9291 
    … …  
    9796  int getSettingsInt(std::string section, std::string key, int defaultValue); 
    9897  void Message(int msgType, std::string file, int line, std::string message); 
    99   int InjectCommandRAW(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen); 
    100   std::string InjectCommand(const char* command, const unsigned int argLen, char **argument); 
    101   std::string InjectSplitAndCommand(const char* command, char* buffer, char splitChar = '&'); 
     98  NSCAPI::nagiosReturn InjectCommandRAW(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen); 
     99  NSCAPI::nagiosReturn InjectCommand(const char* command, const unsigned int argLen, char **argument, std::string & message, std::string & perf); 
     100  NSCAPI::nagiosReturn InjectSplitAndCommand(const char* command, char* buffer, char splitChar, std::string & message, std::string & perf); 
    102101  void StopService(void); 
    103102  std::string getBasePath(); 
    … …  
    115114 
    116115  int wrapModuleHelperInit(NSCModuleHelper::lpNSAPILoader f);; 
    117   int wrapGetModuleName(char* buf, unsigned int buflen, std::string str); 
     116  NSCAPI::errorReturn wrapGetModuleName(char* buf, unsigned int buflen, std::string str); 
    118117  int wrapLoadModule(bool success); 
    119   int wrapGetModuleVersion(int *major, int *minor, int *revision, module_version version); 
    120   int wrapHasCommandHandler(bool has); 
    121   int wrapHasMessageHandler(bool has); 
     118  NSCAPI::errorReturn wrapGetModuleVersion(int *major, int *minor, int *revision, module_version version); 
     119  NSCAPI::boolReturn wrapHasCommandHandler(bool has); 
     120  NSCAPI::boolReturn wrapHasMessageHandler(bool has); 
    122121  int wrapUnloadModule(bool success); 
    123   int wrapHandleCommand(const std::string retStr, char *returnBuffer, unsigned int returnBufferLen); 
     122  NSCAPI::nagiosReturn wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::string retMessage, const std::string retPerformance, char *returnBufferMessage, unsigned int returnBufferMessageLen, char *returnBufferPerf, unsigned int returnBufferPerfLen); 
    124123} 
    125124 
    … …  
    131130  extern int NSGetModuleName(char* buf, int buflen); \ 
    132131  extern int NSGetModuleVersion(int *major, int *minor, int *revision); \ 
    133   extern int NSHasCommandHandler(); \ 
    134   extern int NSHasMessageHandler(); \ 
     132  extern NSCAPI::boolReturn NSHasCommandHandler(); \ 
     133  extern NSCAPI::boolReturn NSHasMessageHandler(); \ 
    135134  extern void NSHandleMessage(int msgType, char* file, int line, char* message); \ 
    136   extern int NSHandleCommand(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen); \ 
     135  extern NSCAPI::nagiosReturn NSHandleCommand(const char* IN_cmd, const unsigned int IN_argsLen, char **IN_args, \ 
     136    char *OUT_retBufMessage, unsigned int IN_retBufMessageLen, char *OUT_retBufPerf, unsigned int IN_retBufPerfLen); \ 
    137137  extern int NSUnloadModule(); 
    138138 
    … …  
    178178    toObject.handleMessage(msgType, file, line, message); \ 
    179179  } \ 
    180   extern int NSHasMessageHandler() { \ 
     180  extern NSCAPI::boolReturn NSHasMessageHandler() { \ 
    181181    return NSCModuleWrapper::wrapHasMessageHandler(toObject.hasMessageHandler()); \ 
    182182  } 
    183183#define NSC_WRAPPERS_IGNORE_MSG_DEF() \ 
    184184  extern void NSHandleMessage(int msgType, char* file, int line, char* message) {} \ 
    185   extern int NSHasMessageHandler() { return NSCAPI::isfalse; } 
     185  extern NSCAPI::boolReturn NSHasMessageHandler() { return NSCAPI::isfalse; } 
    186186#define NSC_WRAPPERS_HANDLE_CMD_DEF(toObject) \ 
    187   extern int NSHandleCommand(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen) { \ 
    188     return NSCModuleWrapper::wrapHandleCommand(toObject.handleCommand(command, argLen, argument), returnBuffer, returnBufferLen); \ 
    189   } \ 
    190   extern int NSHasCommandHandler() { \ 
     187  extern NSCAPI::nagiosReturn NSHandleCommand(const char* IN_cmd, const unsigned int IN_argsLen, char **IN_args, \ 
     188                  char *OUT_retBufMessage, unsigned int IN_retBufMessageLen, char *OUT_retBufPerf, unsigned int IN_retBufPerfLen) \ 
     189  { \ 
     190    std::string message, perf; \ 
     191    NSCAPI::nagiosReturn retCode = toObject.handleCommand(IN_cmd, IN_argsLen, IN_args, message, perf); \ 
     192    return NSCModuleWrapper::wrapHandleCommand(retCode, message, perf, OUT_retBufMessage, IN_retBufMessageLen, OUT_retBufPerf, IN_retBufPerfLen); \ 
     193  } \ 
     194  extern NSCAPI::boolReturn NSHasCommandHandler() { \ 
    191195    return NSCModuleWrapper::wrapHasCommandHandler(toObject.hasCommandHandler()); \ 
    192196  } 
    193197#define NSC_WRAPPERS_IGNORE_CMD_DEF() \ 
    194   extern int NSHandleCommand(const char* command, const unsigned int argLen, char **argument, char *returnBuffer, unsigned int returnBufferLen) { \ 
    195     return NSCAPI::failed; \ 
    196   } \ 
    197   extern int NSHasCommandHandler() { return NSCAPI::isfalse; } 
     198  extern NSCAPI::nagiosReturn NSHandleCommand(const char* IN_cmd, const unsigned int IN_argsLen, char **IN_args, \ 
     199                  char *OUT_retBufMessage, unsigned int IN_retBufMessageLen, char *OUT_retBufPerf, unsigned int IN_retBufPerfLen) { \ 
     200    return NSCAPI::returnIgnored; \ 
     201  } \ 
     202  extern NSCAPI::boolReturn NSHasCommandHandler() { return NSCAPI::isfalse; } 

  • modules/CheckDisk/CheckDisk.cpp

    r8223547 r1eef1ee  
    8282} 
    8383 
    84 std::string CheckDisk::CheckFileSize(const unsigned int argLen, char **char_args) { 
     84NSCAPI::nagiosReturn CheckDisk::CheckFileSize(const unsigned int argLen, char **char_args, std::string &message, std::string &perf) { 
    8585  // CheckFileSize 
    8686  // request: CheckFileSize&<option>&<option>... 
    … …  
    108108  // WIN: 1G (2110962363B)|WIN:2110962363:1073741824:4294967296 
    109109  NSC_DEBUG_MSG("CheckFileSize"); 
    110   std::string perfData; 
    111   std::string ret; 
    112   NSCAPI::returnCodes returnCode = NSCAPI::returnOK; 
     110  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    113111  std::list<std::string> args = NSCHelper::arrayBuffer2list(argLen, char_args); 
    114   if (args.empty()) 
    115     return "Missing argument(s)."; 
     112  if (args.empty()) { 
     113    message = "Missing argument(s)."; 
     114    return NSCAPI::returnCRIT; 
     115  } 
    116116  long long maxWarn = 0; 
    117117  long long maxCrit = 0; 
    … …  
    142142        paths.push_back(std::pair<std::string,std::string>(p2.second,p.second)); 
    143143      } else { 
    144         return "Unknown command: " + p.first; 
     144        message = "Unknown command: " + p.first; 
     145        return NSCAPI::returnCRIT; 
    145146      } 
    146147    } else { 
    147       return "Unknown command: " + p.first; 
     148      message = "Unknown command: " + p.first; 
     149      return NSCAPI::returnCRIT; 
    148150    } 
    149151  } 
    … …  
    177179    } 
    178180    if (!(*pit).first.empty()) 
    179       perfData += (*pit).first + "=" + strEx::itos(sizeFinder.getSize()) + ";" + strEx::itos(maxWarn) + ";" + strEx::itos(maxCrit) + " "; 
    180     if (!ret.empty() && !tstr.empty()) 
    181       ret += ", "; 
     181      perf += (*pit).first + "=" + strEx::itos(sizeFinder.getSize()) + ";" + strEx::itos(maxWarn) + ";" + strEx::itos(maxCrit) + " "; 
     182    if (!message.empty() && !tstr.empty()) 
     183      message += ", "; 
    182184    if (!tstr.empty()) 
    183       ret += tstr; 
    184   } 
    185   if (ret.empty()) 
    186     ret = "OK all file sizes are within bounds."; 
    187   if (!perfData.empty()) 
    188     ret += "|" + perfData; 
    189   return NSCHelper::returnNSCP(returnCode, ret); 
     185      message += tstr; 
     186  } 
     187  if (message.empty()) 
     188    message = "OK all file sizes are within bounds."; 
     189  return returnCode; 
    190190} 
    191191 
    … …  
    193193#define BUFFER_SIZE 1024*64 
    194194 
    195 std::string CheckDisk::handleCommand(const std::string command, const unsigned int argLen, char **char_args) { 
     195NSCAPI::nagiosReturn CheckDisk::handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &msg, std::string &perf) { 
    196196  if (command == "CheckFileSize") { 
    197     return CheckFileSize(argLen, char_args); 
     197    return CheckFileSize(argLen, char_args, msg, perf); 
    198198//  } else if (command == "CheckFileDate") { 
    199199  }  
    200   return ""; 
     200  return NSCAPI::returnIgnored; 
    201201} 
    202202 

  • modules/CheckDisk/CheckDisk.h

    r36c340d r1eef1ee  
    1414  bool hasCommandHandler(); 
    1515  bool hasMessageHandler(); 
    16   std::string handleCommand(const std::string command, const unsigned int argLen, char **args); 
     16  NSCAPI::nagiosReturn handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &message, std::string &perf); 
    1717 
    1818  // Check commands 
    19   std::string CheckFileSize(const unsigned int argLen, char **char_args); 
     19  NSCAPI::nagiosReturn CheckFileSize(const unsigned int argLen, char **char_args, std::string &message, std::string &perf); 
    2020}; 

  • modules/CheckEventLog/CheckEventLog.cpp

    r8223547 r1eef1ee  
    296296#define BUFFER_SIZE 1024*64 
    297297 
    298 std::string CheckEventLog::handleCommand(const std::string command, const unsigned int argLen, char **char_args) { 
     298NSCAPI::nagiosReturn CheckEventLog::handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &message, std::string &perf) { 
    299299  if (command != "CheckEventLog") 
    300     return ""; 
    301   NSCAPI::returnCodes rCode = NSCAPI::returnOK; 
     300    return NSCAPI::returnIgnored; 
     301  NSCAPI::nagiosReturn rCode = NSCAPI::returnOK; 
    302302  std::list<std::string> args = NSCHelper::arrayBuffer2list(argLen, char_args); 
    303   if (args.size() < 2) 
    304     return "Missing argument"; 
     303  if (args.size() < 2) { 
     304    message = "Missing argument"; 
     305    return NSCAPI::returnCRIT; 
     306  } 
    305307  std::string ret; 
    306308  bool critical = false; 
    … …  
    310312    buildQury(query, args); 
    311313  } catch (std::string s) { 
    312     return NSCHelper::returnNSCP(NSCAPI::returnUNKNOWN, s); 
     314    message = s; 
     315    return NSCAPI::returnCRIT; 
    313316  } 
    314317  NSC_DEBUG_MSG_STD("Base query: " + query.toString()); 
    315318 
    316319  HANDLE hLog = OpenEventLog(NULL, logFile.c_str()); 
    317   if (hLog == NULL)  
    318     return NSCHelper::returnNSCP(NSCAPI::returnUNKNOWN, "Could not open the Application event log."); 
     320  if (hLog == NULL) { 
     321    message = "Could not open the Application event log."; 
     322    return NSCAPI::returnUNKNOWN; 
     323  } 
    319324 
    320325  DWORD dwThisRecord, dwRead, dwNeeded; 
    … …  
    403408  if (query.truncate != 0) 
    404409    ret = ret.substr(0, query.truncate); 
    405   return NSCHelper::returnNSCP(rCode, ret); 
     410  message = ret; 
     411  return rCode; 
    406412} 
    407413 

  • modules/CheckEventLog/CheckEventLog.h

    ra0528c4 r1eef1ee  
    1414  bool hasCommandHandler(); 
    1515  bool hasMessageHandler(); 
    16   std::string handleCommand(const std::string command, const unsigned int argLen, char **args); 
     16  NSCAPI::nagiosReturn handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &message, std::string &perf); 
    1717}; 

  • modules/NRPEListener/NRPEListener.cpp

    r2a94f3f r1eef1ee  
    2222 
    2323bool NRPEListener::loadModule() { 
     24  socketThreadManager.createThread(NULL); 
    2425  return true; 
    2526} 
    2627bool NRPEListener::unloadModule() { 
     28  socketThreadManager.exitThread(); 
    2729  return true; 
    2830} 
    … …  
    4446 
    4547 
    46 std::string NRPEListener::handleCommand(const std::string command, const unsigned int argLen, char **char_args) { 
    47   return ""; 
     48NSCAPI::nagiosReturn NRPEListener::handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &message, std::string &perf) { 
     49  return NSCAPI::returnIgnored; 
    4850} 
    4951 

  • modules/NRPEListener/NRPEListener.h

    r2a94f3f r1eef1ee  
    11NSC_WRAPPERS_MAIN(); 
     2 
     3 
     4#include "NRPESocket.h" 
     5#include <Socket.h> 
    26 
    37class NRPEListener { 
    48private: 
     9  NRPESocketThread socketThreadManager; 
    510 
    611public: 
    … …  
    1419  bool hasCommandHandler(); 
    1520  bool hasMessageHandler(); 
    16   std::string handleCommand(const std::string command, const unsigned int argLen, char **args); 
     21  NSCAPI::nagiosReturn handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &message, std::string &perf); 
    1722}; 
     23 

  • modules/NRPEListener/NRPEListener.vcproj

    r2a94f3f r1eef1ee  
    134134      </File> 
    135135      <File 
     136        RelativePath="..\..\include\Socket.cpp"> 
     137      </File> 
     138      <File 
    136139        RelativePath=".\stdafx.cpp"> 
    137140        <FileConfiguration 
    … …  
    166169      </File> 
    167170      <File 
     171        RelativePath="..\..\include\Socket.h"> 
     172      </File> 
     173      <File 
    168174        RelativePath=".\stdafx.h"> 
    169175      </File> 

  • modules/NRPEListener/NRPESocket.cpp

    r2a94f3f r1eef1ee  
    66 * Default c-tor 
    77 */ 
    8 NRPESocket::NRPESocket(): hStopEvent(NULL) { 
     8NRPESocket::NRPESocket(): SimpleSocketListsner(DEFAULT_NRPE_PORT) { 
    99} 
    1010 
    … …  
    1212} 
    1313 
     14typedef short int16_t; 
     15typedef unsigned long u_int32_t; 
    1416 
    15 /** 
    16  * Thread procedure for the socket listener 
    17  * @param lpParameter Potential argument to the thread proc. 
    18  * @return thread exit status 
    19  * @todo This needs to be reworked, possibly completely redone ? 
    20  */ 
    21 DWORD NRPESocket::threadProc(LPVOID lpParameter) 
    22 { 
    23   hStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 
    24   if (!hStopEvent) { 
    25     NSC_LOG_ERROR_STD("Create StopEvent failed: " + strEx::itos(GetLastError())); 
    26     return 0; 
    27   } 
     17typedef struct packet_struct{ 
     18  int16_t   packet_version; 
     19  int16_t   packet_type; 
     20  u_int32_t crc32_value; 
     21  int16_t   result_code; 
     22  char      buffer[1024]; 
     23}packet; 
    2824 
    29   WSADATA wsaData; 
    30   sockaddr_in local; 
    31   int wsaret=WSAStartup(0x101,&wsaData); 
    32   if(wsaret!=0) { 
    33     NSC_LOG_ERROR_STD("WSA Startup failed: " + strEx::itos(wsaret)); 
    34     return 0; 
    35   } 
     25void NRPESocket::onAccept(SOCKET client) { 
     26  NSC_DEBUG_MSG("Accepting connection from remote host"); 
    3627 
    37   local.sin_family=AF_INET; 
    38   local.sin_addr.s_addr=INADDR_ANY; 
    39   local.sin_port=htons(static_cast<u_short>(NSCModuleHelper::getSettingsInt("NRPE", "port", DEFAULT_NRPE_PORT))); 
    40   server=socket(AF_INET,SOCK_STREAM,0); 
    41   if(server==INVALID_SOCKET) { 
    42     WSACleanup(); 
    43     NSC_LOG_ERROR_STD("Could not create listening socket: " + strEx::itos(GetLastError())); 
    44     return 0; 
    45   } 
     28  SimpleSocketListsner::readAllDataBlock block = SimpleSocketListsner::readAll(client); 
     29  packet *p = reinterpret_cast<packet*>(block.first); 
     30  /* 
     31  char* foo = new char[1024]; 
     32  sprintf(foo, "packet_version = %d, packet_type = %d, crc32 = %d, result_code = %d", 
     33    ntohs(p->packet_version), ntohs(p->packet_type), ntohl(p->crc32_value), ntohs(p->result_code)); 
    4634 
    47   if(bind(server,(sockaddr*)&local,sizeof(local))!=0) { 
    48     closesocket(server); 
    49     WSACleanup(); 
    50     NSC_LOG_ERROR_STD("Could not bind socket: " + strEx::itos(GetLastError())); 
    51     return 0; 
    52   } 
     35  NSC_DEBUG_MSG_STD("Incoming header: " + foo); 
     36  */ 
     37  // @todo Verify versions and stuff, and ofcource add SSL (but thats in the future :) 
     38  NSC_DEBUG_MSG_STD("Incoming data: " + p->buffer); 
    5339 
    54   if(listen(server,10)!=0) { 
    55     closesocket(server); 
    56     WSACleanup(); 
    57     NSC_LOG_ERROR_STD("Could not open socket: " + strEx::itos(GetLastError())); 
    58     return 0; 
    59   } 
     40  charEx::token cmd = charEx::getToken(p->buffer, '!'); 
     41  std::string msg, perf; 
     42  NSCModuleHelper::InjectSplitAndCommand(cmd.first.c_str(), cmd.second, '!', msg, perf); 
    6043 
    61   SOCKET client; 
    62   sockaddr_in from; 
    63   int fromlen=sizeof(from); 
    64 #define RECV_BUFFER_LEN 1024 
    65   while (!(WaitForSingleObject(hStopEvent, 100) == WAIT_OBJECT_0)) { 
    66     client=accept(server, (struct sockaddr*)&from,&fromlen); 
    67     if (client != INVALID_SOCKET) { 
    68       char *buff = new char[RECV_BUFFER_LEN+1]; 
    69       int n=recv(client,buff,RECV_BUFFER_LEN,0); 
    70       if ((n!=SOCKET_ERROR )&&(n > 0)&&(n < RECV_BUFFER_LEN)) { 
    71         buff[n] = '\0'; 
    72         NSC_DEBUG_MSG("Incoming data: "); 
    73         NSC_DEBUG_MSG(buff); 
    74         std::string ret = "fool"; //parseCommand(buff); 
    75         NSC_DEBUG_MSG("Outgoing data: "); 
    76         NSC_DEBUG_MSG(ret.c_str()); 
    77         send(client, ret.c_str(), ret.length(), 0); 
    78       } else { 
    79         std::string str = "ERROR: Unknown socket error"; 
    80         send(client,str.c_str(),str.length(),0); 
    81       } 
    82       delete [] buff; 
    83       closesocket(client); 
    84     } 
    85   } 
    86   closesocket(server); 
    87   WSACleanup(); 
    88   NSC_DEBUG_MSG("Socket closed!"); 
    89   return 0; 
     44  delete [] block.first; 
     45  closesocket(client); 
    9046} 
    9147 
    92 /** 
    93  * Exit thread callback proc.  
    94  * This is called by the thread manager when the thread should initiate a shutdown procedure. 
    95  * The thread manager is responsible for waiting for the actual termination of the thread. 
    96  */ 
    97 void NRPESocket::exitThread(void) { 
    98   NSC_DEBUG_MSG("Requesting shutdown!"); 
    99   if (!SetEvent(hStopEvent)) { 
    100     NSC_LOG_ERROR_STD("SetStopEvent failed"); 
    101   } 
    102 } 

  • modules/NRPEListener/NRPESocket.h

    r2a94f3f r1eef1ee  
    44#include <Mutex.h> 
    55#include <WinSock2.h> 
     6#include <Socket.h> 
    67/** 
    78 * @ingroup NSClient++ 
    … …  
    2829 * 
    2930 */ 
    30 class NRPESocket { 
     31 
     32#define DEFAULT_NRPE_PORT 5666 
     33 
     34 
     35class NRPESocket : public SimpleSocketListsner { 
    3136private: 
    32   MutexHandler mutexHandler; 
    33   SOCKET server; 
    34   HANDLE hStopEvent; 
    3537 
    3638public: 
    3739  NRPESocket(); 
    3840  virtual ~NRPESocket(); 
    39   DWORD threadProc(LPVOID lpParameter); 
    40   void exitThread(void); 
    4141 
    4242private: 
    43   bool isRunning(void); 
    44   void stopRunning(void); 
    45   void startRunning(void); 
    46   std::list<std::string> split(char* buffer); 
    47   std::string parseCommand(char* request); 
     43  virtual void onAccept(SOCKET client); 
    4844}; 
    49 #define DEFAULT_NRPE_PORT 5666 
    50  
    5145 
    5246 

  • modules/NSClientCompat/NSClientCompat.cpp

    r8223547 r1eef1ee  
    107107 * @return  
    108108 */ 
    109 std::string NSClientCompat::handleCommand(const std::string command, const unsigned int argLen, char **args) { 
     109NSCAPI::nagiosReturn NSClientCompat::handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &msg, std::string &perf) { 
    110110  std::list<std::string> stl_args; 
    111111  int id = atoi(command.c_str()); 
    112112  if (id == 0) 
    113     return ""; 
     113    return NSCAPI::returnIgnored; 
    114114  switch (id) { 
    115115    case REQ_CLIENTVERSION: 
    116116      { 
    117         std::string version = NSCModuleHelper::getSettingsString("nsclient compat", "version", "modern"); 
    118         if (version == "modern") 
    119           return NSCModuleHelper::getApplicationName() + " " + NSCModuleHelper::getApplicationVersionString(); 
    120         return version; 
     117        std::string msg = NSCModuleHelper::getSettingsString("nsclient compat", "version", "modern"); 
     118        if (msg == "modern") 
     119          msg = NSCModuleHelper::getApplicationName() + " " + NSCModuleHelper::getApplicationVersionString(); 
     120        return NSCAPI::returnOK; 
    121121      } 
    122122    case REQ_UPTIME: 
    123       return strEx::itos(pdhCollector->getUptime()); 
     123      msg= strEx::itos(pdhCollector->getUptime()); 
     124      return NSCAPI::returnOK; 
    124125 
    125126    case REQ_CPULOAD: 
    126127      { 
    127         stl_args = NSCHelper::arrayBuffer2list(argLen, args); 
    128         if (stl_args.empty()) 
    129           return "ERROR: Missing argument exception."; 
    130         std::string ret; 
     128        stl_args = NSCHelper::arrayBuffer2list(argLen, char_args); 
     129        if (stl_args.empty()) { 
     130          msg = "ERROR: Missing argument exception."; 
     131          return NSCAPI::returnCRIT; 
     132        } 
    131133        while (!stl_args.empty()) { 
    132134          std::string s = stl_args.front(); stl_args.pop_front(); 
    133135          int v = pdhCollector->getCPUAvrage(strEx::stoi(s)*(60/CHECK_INTERVAL)); 
    134           if (v == -1) 
    135             return ret; 
    136           if (!ret.empty()) 
    137             ret += "&"; 
    138           ret += strEx::itos(v); 
     136          if (v == -1) { 
     137            return NSCAPI::returnOK; 
     138          } 
     139          if (!msg.empty()) 
     140            msg += "&"; 
     141          msg += strEx::itos(v); 
    139142        } 
    140         return ret; 
     143        return NSCAPI::returnOK; 
    141144      } 
     145      /* 
    142146    case REQ_SERVICESTATE: 
    143147      return NSCommands::serviceState(NSCHelper::arrayBuffer2list(argLen, args)); 
    … …  
    152156    case REQ_USEDDISKSPACE: 
    153157      return NSCommands::usedDiskSpace(NSCHelper::arrayBuffer2list(argLen, args)); 
     158      */ 
    154159  } 
    155   return ""; 
     160  return NSCAPI::returnIgnored; 
    156161} 
    157162 

  • modules/NSClientCompat/NSClientCompat.h

    ra0528c4 r1eef1ee  
    1818  bool hasCommandHandler(); 
    1919  bool hasMessageHandler(); 
    20   std::string handleCommand(const std::string command, const unsigned int argLen, char **args); 
     20  NSCAPI::nagiosReturn handleCommand(const std::string command, const unsigned int argLen, char **char_args, std::string &msg, std::string &perf); 
    2121}; 

  • modules/NSClientListener/NSClientSocket.cpp

    r2a94f3f r1eef1ee  
    8383  charEx::token cmd = charEx::getToken(pwd.second, '&'); 
    8484  NSC_DEBUG_MSG("Command: " + cmd.first); 
    85   return NSCModuleHelper::InjectSplitAndCommand(cmd.first.c_str(), cmd.second, '&'); 
     85  std::string message, perf; 
     86  NSCAPI::nagiosReturn ret = NSCModuleHelper::InjectSplitAndCommand(cmd.first.c_str(), cmd.second, '&', message, perf); 
     87  // @todo fix some way to interpret return code 
     88  return message; 
    8689} 
    8790 
Note: See TracChangeset for help on using the changeset viewer.