Changeset 3136203 in nscp


Ignore:
Timestamp:
01/03/11 08:16:46 (2 years ago)
Author:
Michael Medin <michael@…>
Branches:
stable
Children:
349a44a
Parents:
aab5b07
Message:

some merge fixes to syncronize streams between 0.3.x and 0.4.x

Files:
12 edited

Legend:

Unmodified
Added
Removed

  • AutoBuild.h

    r41ca52e r3136203  
    33// change the FALSE to TRUE for autoincrement of build number 
    44#define INCREMENT_VERSION TRUE 
    5 #define FILEVER        0,3,9,222 
    6 #define PRODUCTVER     0,3,9,222 
    7 #define STRFILEVER     _T("0.3.9.222") 
    8 #define STRPRODUCTVER  _T("0.3.9.222") 
    9 #define STRPRODUCTDATE  _T("2010-12-26") 
     5#define FILEVER        0,3,9,227 
     6#define PRODUCTVER     0,3,9,227 
     7#define STRFILEVER     _T("0.3.9.227") 
     8#define STRPRODUCTVER  _T("0.3.9.227") 
     9#define STRPRODUCTDATE  _T("2010-12-31") 
    1010#endif // AUTOBUILD_H 

  • NSC.dist

    r41ca52e r3136203  
    1717;CheckHelpers.dll 
    1818;CheckWMI.dll 
     19;CheckNSCP.dll 
    1920; 
    2021; Script to check external scripts and/or internal aliases. 

  • changelog

    r41ca52e r3136203  
    1414 * General improvments to the crash helper. 
    1515 * Added check_nscp which is a basic command to check the internal health of NSClient++ 
     16 * Added check_files (script) submitted by  
    1617 
    17182010-12-25 MickeM 

  • include/arrayBuffer.cpp

    r1d6bb09 r3136203  
    2828 * @return Argument wrapped as a list 
    2929 */ 
    30 arrayBuffer::arrayList arrayBuffer::arrayBuffer2list(const unsigned int argLen, TCHAR *argument[]) { 
     30arrayBuffer::arrayList arrayBuffer::arrayBuffer2list(const unsigned int argLen, wchar_t *argument[]) { 
    3131  arrayList ret; 
    3232  int i=0; 
    … …  
    4343 * @return Argument wrapped as a list 
    4444 */ 
    45 arrayBuffer::arrayVector arrayBuffer::arrayBuffer2vector(const unsigned int argLen, TCHAR *argument[]) { 
     45arrayBuffer::arrayVector arrayBuffer::arrayBuffer2vector(const unsigned int argLen, wchar_t *argument[]) { 
    4646  arrayVector ret; 
    4747  int i=0; 
    … …  
    6868  for (i=0;it!=lst.end();++it,i++) { 
    6969    std::wstring::size_type alen = (*it).size(); 
    70     arrayBuffer[i] = new TCHAR[alen+2]; 
     70    arrayBuffer[i] = new wchar_t[alen+2]; 
    7171    wcsncpy_s(arrayBuffer[i], alen+2, (*it).c_str(), alen+1); 
    7272  } 
    … …  
    122122* @return The arrayBuffer 
    123123*/ 
    124 arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const TCHAR* buffer, TCHAR splitChar, unsigned int &argLen) { 
     124arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const wchar_t* buffer, wchar_t splitChar, unsigned int &argLen) { 
    125125  if (!buffer) 
    126126    throw ArrayBufferException(_T("Invalid buffer specified!")); 
    127127  argLen = 0; 
    128   const TCHAR *p = buffer; 
     128  const wchar_t *p = buffer; 
    129129  if (!p[0]) { 
    130130    return createEmptyArrayBuffer(argLen); 
    … …  
    136136  } 
    137137  argLen++; 
    138   TCHAR **arrayBuffer = new TCHAR*[argLen]; 
     138  wchar_t **arrayBuffer = new wchar_t*[argLen]; 
    139139  p = buffer; 
    140140  for (unsigned int i=0;i<argLen;i++) { 
    141     const TCHAR *q = wcschr(p, (i<argLen-1)?splitChar:0); 
     141    const wchar_t *q = wcschr(p, (i<argLen-1)?splitChar:0); 
    142142    unsigned int len = static_cast<int>(q-p); 
    143     arrayBuffer[i] = new TCHAR[len+1]; 
     143    arrayBuffer[i] = new wchar_t[len+1]; 
    144144    wcsncpy_s(arrayBuffer[i], len+1, p, len); 
    145145    arrayBuffer[i][len] = 0; 
    … …  
    155155  delete [] arrayBuffer[position]; 
    156156  size_t len = argument.length(); 
    157   arrayBuffer[position] = new TCHAR[len+2]; 
     157  arrayBuffer[position] = new wchar_t[len+2]; 
    158158  wcsncpy_s(arrayBuffer[position], len+1, argument.c_str(), len); 
    159159  arrayBuffer[position][len] = 0; 
    … …  
    168168 * @return The arrayBuffer 
    169169 */ 
    170 arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const std::wstring inBuf, TCHAR splitChar, unsigned int &argLen, bool escape) { 
     170arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const std::wstring inBuf, wchar_t splitChar, unsigned int &argLen, bool escape) { 
    171171  if (inBuf.empty()) 
    172172    return createEmptyArrayBuffer(argLen); 
    … …  
    191191    // p1 = start of "this token" 
    192192    // p2 = end of "this token" (next split char) 
    193     //std::wcout << _T("found token: ") << p1 << _T(":") << p2; 
    194193 
    195194    if (p2<=p1) 
    … …  
    201200      token = token.substr(0, token.size()-1); 
    202201 
    203     //std::wcout << _T(" -- ") << token << std::endl; 
    204202 
    205203    token_list.push_back(token); 
    … …  
    214212  for (std::list<std::wstring>::const_iterator cit=token_list.begin();cit!=token_list.end();++cit) { 
    215213    size_t len = (*cit).size(); 
    216     TCHAR* token = new TCHAR[len+1]; 
     214    wchar_t* token = new wchar_t[len+1]; 
    217215    wcsncpy_s(token, len+1, (*cit).c_str(), len); 
    218216    arrayBuffer[argLen++] = token; 
    … …  
    306304  std::wcout << "arrayBuffer::test_createEmptyArrayBuffer() : "; 
    307305  unsigned int argLen; 
    308   TCHAR ** c = createEmptyArrayBuffer(argLen); 
     306  wchar_t ** c = createEmptyArrayBuffer(argLen); 
    309307  if ((c) && (argLen == 0)) 
    310308    std::wcout << "Succeeded" << std::endl; 
    … …  
    319317 * @param OUT_argLen  
    320318 */ 
    321 void arrayBuffer::test_split2arrayBuffer_str(std::wstring buffer, TCHAR splitter, int OUT_argLen) { 
     319void arrayBuffer::test_split2arrayBuffer_str(std::wstring buffer, wchar_t splitter, int OUT_argLen) { 
    322320  std::wcout << _T("arrayBuffer::test_split2arrayBuffer(") << buffer << _T(", ...) : "); 
    323321  unsigned int argLen = 0; 
    324   TCHAR ** c = split2arrayBuffer(buffer, splitter, argLen); 
     322  wchar_t ** c = split2arrayBuffer(buffer, splitter, argLen); 
    325323  if ((c) && (argLen == OUT_argLen)) 
    326324    std::wcout << _T("Succeeded") << std::endl; 
    … …  
    335333 * @param OUT_argLen  
    336334 */ 
    337 void arrayBuffer::test_split2arrayBuffer_char(TCHAR* buffer, TCHAR splitter, int OUT_argLen) { 
     335void arrayBuffer::test_split2arrayBuffer_char(wchar_t* buffer, wchar_t splitter, int OUT_argLen) { 
    338336  std::wcout << _T("arrayBuffer::test_split2arrayBuffer(") << buffer << _T(", ...) : "); 
    339337  unsigned int argLen = 0; 
    340   TCHAR ** c = split2arrayBuffer(buffer, splitter, argLen); 
     338  wchar_t ** c = split2arrayBuffer(buffer, splitter, argLen); 
    341339  if ((c) && (argLen == OUT_argLen)) 
    342340    std::wcout << _T("Succeeded") << std::endl; 

  • include/arrayBuffer.h

    r1d6bb09 r3136203  
    5555    ArrayBufferException(std::wstring error) {} 
    5656  }; 
    57   typedef TCHAR* arrayBufferItem; 
     57  typedef wchar_t* arrayBufferItem; 
    5858  typedef arrayBufferItem* arrayBuffer; 
    5959  typedef std::list<std::wstring> arrayList; 
    6060  typedef std::vector<std::wstring> arrayVector; 
    6161  void set(arrayBuffer arrayBuffer, const unsigned int argLen, const unsigned int position, std::wstring argument); 
    62   arrayList arrayBuffer2list(const unsigned int argLen, TCHAR **argument); 
     62  arrayList arrayBuffer2list(const unsigned int argLen, wchar_t **argument); 
    6363  arrayVector arrayBuffer2vector(const unsigned int argLen, TCHAR **argument); 
    6464  arrayBuffer list2arrayBuffer(const arrayList lst, unsigned int &argLen); 
    65   arrayBuffer split2arrayBuffer(const TCHAR* buffer, TCHAR splitChar, unsigned int &argLen); 
    66   arrayBuffer split2arrayBuffer(const std::wstring inBuf, TCHAR splitChar, unsigned int &argLen, bool escape = false); 
    67   std::wstring arrayBuffer2string(TCHAR **argument, const unsigned int argLen, std::wstring join); 
     65  arrayBuffer split2arrayBuffer(const wchar_t* buffer, wchar_t splitChar, unsigned int &argLen); 
     66  arrayBuffer split2arrayBuffer(const std::wstring inBuf, wchar_t splitChar, unsigned int &argLen, bool escape = false); 
     67  std::wstring arrayBuffer2string(wchar_t **argument, const unsigned int argLen, std::wstring join); 
    6868  arrayBuffer createEmptyArrayBuffer(unsigned int &argLen); 
    6969  arrayBuffer createArrayBuffer(unsigned int &argLen); 
    … …  
    7373    for (unsigned int i=0; i<argLen; i++) { 
    7474      size_t s = wcslen(other[i]); 
    75       ret[i] = new TCHAR[s+2]; 
     75      ret[i] = new wchar_t[s+2]; 
    7676      wcsncpy_s(ret[i], s+2, other[i], s); 
    7777    } 
    … …  
    8181#ifdef _DEBUG 
    8282  void test_createEmptyArrayBuffer(); 
    83   void test_split2arrayBuffer_str(std::wstring buffer, TCHAR splitter, int OUT_argLen); 
    84   void test_split2arrayBuffer_char(TCHAR* buffer, TCHAR splitter, int OUT_argLen); 
     83  void test_split2arrayBuffer_str(std::wstring buffer, wchar_t splitter, int OUT_argLen); 
     84  void test_split2arrayBuffer_char(wchar_t* buffer, wchar_t splitter, int OUT_argLen); 
    8585  void run_testArrayBuffer(); 
    8686#endif 

  • include/pdh/collectors.hpp

    r41ca52e r3136203  
    113113  }; 
    114114 
     115  class PDHCollector : public PDH::PDHCounterListener{ 
     116  public: 
     117    virtual std::wstring get_string() = 0; 
     118    virtual double get_double() = 0; 
     119    virtual __int64 get_int64() = 0; 
     120    virtual double get_average(int backlog) = 0; 
     121  }; 
     122 
     123 
    115124  template <class TType, int TCollectionFormat, class TMutextHandler = PDHCounterNoMutex> 
    116125  class StaticPDHCounterListener { 
    … …  
    118127 
    119128  template <class TType, class TMutextHandler> 
    120   class StaticPDHCounterListener<TType, format_double, TMutextHandler> : public PDH::PDHCounterListener { 
     129  class StaticPDHCounterListener<TType, format_double, TMutextHandler> : public PDHCollector { 
    121130    TType value_; 
    122131    TMutextHandler mutex_; 
    … …  
    146155      return format_double; 
    147156    } 
     157  public: 
     158    inline std::wstring get_string() { 
     159      return strEx::itos(getValue()); 
     160    } 
     161    inline double get_double() { 
     162      return static_cast<double>(getValue()); 
     163    } 
     164    __int64 get_int64() { 
     165      return getValue(); 
     166    } 
     167    inline double get_average(int backlog) { 
     168      return static_cast<double>(getValue()); 
     169    } 
    148170  private: 
    149171    std::wstring get_name() const { 
    … …  
    155177 
    156178  template <class TType, class TMutextHandler> 
    157   class StaticPDHCounterListener<TType, format_long, TMutextHandler> : public PDH::PDHCounterListener { 
     179  class StaticPDHCounterListener<TType, format_long, TMutextHandler> : public PDHCollector { 
    158180    TType value_; 
    159181    TMutextHandler mutex_; 
    … …  
    181203    DWORD getFormat() const { 
    182204      return format_long; 
     205    } 
     206    inline std::wstring get_string() { 
     207      return strEx::itos(getValue()); 
     208    } 
     209    inline double get_double() { 
     210      return static_cast<double>(getValue()); 
     211    } 
     212    __int64 get_int64() { 
     213      return getValue(); 
     214    } 
     215    inline double get_average(int backlog) { 
     216      return static_cast<double>(getValue()); 
    183217    } 
    184218  private: 
    … …  
    191225 
    192226  template <class TType, class TMutextHandler> 
    193   class StaticPDHCounterListener<TType, format_large, TMutextHandler> : public PDH::PDHCounterListener { 
     227  class StaticPDHCounterListener<TType, format_large, TMutextHandler> : public PDHCollector { 
    194228    TMutextHandler mutex_; 
    195229    TType value_; 
    … …  
    217251    DWORD getFormat() const { 
    218252      return format_large; 
     253    } 
     254    inline std::wstring get_string() { 
     255      return strEx::itos(getValue()); 
     256    } 
     257    inline double get_double() { 
     258      return static_cast<double>(getValue()); 
     259    } 
     260    __int64 get_int64() { 
     261      return getValue(); 
     262    } 
     263    inline double get_average(int backlog) { 
     264      return static_cast<double>(getValue()); 
    219265    } 
    220266  private: 
    … …  
    228274 
    229275  template <class TType, class TMutextHandler> 
    230   class RoundINTPDHBufferListenerImpl : public PDH::PDHCounterListener { 
     276  class RoundINTPDHBufferListenerImpl : public PDHCollector { 
    231277    TMutextHandler mutex_; 
    232278    unsigned int length; 
    … …  
    238284    RoundINTPDHBufferListenerImpl() : buffer(NULL), length(0), current(0), hasValue_(false), parent_(NULL) {} 
    239285    RoundINTPDHBufferListenerImpl(int length_) : length(length_), current(0), hasValue_(false), parent_(NULL) { 
    240       PDHCounterMutexHandler mutex(mutex_); 
    241       if (!mutex.hasLock()) 
    242         return; 
    243       buffer = new int[length]; 
     286      PDHCounterMutexHandler mutex(&mutex_); 
     287      if (!mutex.hasLock()) 
     288        return; 
     289      buffer = new TType[length]; 
    244290      for (unsigned int i=0; i<length;i++) 
    245291        buffer[i] = 0; 
    … …  
    313359      return (ret/backItems); 
    314360    } 
     361    inline std::wstring get_string() { 
     362      return strEx::itos(getAvrage(length-1)); 
     363    } 
     364    inline double get_double() { 
     365      return getAvrage(length-1); 
     366    } 
     367    __int64 get_int64() { 
     368      return static_cast<__int64>(getAvrage(length-1)); 
     369    } 
     370    inline double get_average(int backlog) { 
     371      return getAvrage(backlog); 
     372    } 
    315373    inline unsigned int getLength() const { 
    316374      return length; 

  • include/pdh/counters.hpp

    r42ff14d r3136203  
    4444    std::wstring name_; 
    4545    PDH_FMT_COUNTERVALUE data_; 
    46     PDHCounterListener *listener_; 
     46    typedef PDHCounterListener* listener_ptr; 
     47    listener_ptr listener_; 
    4748 
    4849  public: 
    4950 
    50     PDHCounter(std::wstring name, PDHCounterListener *listener) : name_(name), listener_(listener), hCounter_(NULL){} 
     51    PDHCounter(std::wstring name, listener_ptr listener) : name_(name), listener_(listener), hCounter_(NULL){} 
    5152    PDHCounter(std::wstring name) : name_(name), listener_(NULL), hCounter_(NULL){} 
    5253    virtual ~PDHCounter(void) { 
    … …  
    5556    } 
    5657 
    57     void setListener(PDHCounterListener *listener) { 
     58    void setListener(listener_ptr listener) { 
    5859      listener_ = listener; 
    5960    } 

  • include/pdh/query.hpp

    r42ff14d r3136203  
    3131  class PDHQuery : public PDH::PDHImplSubscriber { 
    3232  private: 
    33     typedef std::list<PDHCounter*> CounterList; 
     33    typedef PDHCounter* counter_ptr; 
     34    typedef PDHCounterListener* listener_ptr; 
     35    typedef std::list<counter_ptr> CounterList; 
    3436    CounterList counters_; 
    3537    PDH::PDH_HQUERY hQuery_; 
    … …  
    4143    } 
    4244 
    43     PDHCounter* addCounter(std::wstring name, PDHCounterListener *listener) { 
    44       PDHCounter *counter = new PDHCounter(name, listener); 
     45    counter_ptr addCounter(std::wstring name, listener_ptr listener) { 
     46      counter_ptr counter = new PDHCounter(name, listener); 
    4547      counters_.push_back(counter); 
    4648      return counter; 
    4749    } 
    48     PDHCounter* addCounter(std::wstring name) { 
    49       PDHCounter *counter = new PDHCounter(name); 
     50    counter_ptr addCounter(std::wstring name) { 
     51      counter_ptr counter = new PDHCounter(name); 
    5052      counters_.push_back(counter); 
    5153      return counter; 

  • modules/CheckEventLog/CheckEventLog.cpp

    r41ca52e r3136203  
    5656#include <parsers/ast.cpp> 
    5757 
     58 
     59bool CheckEventLog::loadModule() { 
     60  try { 
     61    NSCModuleHelper::registerCommand(_T("CheckEventLog"), _T("Check for errors in the event logger!")); 
     62    debug_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_DEBUG, EVENTLOG_DEBUG_DEFAULT)==1; 
     63    lookup_names_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_LOOKUP_NAMES, EVENTLOG_LOOKUP_NAMES_DEFAULT)==1; 
     64    syntax_ = NSCModuleHelper::getSettingsString(EVENTLOG_SECTION_TITLE, EVENTLOG_SYNTAX, EVENTLOG_SYNTAX_DEFAULT); 
     65    buffer_length_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_BUFFER, EVENTLOG_BUFFER_DEFAULT); 
     66  } catch (NSCModuleHelper::NSCMHExcpetion &e) { 
     67    NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_); 
     68    return false; 
     69  } catch (...) { 
     70    NSC_LOG_ERROR_STD(_T("Failed to register command.")); 
     71    return false; 
     72  } 
     73  /* 
     74  parse(_T("321 = 123")); 
     75  parse(_T("123 = 123")); 
     76  parse(_T("id = 123")); 
     77  parse(_T("id = 321")); 
     78 
     79  parse(_T("id = '123'")); 
     80  parse(_T("id = '321'")); 
     81 
     82  parse(_T("id = convert(123)")); 
     83  parse(_T("id = convert(321)")); 
     84 
     85  parse(_T("id = 123 AND 123 = 123 AND id = 123x")); 
     86  parse(_T("id = 123 AND 123 = 321 OR 123 = 456 OR 123 = 123")); 
     87   
     88  parse(_T("foo")); 
     89  parse(_T("1")); 
     90  parse(_T("foo = ")); 
     91  parse(_T("foo = 1")); 
     92  parse(_T("'foo' = 1")); 
     93  parse(_T("foo = '1'")); 
     94  parse(_T("'hello'='world'")); 
     95 
     96  parse(_T("foo = bar")); 
     97  parse(_T("foo = bar AND bar = foo")); 
     98  parse(_T("foo = bar AND bar = 1")); 
     99  parse(_T("foo = bar AND bar = foo OR foo = bar")); 
     100  parse(_T("foo = bar AND bar = 1 OR foo = 1")); 
     101  parse(_T(" foo = bar AND ( test > 120 OR foo < 123) OR ugh IN (123, 456, 789)")); 
     102 
     103  parse(_T("aaa = 111 OR bbb = 222 OR ccc = 333")); 
     104  parse(_T("(aaa = 111) OR bbb = 222 OR ccc = 333")); 
     105  parse(_T("(aaa = 111 OR bbb = 222) OR ccc = 333")); 
     106  parse(_T("(aaa = 111 OR bbb = 222 OR ccc = 333)")); 
     107  parse(_T("aaa = 111 OR (bbb = 222 OR ccc = 333)")); 
     108  parse(_T("aaa = 111 OR bbb = 222 OR (ccc = 333)")); 
     109  parse(_T("ccc = -333")); 
     110  parse(_T("ccc = -333 AND ccc = to_date('AABBCC', 1234)")); 
     111  parse(_T("aaa = 111 OR bbb = 222 OR (ccc = -333)")); 
     112  parse(_T("ccc = -333 AND ccc = to_date('AABBCC', 1234) OR aaa = 123x")); 
     113  parse(_T("ccc = -333 AND ccc = to_date('AABBCC', 1234) OR aaa = 123x OR 123r = foo123")); 
     114*/ 
     115  return true; 
     116} 
     117bool CheckEventLog::unloadModule() { 
     118  return true; 
     119} 
     120 
     121bool CheckEventLog::hasCommandHandler() { 
     122  return true; 
     123} 
     124bool CheckEventLog::hasMessageHandler() { 
     125  return false; 
     126} 
    58127namespace filter { 
    59128  namespace where { 
    … …  
    415484} 
    416485 
    417 bool CheckEventLog::loadModule() { 
    418   try { 
    419     NSCModuleHelper::registerCommand(_T("CheckEventLog"), _T("Check for errors in the event logger!")); 
    420     debug_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_DEBUG, EVENTLOG_DEBUG_DEFAULT)==1; 
    421     lookup_names_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_LOOKUP_NAMES, EVENTLOG_LOOKUP_NAMES_DEFAULT)==1; 
    422     syntax_ = NSCModuleHelper::getSettingsString(EVENTLOG_SECTION_TITLE, EVENTLOG_SYNTAX, EVENTLOG_SYNTAX_DEFAULT); 
    423     buffer_length_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_BUFFER, EVENTLOG_BUFFER_DEFAULT); 
    424   } catch (NSCModuleHelper::NSCMHExcpetion &e) { 
    425     NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_); 
    426   } catch (...) { 
    427     NSC_LOG_ERROR_STD(_T("Failed to register command.")); 
    428   } 
    429   /* 
    430   parse(_T("321 = 123")); 
    431   parse(_T("123 = 123")); 
    432   parse(_T("id = 123")); 
    433   parse(_T("id = 321")); 
    434  
    435   parse(_T("id = '123'")); 
    436   parse(_T("id = '321'")); 
    437  
    438   parse(_T("id = convert(123)")); 
    439   parse(_T("id = convert(321)")); 
    440  
    441   parse(_T("id = 123 AND 123 = 123 AND id = 123x")); 
    442   parse(_T("id = 123 AND 123 = 321 OR 123 = 456 OR 123 = 123")); 
    443    
    444   parse(_T("foo")); 
    445   parse(_T("1")); 
    446   parse(_T("foo = ")); 
    447   parse(_T("foo = 1")); 
    448   parse(_T("'foo' = 1")); 
    449   parse(_T("foo = '1'")); 
    450   parse(_T("'hello'='world'")); 
    451  
    452   parse(_T("foo = bar")); 
    453   parse(_T("foo = bar AND bar = foo")); 
    454   parse(_T("foo = bar AND bar = 1")); 
    455   parse(_T("foo = bar AND bar = foo OR foo = bar")); 
    456   parse(_T("foo = bar AND bar = 1 OR foo = 1")); 
    457   parse(_T(" foo = bar AND ( test > 120 OR foo < 123) OR ugh IN (123, 456, 789)")); 
    458  
    459   parse(_T("aaa = 111 OR bbb = 222 OR ccc = 333")); 
    460   parse(_T("(aaa = 111) OR bbb = 222 OR ccc = 333")); 
    461   parse(_T("(aaa = 111 OR bbb = 222) OR ccc = 333")); 
    462   parse(_T("(aaa = 111 OR bbb = 222 OR ccc = 333)")); 
    463   parse(_T("aaa = 111 OR (bbb = 222 OR ccc = 333)")); 
    464   parse(_T("aaa = 111 OR bbb = 222 OR (ccc = 333)")); 
    465   parse(_T("ccc = -333")); 
    466   parse(_T("ccc = -333 AND ccc = to_date('AABBCC', 1234)")); 
    467   parse(_T("aaa = 111 OR bbb = 222 OR (ccc = -333)")); 
    468   parse(_T("ccc = -333 AND ccc = to_date('AABBCC', 1234) OR aaa = 123x")); 
    469   parse(_T("ccc = -333 AND ccc = to_date('AABBCC', 1234) OR aaa = 123x OR 123r = foo123")); 
    470 */ 
    471   return true; 
    472 } 
    473 bool CheckEventLog::unloadModule() { 
    474   return true; 
    475 } 
    476  
    477 bool CheckEventLog::hasCommandHandler() { 
    478   return true; 
    479 } 
    480 bool CheckEventLog::hasMessageHandler() { 
    481   return false; 
    482 } 
    483486 
    484487 
    … …  
    562565   
    563566  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    564   std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
     567  std::list<std::wstring> arguments = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    565568 
    566569  std::list<std::wstring> files; 
    … …  
    588591 
    589592  try { 
    590     MAP_OPTIONS_BEGIN(stl_args) 
     593    MAP_OPTIONS_BEGIN(arguments) 
    591594      MAP_OPTIONS_NUMERIC_ALL(query1, _T("")) 
    592595      MAP_OPTIONS_EXACT_NUMERIC_ALL(query2, _T("")) 

  • modules/CheckEventLog/CheckEventLog.h

    rb6d6f90 r3136203  
    3131  bool debug_; 
    3232  std::wstring syntax_; 
    33   DWORD buffer_length_; 
     33  int buffer_length_; 
    3434  bool lookup_names_; 
    3535 

  • modules/CheckExternalScripts/CheckExternalScripts.cpp

    rf40d813 r3136203  
    4444  if (!file_helpers::checks::exists(pattern.first)) 
    4545    NSC_LOG_ERROR_STD(_T("Path was not found: ") + pattern.first); 
    46 /* TODO: do we need this? 
    47   std::wstring::size_type pos = path.find_last_of('*'); 
    48   if (pos == std::wstring::npos) { 
    49     path += _T("*.*"); 
    50   } 
    51   */ 
     46 
    5247  WIN32_FIND_DATA wfd; 
    5348  std::wstring real_path = file_helpers::patterns::combine_pattern(pattern); 
    … …  
    8479 
    8580bool CheckExternalScripts::loadModule() { 
    86   timeout = NSCModuleHelper::getSettingsInt(EXTSCRIPT_SECTION_TITLE, EXTSCRIPT_SETTINGS_TIMEOUT ,EXTSCRIPT_SETTINGS_TIMEOUT_DEFAULT); 
    87   scriptDirectory_ = NSCModuleHelper::getSettingsString(EXTSCRIPT_SECTION_TITLE, EXTSCRIPT_SETTINGS_SCRIPTDIR ,EXTSCRIPT_SETTINGS_SCRIPTDIR_DEFAULT); 
    88   std::list<std::wstring>::const_iterator it; 
    89   std::list<std::wstring> commands = NSCModuleHelper::getSettingsSection(EXTSCRIPT_SCRIPT_SECTION_TITLE); 
    90   for (it = commands.begin(); it != commands.end(); ++it) { 
    91     if ((*it).empty()) 
    92       continue; 
    93     std::wstring s = NSCModuleHelper::getSettingsString(EXTSCRIPT_SCRIPT_SECTION_TITLE, (*it), _T("")); 
    94     if (s.empty()) { 
    95       NSC_LOG_ERROR_STD(_T("Invalid command definition: ") + (*it)); 
    96     } else { 
    97       strEx::token tok = strEx::getToken(s, ' ', true); 
    98       addCommand((*it).c_str(), tok.first, tok.second); 
    99     } 
    100   } 
    101  
    102   commands = NSCModuleHelper::getSettingsSection(EXTSCRIPT_ALIAS_SECTION_TITLE); 
    103   for (it = commands.begin(); it != commands.end(); ++it) { 
    104     if ((*it).empty()) 
    105       continue; 
    106     std::wstring s = NSCModuleHelper::getSettingsString(EXTSCRIPT_ALIAS_SECTION_TITLE, (*it), _T("")); 
    107     if (s.empty()) { 
    108       NSC_LOG_ERROR_STD(_T("Invalid command definition: ") + (*it)); 
    109     } else { 
    110       strEx::token tok = strEx::getToken(s, ' ', true); 
    111       addAlias((*it).c_str(), tok.first, tok.second); 
    112     } 
    113   } 
    114  
    115   std::map<std::wstring,std::wstring> wrappers; 
    116   std::list<std::wstring> wrappings = NSCModuleHelper::getSettingsSection(EXTSCRIPT_WRAPPINGS_SECTION_TITLE); 
    117   for (it = wrappings.begin(); it != wrappings.end(); ++it) { 
    118     std::wstring val = NSCModuleHelper::getSettingsString(EXTSCRIPT_WRAPPINGS_SECTION_TITLE, *it, _T("")); 
    119     if (!(*it).empty() && !val.empty()) { 
    120       wrappers[(*it)] = val; 
    121     } 
    122   } 
    123   std::list<std::wstring> wscript = NSCModuleHelper::getSettingsSection(EXTSCRIPT_WRAPPED_SCRIPT_SECTION_TITLE); 
    124   for (it = wscript.begin(); it != wscript.end(); ++it) { 
    125     std::wstring val = NSCModuleHelper::getSettingsString(EXTSCRIPT_WRAPPED_SCRIPT_SECTION_TITLE, *it, _T("")); 
    126     if (!(*it).empty() && !val.empty()) { 
    127       std::wstring type = getWrapping(val); 
    128       std::map<std::wstring,std::wstring>::const_iterator cit = wrappers.find(type); 
    129       if (cit == wrappers.end()) { 
    130         NSC_LOG_ERROR_STD(_T("Failed to find wrappings for: ") + type + _T(" (" + (*it) + _T(")"))); 
     81  try { 
     82    timeout = NSCModuleHelper::getSettingsInt(EXTSCRIPT_SECTION_TITLE, EXTSCRIPT_SETTINGS_TIMEOUT ,EXTSCRIPT_SETTINGS_TIMEOUT_DEFAULT); 
     83    scriptDirectory_ = NSCModuleHelper::getSettingsString(EXTSCRIPT_SECTION_TITLE, EXTSCRIPT_SETTINGS_SCRIPTDIR ,EXTSCRIPT_SETTINGS_SCRIPTDIR_DEFAULT); 
     84    std::list<std::wstring>::const_iterator it; 
     85    std::list<std::wstring> commands = NSCModuleHelper::getSettingsSection(EXTSCRIPT_SCRIPT_SECTION_TITLE); 
     86    for (it = commands.begin(); it != commands.end(); ++it) { 
     87      if ((*it).empty()) 
     88        continue; 
     89      std::wstring s = NSCModuleHelper::getSettingsString(EXTSCRIPT_SCRIPT_SECTION_TITLE, (*it), _T("")); 
     90      if (s.empty()) { 
     91        NSC_LOG_ERROR_STD(_T("Invalid command definition: ") + (*it)); 
    13192      } else { 
    132         addWrappedCommand((*it), (*cit).second, val); 
    133       } 
    134     } 
    135   } 
    136  
    137   if (!scriptDirectory_.empty()) { 
    138     addAllScriptsFrom(scriptDirectory_); 
    139   } 
    140   root_ = NSCModuleHelper::getBasePath(); 
     93        strEx::token tok = strEx::getToken(s, ' ', true); 
     94        addCommand((*it).c_str(), tok.first, tok.second); 
     95      } 
     96    } 
     97   
     98    commands = NSCModuleHelper::getSettingsSection(EXTSCRIPT_ALIAS_SECTION_TITLE); 
     99    for (it = commands.begin(); it != commands.end(); ++it) { 
     100      if ((*it).empty()) 
     101        continue; 
     102      std::wstring s = NSCModuleHelper::getSettingsString(EXTSCRIPT_ALIAS_SECTION_TITLE, (*it), _T("")); 
     103      if (s.empty()) { 
     104        NSC_LOG_ERROR_STD(_T("Invalid command definition: ") + (*it)); 
     105      } else { 
     106        strEx::token tok = strEx::getToken(s, ' ', true); 
     107        addAlias((*it).c_str(), tok.first, tok.second); 
     108      } 
     109    } 
     110   
     111    std::map<std::wstring,std::wstring> wrappers; 
     112    std::list<std::wstring> wrappings = NSCModuleHelper::getSettingsSection(EXTSCRIPT_WRAPPINGS_SECTION_TITLE); 
     113    for (it = wrappings.begin(); it != wrappings.end(); ++it) { 
     114      std::wstring val = NSCModuleHelper::getSettingsString(EXTSCRIPT_WRAPPINGS_SECTION_TITLE, *it, _T("")); 
     115      if (!(*it).empty() && !val.empty()) { 
     116        wrappers[(*it)] = val; 
     117      } 
     118    } 
     119    std::list<std::wstring> wscript = NSCModuleHelper::getSettingsSection(EXTSCRIPT_WRAPPED_SCRIPT_SECTION_TITLE); 
     120    for (it = wscript.begin(); it != wscript.end(); ++it) { 
     121      std::wstring val = NSCModuleHelper::getSettingsString(EXTSCRIPT_WRAPPED_SCRIPT_SECTION_TITLE, *it, _T("")); 
     122      if (!(*it).empty() && !val.empty()) { 
     123        std::wstring type = getWrapping(val); 
     124        std::map<std::wstring,std::wstring>::const_iterator cit = wrappers.find(type); 
     125        if (cit == wrappers.end()) { 
     126          NSC_LOG_ERROR_STD(_T("Failed to find wrappings for: ") + type + _T(" (" + (*it) + _T(")"))); 
     127        } else { 
     128          addWrappedCommand((*it), (*cit).second, val); 
     129        } 
     130   
     131   
     132   
     133   
     134   
     135   
     136   
     137   
     138   
     139   
     140   
     141   
     142   
     143   
     144   
     145   
     146   
     147   
     148   
     149   
     150   
     151   
     152   
     153      } 
     154    } 
     155   
     156    if (!scriptDirectory_.empty()) { 
     157      addAllScriptsFrom(scriptDirectory_); 
     158   
     159   
     160   
     161   
     162    } 
     163    root_ = NSCModuleHelper::getBasePath(); 
     164  } catch (...) { 
     165    return false; 
     166} 
    141167  return true; 
    142168} 
    … …  
    190216    } 
    191217    return NSCHelper::int2nagios(result); 
    192     /* 
    193   } else if (cd.type == script_dir) { 
    194     std::wstring args = arrayBuffer::arrayBuffer2string(char_args, argLen, _T(" ")); 
    195     std::wstring cmd = scriptDirectory_ + command.c_str() + _T(" ") +args; 
    196     return executeNRPECommand(cmd, message, perf); 
    197   } else { 
    198     NSC_LOG_ERROR_STD(_T("Unknown script type: ") + command.c_str()); 
    199     return NSCAPI::critical; 
    200     */ 
    201218  } 
    202219 

  • modules/CheckHelpers/CheckHelpers.cpp

    r1d6bb09 r3136203  
    3434CheckHelpers gCheckHelpers; 
    3535 
    36 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) 
    37 { 
    38   NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call); 
    39   return TRUE; 
    40 } 
    41  
    4236CheckHelpers::CheckHelpers() { 
    4337} 
    … …  
    7569  return false; 
    7670} 
    77 NSCAPI::nagiosReturn CheckHelpers::checkSimpleStatus(NSCAPI::nagiosReturn status, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf)  
     71NSCAPI::nagiosReturn CheckHelpers::checkSimpleStatus(NSCAPI::nagiosReturn status, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf)  
    7872{ 
    7973  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    80   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    81   if (args.empty()) { 
    82     msg = NSCHelper::translateReturn(status) + _T(": Lets pretend everything is going to be ok."); 
     74  std::list<std::wstring> arguments = arrayBuffer::arrayBuffer2list(argLen, char_args); 
     75  if (arguments.empty()) { 
     76    message = NSCHelper::translateReturn(status) + _T(": Lets pretend everything is going to be ok."); 
    8377    return status; 
    8478  } 
    8579  std::list<std::wstring>::const_iterator cit; 
    86   for (cit=args.begin();cit!=args.end();++cit) 
    87     msg += *cit; 
     80  for (cit=arguments.begin();cit!=arguments.end();++cit) 
     81    message += *cit; 
    8882  return status; 
    8983} 
    9084 
    91 NSCAPI::nagiosReturn CheckHelpers::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) { 
    92   if (command == _T("CheckAlwaysOK")) { 
     85NSCAPI::nagiosReturn CheckHelpers::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
     86  if (command == _T("CheckVersion")) { 
     87    message = NSCModuleHelper::getApplicationVersionString(); 
     88    return NSCAPI::returnOK; 
     89  } else if (command == _T("CheckAlwaysOK")) { 
    9390    if (argLen < 2) { 
    94       msg = _T("ERROR: Missing arguments."); 
    95       return NSCAPI::returnUNKNOWN; 
    96     } 
    97     NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], msg, perf); 
     91      message = _T("ERROR: Missing arguments."); 
     92      return NSCAPI::returnUNKNOWN; 
     93    } 
     94    NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], message, perf); 
    9895    return NSCAPI::returnOK; 
    99   } else if (command == _T("CheckVersion")) { 
    100     msg = NSCModuleHelper::getApplicationVersionString(); 
    101     return NSCAPI::returnOK; 
    102   } else if (command == _T("CheckOK")) { 
    103     return checkSimpleStatus(NSCAPI::returnOK, argLen, char_args, msg, perf); 
    104   } else if (command == _T("CheckWARNING")) { 
    105     return checkSimpleStatus(NSCAPI::returnWARN, argLen, char_args, msg, perf); 
    106   } else if (command == _T("CheckCRITICAL")) { 
    107     return checkSimpleStatus(NSCAPI::returnCRIT, argLen, char_args, msg, perf); 
    10896  } else if (command == _T("CheckAlwaysCRITICAL")) { 
    10997    if (argLen < 2) { 
    110       msg = _T("ERROR: Missing arguments."); 
    111       return NSCAPI::returnUNKNOWN; 
    112     } 
    113     NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], msg, perf); 
     98      message = _T("ERROR: Missing arguments."); 
     99      return NSCAPI::returnUNKNOWN; 
     100    } 
     101    NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], message, perf); 
    114102    return NSCAPI::returnCRIT; 
    115103  } else if (command == _T("CheckAlwaysWARNING")) { 
    116104    if (argLen < 2) { 
    117       msg = _T("ERROR: Missing arguments."); 
    118       return NSCAPI::returnUNKNOWN; 
    119     } 
    120     NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], msg, perf); 
     105      message = _T("ERROR: Missing arguments."); 
     106      return NSCAPI::returnUNKNOWN; 
     107    } 
     108    NSCModuleHelper::InjectCommand(char_args[0], argLen-1, &char_args[1], message, perf); 
    121109    return NSCAPI::returnWARN; 
     110  } else if (command == _T("CheckOK")) { 
     111    return checkSimpleStatus(NSCAPI::returnOK, argLen, char_args, message, perf); 
     112  } else if (command == _T("check_ok")) { 
     113    return checkSimpleStatus(NSCAPI::returnOK, argLen, char_args, message, perf); 
     114  } else if (command == _T("CheckWARNING")) { 
     115    return checkSimpleStatus(NSCAPI::returnWARN, argLen, char_args, message, perf); 
     116  } else if (command == _T("CheckCRITICAL")) { 
     117    return checkSimpleStatus(NSCAPI::returnCRIT, argLen, char_args, message, perf); 
    122118  } else if (command == _T("CheckMultiple")) { 
    123     return checkMultiple(argLen, char_args, msg, perf); 
     119    return checkMultiple(argLen, char_args, message, perf); 
    124120  } else if (command == _T("Negate")) { 
    125     return negate(argLen, char_args, msg, perf); 
     121    return negate(argLen, char_args, message, perf); 
    126122  } else if (command == _T("Timeout")) { 
    127     return timeout(argLen, char_args, msg, perf); 
     123    return timeout(argLen, char_args, message, perf); 
    128124  } 
    129125  return NSCAPI::returnIgnored; 
    130126} 
    131 NSCAPI::nagiosReturn CheckHelpers::checkMultiple(const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf)  
     127NSCAPI::nagiosReturn CheckHelpers::checkMultiple(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf)  
    132128{ 
    133129  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    134   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    135   if (args.empty()) { 
    136     msg = _T("Missing argument(s)."); 
     130  std::list<std::wstring> arguments = arrayBuffer::arrayBuffer2list(argLen, char_args); 
     131  if (arguments.empty()) { 
     132    message = _T("Missing argument(s)."); 
    137133    return NSCAPI::returnCRIT; 
    138134  } 
    … …  
    141137  sub_command currentCommand; 
    142138  std::list<std::wstring>::const_iterator cit; 
    143   for (cit=args.begin();cit!=args.end();++cit) { 
     139  for (cit=arguments.begin();cit!=arguments.end();++cit) { 
    144140    std::wstring arg = *cit; 
    145141    std::pair<std::wstring,std::wstring> p = strEx::split(arg,_T("=")); 
    … …  
    163159    arrayBuffer::destroyArrayBuffer(args, length); 
    164160    returnCode = NSCHelper::maxState(returnCode, tRet); 
    165     if (!msg.empty()) 
    166       msg += _T(", "); 
    167     msg += tMsg; 
     161    if (!message.empty()) 
     162      message += _T(", "); 
     163    message += tMsg; 
    168164    perf += tPerf; 
    169165  } 
    … …  
    174170{ 
    175171  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    176   std::vector<std::wstring> args = arrayBuffer::arrayBuffer2vector(argLen, char_args); 
    177   if (args.empty()) { 
     172  std::vector<std::wstring> arguments = arrayBuffer::arrayBuffer2vector(argLen, char_args); 
     173  if (arguments.empty()) { 
    178174    msg = _T("Missing argument(s)."); 
    179175    return NSCAPI::returnCRIT; 
    … …  
    210206 
    211207    boost::program_options::variables_map vm; 
    212     boost::program_options::store(boost::program_options::basic_command_line_parser<wchar_t>(args).options(desc).positional(p).run(), vm); 
     208    boost::program_options::store(boost::program_options::basic_command_line_parser<wchar_t>(arguments).options(desc).positional(p).run(), vm); 
    213209    boost::program_options::notify(vm);  
    214210 
    … …  
    271267{ 
    272268  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    273   std::vector<std::wstring> args = arrayBuffer::arrayBuffer2vector(argLen, char_args); 
    274   if (args.empty()) { 
     269  std::vector<std::wstring> arguments = arrayBuffer::arrayBuffer2vector(argLen, char_args); 
     270  if (arguments.empty()) { 
    275271    msg = _T("Missing argument(s)."); 
    276272    return NSCAPI::returnCRIT; 
    … …  
    296292 
    297293      ("command,q", boost::program_options::wvalue<std::wstring>(&command), "Wrapped command to execute") 
    298       ("arguments,a", boost::program_options::wvalue<std::vector<std::wstring> >(&cmd_args), "List of arguments (for wrapped command)") 
     294      ("arguments,a", boost::program_options::wvalue<std::vector<std::wstring> >(&arguments), "List of arguments (for wrapped command)") 
    299295      ; 
    300296 
    … …  
    344340} 
    345341 
     342NSC_WRAP_DLL(); 
    346343NSC_WRAPPERS_MAIN_DEF(gCheckHelpers); 
    347344NSC_WRAPPERS_IGNORE_MSG_DEF(); 
Note: See TracChangeset for help on using the changeset viewer.