Changeset 1eef1ee in nscp for modules


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
Location:
modules
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • 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.