Changeset e93e741 in nscp

Timestamp:

05/29/05 20:58:08 (8 years ago)

Author:

Michael Medin <michael@…>

Children:

24f7192

Parents:

7da80b5

Message:

• Fixed PROCSTATE and SERVICESTATE return state. + Added support for individual size in CheckDriveSize and CheckFileSize (size has to be specified before a drive/path)
• Fixed performance data for drives (and possibly other places)

Location:

trunk

Files:

• changelog (modified) (1 diff)
• docs/CheckDisk/index.html (modified) (2 diffs)
• include/PDHCollectors.h (modified) (5 diffs)
• include/PDHCounter.h (modified) (2 diffs)
• include/strEx.h (modified) (1 diff)
• include/utils.h (modified) (8 diffs)
• modules/CheckDisk/CheckDisk.cpp (modified) (14 diffs)
• modules/CheckSystem/CheckSystem.cpp (modified) (3 diffs)
• modules/CheckSystem/PDHCollector.cpp (modified) (2 diffs)
• modules/CheckSystem/PDHCollector.h (modified) (1 diff)
• modules/NSClientListener/NSClientListener.cpp (modified) (1 diff)

trunk/changelog

@@ +1 @@
+2005-05-29 MickeM
+ * Fixed PROCSTATE and SERVICESTATE return state.
+ + Added support for individual size in CheckDriveSize and CheckFileSize (size has to be specified before a drive/path)
+ * Fixed performance data for drives (and possibly other places)
+
 2005-05-23 MickeM
  + Added obfuscated password support

trunk/docs/CheckDisk/index.html

@@ -33 +33 @@
   <h2>CheckFileSize</h2>
   <p>This check does a recursive size calculation of the directory (or file) specified. 
-  A request has one or more options described in the table below. </p>
+  A request has one or more options described in the table below. The order 
+  only matter in that the size has to be specified before the File option 
+  this becous you can change the size for each drive by specifying multiple 
+  Size options.</p>
   <table class="MsoNormalTable" border="0" cellspacing="0" cellpadding="0" id="table5">
     <tr>
@@ -127 +130 @@
       </div>
       </li>
+      <li>
+      <p><b>Sample of using individual size for multiple files.:</b></p>
+      <p><code>CheckFileSize MaxWarn=2G MaxCrit=4G File=c:\\pagefile.sys MaxWarn=1K MaxCrit=512 File=c:\\boot.ini</code></p>
+      <p><code>OK all file sizes are within bounds.</code></p>
+      <div class="config">
+        <p>define command { </p>
+        <p>&nbsp;&nbsp;&nbsp; command_name CheckMyFiles </p>
+        <p>&nbsp;&nbsp;&nbsp; command_line check_nrpe -H $HOSTADDRESS$ -p 
+        5666 -c CheckFileSize -a MaxWarn=2G MaxCrit=4G File=c:\\pagefile.sys MaxWarn=1K MaxCrit=512 File=c:\\boot.ini</p>
+        <p>}</p>
+        <p>&nbsp;&nbsp;&nbsp; check_command CheckMyFiles</p>
+      </div>
+      </li>
     </ul>
   </div>
   <h2>CheckDriveSize</h2>
+  <p>This check verifies the size of various drives specified on the command 
+  line. 
+  A request has one or more options described in the table below. The order 
+  only matter in that the size has to be specified before the Drive option 
+  this becous you can change the size for each drive by specifying multiple 
+  Size options.</p>
   <table class="MsoNormalTable" border="0" cellspacing="0" cellpadding="0" id="table6">
     <tr>

trunk/include/PDHCollectors.h

@@ -4 +4 @@
 
 namespace PDHCollectors {
-  class StaticPDHCounterListenerInt : public PDH::PDHCounterListener {
-    __int64 value_;
+  template <class TType = __int64, DWORD TCollectionFormat = PDH_FMT_LARGE>
+  class StaticPDHCounterListener : public PDH::PDHCounterListener {
+    TType value_;
   public:
     virtual void collect(const PDH::PDHCounter &counter) {
-      setValue(counter.getInt64Value());
+      switch (TCollectionFormat) {
+        case PDH_FMT_LARGE:
+          setValue(counter.getInt64Value());
+          break;
+        case PDH_FMT_DOUBLE:
+          setValue(counter.getDoubleValue());
+          break;
+        default:
+          return;
+      }
     }
     void attach(const PDH::PDHCounter &counter){}
     void detach(const PDH::PDHCounter &counter){}
-    void setValue(__int64 value) {
+    void setValue(TType value) {
       value_ = value;
     }
-    __int64 getValue() const {
+    TType getValue() const {
       return value_;
     }
-  };
-  class StaticPDHCounterListenerDouble : public PDH::PDHCounterListener {
-    double value_;
-  public:
-    virtual void collect(const PDH::PDHCounter &counter) {
-      setValue(counter.getDoubleValue());
-    }
-    void attach(const PDH::PDHCounter &counter){}
-    void detach(const PDH::PDHCounter &counter){}
-    void setValue(double value) {
-      value_ = value;
-    }
-    double getValue() const {
-      return value_;
+    DWORD getFormat() const {
+      return TCollectionFormat;
     }
   };
 
-
+  template <class TType = __int64, DWORD TCollectionFormat = PDH_FMT_LARGE>
   class RoundINTPDHBufferListener : public PDH::PDHCounterListener {
     unsigned int length;
-    int *buffer;
+    TType *buffer;
     unsigned int current;
   public:
@@ -64 +62 @@
       length = newLength;
 
-      buffer = new int[length];
+      buffer = new TType[length];
       for (unsigned int i=0; i<length;i++)
         buffer[i] = 0;
@@ -70 +68 @@
     }
     virtual void collect(const PDH::PDHCounter &counter) {
-      pushValue(static_cast<int>(counter.getInt64Value()));
+      switch (TCollectionFormat) {
+        case PDH_FMT_LONG:
+          pushValue(counter.getInt64Value());
+          break;
+        case PDH_FMT_DOUBLE:
+          pushValue(counter.getInt64Value());
+          break;
+        default:
+          return;
+      }
     }
     void attach(const PDH::PDHCounter &counter){}
     void detach(const PDH::PDHCounter &counter){}
-    void pushValue(int value) {
+    void pushValue(TType value) {
       if (buffer == NULL)
         return;
@@ -83 +90 @@
         current = 0;
     }
-    int getAvrage(unsigned int backItems) const {
+    TType getAvrage(unsigned int backItems) const {
       if ((backItems == 0) || (backItems >= length))
         return -1;
@@ -98 +105 @@
           ret += buffer[i];
       }
-      return static_cast<int>(ret/backItems);
+      return (ret/backItems);
     }
     inline unsigned int getLength() const {
       return length;
     }
+    DWORD getFormat() const {
+      return TCollectionFormat;
+    }
   };
 

trunk/include/PDHCounter.h

@@ -23 +23 @@
     virtual void attach(const PDHCounter &counter) = 0;
     virtual void detach(const PDHCounter &counter) = 0;
+    virtual DWORD getFormat() const = 0;
   };
 
@@ -72 +73 @@
         return;
       PDH_STATUS status;
-      if ((status = PdhGetFormattedCounterValue(hCounter_, PDH_FMT_LARGE , NULL, &data_)) != ERROR_SUCCESS)
+      if (!listener_)
+        return;
+      if ((status = PdhGetFormattedCounterValue(hCounter_, listener_->getFormat(), NULL, &data_)) != ERROR_SUCCESS)
         throw PDHException("PdhGetFormattedCounterValue failed", status);
-      if (listener_)
-        listener_->collect(*this);
+      listener_->collect(*this);
     }
     double getDoubleValue() const {

trunk/include/strEx.h

@@ -40 +40 @@
   }
   inline std::string itos(unsigned long i) {
+    std::stringstream ss;
+    ss << i;
+    return ss.str();
+  }
+  inline std::string itos(double i) {
     std::stringstream ss;
     ss << i;

trunk/include/utils.h

@@ -22 +22 @@
       return strEx::itos(value) + "%";
     }
+    static std::string print_unformated(TType value) {
+      return strEx::itos(value);
+    }
   };
 
@@ -34 +37 @@
     }
     static std::string print(TType value) {
+      return strEx::itos(value);
+    }
+    static std::string print_unformated(TType value) {
       return strEx::itos(value);
     }
@@ -54 +60 @@
 
     Size() : bHasBounds_(false), value_(0) {};
+
+    Size(const Size & other) {
+      bHasBounds_ = other.bHasBounds_;
+      value_ = other.value_;
+    }
+
     void set(std::string s) {
       value_ = THandler::parse(s);
@@ -101 +113 @@
 
     SizePercentage() : type_(none), value_(0) {};
+
+    SizePercentage(const SizePercentage &other) {
+      type_ = other.type_;
+      value_ = other.value_;
+    };
     void set(std::string s) {
       std::string::size_type p = s.find_first_of('%');
@@ -159 +176 @@
     typedef SizeMaxMin<TType, THandler, THolder> TMyType;
 
+    SizeMaxMin() {}
+    SizeMaxMin(const SizeMaxMin &other) {
+      max = other.max;
+      min = other.min;
+    }
+
     std::string printPerfData()
     {
       if (max.hasBounds()) {
-        return THandler::print(max.value_) + ";";
+        return THandler::print_unformated(max.value_) + ";";
       } else if (min.hasBounds()) {
-        return THandler::print(min.value_) + ";";
+        return THandler::print_unformated(min.value_) + ";";
       }
       return "0;";
@@ -180 +203 @@
     THolder min;
     typedef SizeMaxMinPercentage<TType, THandler, THolder> TMyType;
+
+    SizeMaxMinPercentage() {}
+    SizeMaxMinPercentage(const SizeMaxMinPercentage &other) {
+      max = other.max;
+      min = other.min;
+    }
 
     bool isPercentage() {
@@ -207 +236 @@
         if (max.hasBounds()) {
           if (max.isPercentage()) {
-            return THandler::print((max.value_*total)/100) + ";";
-          } else {
-            return THandler::print(max.value_) + ";";
+            return THandler::print_unformated((max.value_*total)/100) + ";";
+          } else {
+            return THandler::print_unformated(max.value_) + ";";
           }
         } else if (min.hasBounds()) {
           if (min.isPercentage()) {
-            return THandler::print((min.value_*total)/100) + ";";
-          } else {
-            return THandler::print(min.value_) + ";";
+            return THandler::print_unformated((min.value_*total)/100) + ";";
+          } else {
+            return THandler::print_unformated(min.value_) + ";";
           }
         }
@@ -236 +265 @@
 
   };
-/*
-  template <typename TType = drive_size, class THandler = drive_size_handler<>, class THolder = SizeMaxMinPercentage<> > 
-  class PerformancePrinterPercentage {
-  public:
-    static std::string printPerf(std::string name, TType value, TType total, THolder &warn, THolder &crit)
-    {
-      std::string s;
-      bool percentage = crit.isPercentage()  || warn.isPercentage();
-      if (percentage)
-        s += name + "=" + strEx::itos(value*100/total)+ "% ";
-      else
-        s+= name + "=" + strEx::itos(value) + ";";
-      s += warn.printPerfData(percentage, value, total);
-      s += crit.printPerfData(percentage, value, total);
-      s += " ";
-      return s;
-    }
-  };
-  template <typename TType = drive_size, class THandler = drive_size_handler<>, class THolder = SizeMaxMin<> > 
-  class PerformancePrinter {
-  public:
-    static std::string printPerf(std::string name, TType value, THolder &warn, THolder &crit)
-    {
-      return name + "=" + strEx::itos(value) + ";" + warn.printPerfData() + crit.printPerfData();
-    }
-  };
-*/
 }
 void generate_crc32_table(void);

trunk/modules/CheckDisk/CheckDisk.cpp

@@ -83 +83 @@
 }
 
-
-#define MY_FILTER_UNKNOWN     0
-#define MY_FILTER_NO_ROOT_DIR 1
-#define MY_FILTER_REMOVABLE   2
-#define MY_FILTER_FIXED       4
-#define MY_FILTER_REMOTE      8
-#define MY_FILTER_CDROM       16
-#define MY_FILTER_RAMDISK     32
+struct DriveConatiner {
+  checkHolders::SizeMaxMinPercentage<> warn_;
+  checkHolders::SizeMaxMinPercentage<> crit_;
+  std::string drive_;
+  DriveConatiner(std::string drive, checkHolders::SizeMaxMinPercentage<> warn, checkHolders::SizeMaxMinPercentage<> crit) 
+    : drive_(drive), warn_(warn), crit_(crit) 
+  {}
+};
 
 NSCAPI::nagiosReturn CheckDisk::CheckDriveSize(const unsigned int argLen, char **char_args, std::string &message, std::string &perf) {
@@ -111 +111 @@
   bool bFilterFixed = false;
   bool bFilterCDROM = false;
-  std::list<std::string> drives;
+  std::list<DriveConatiner> drives;
 
   std::list<std::string>::const_iterator cit;
@@ -118 +118 @@
     std::pair<std::string,std::string> p = strEx::split(arg,"=");
     if (p.first == "Drive") {
-      drives.push_back(p.second);
+      drives.push_back(DriveConatiner(p.second, warn, crit));
     } else if (p.first == "MaxWarn") {
       warn.max.set(p.second);
@@ -145 +145 @@
       bCheckAll = true;
     } else {
-      drives.push_back(p.first);
+      drives.push_back(DriveConatiner(p.first, warn, crit));
     }
   }
@@ -158 +158 @@
         UINT drvType = GetDriveType(drv.c_str());
         if ((!bFilter)&&(drvType == DRIVE_FIXED)) {
-          drives.push_back(drv);
+          drives.push_back(DriveConatiner(drv, warn, crit));
         } else if ((bFilter)&&(bFilterFixed)&&(drvType==DRIVE_FIXED)) {
-          drives.push_back(drv);
+          drives.push_back(DriveConatiner(drv, warn, crit));
         } else if ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) {
-          drives.push_back(drv);
+          drives.push_back(DriveConatiner(drv, warn, crit));
         } else if ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) {
-          drives.push_back(drv);
+          drives.push_back(DriveConatiner(drv, warn, crit));
         } else if ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) {
-          drives.push_back(drv);
+          drives.push_back(DriveConatiner(drv, warn, crit));
         }
       }
@@ -174 +174 @@
   }
 
-  for (std::list<std::string>::iterator it = drives.begin();it!=drives.end();it++) {
-    std::string drive = (*it);
-    if (drive.length() == 1)
-      drive += ":";
-    UINT drvType = GetDriveType(drive.c_str());
+  for (std::list<DriveConatiner>::iterator it = drives.begin();it!=drives.end();it++) {
+    DriveConatiner drive = (*it);
+    if (drive.drive_.length() == 1)
+      drive.drive_ += ":";
+    UINT drvType = GetDriveType(drive.drive_.c_str());
 
     if ((!bFilter)&&(drvType != DRIVE_FIXED)) {
-      message = "UNKNOWN: Drive is not a fixed drive: " + drive + " (it is a: " + strEx::itos(drvType) + ")";
+      message = "UNKNOWN: Drive is not a fixed drive: " + drive.drive_ + " (it is a: " + strEx::itos(drvType) + ")";
       return NSCAPI::returnUNKNOWN;
     } else if ((bFilter)&&(!bFilterFixed)&&(drvType==DRIVE_FIXED)) {
-      message = "UNKNOWN: Drive does not match the current filter: " + drive + " (it is a: " + strEx::itos(drvType) + ")";
+      message = "UNKNOWN: Drive does not match the current filter: " + drive.drive_ + " (it is a: " + strEx::itos(drvType) + ")";
       return NSCAPI::returnUNKNOWN;
     } else if ((bFilter)&&(!bFilterCDROM)&&(drvType==DRIVE_CDROM)) {
-      message = "UNKNOWN: Drive does not match the current filter: " + drive + " (it is a: " + strEx::itos(drvType) + ")";
+      message = "UNKNOWN: Drive does not match the current filter: " + drive.drive_ + " (it is a: " + strEx::itos(drvType) + ")";
       return NSCAPI::returnUNKNOWN;
     } else if ((bFilter)&&(!bFilterRemote)&&(drvType==DRIVE_REMOTE)) {
-      message = "UNKNOWN: Drive does not match the current filter: " + drive + " (it is a: " + strEx::itos(drvType) + ")";
+      message = "UNKNOWN: Drive does not match the current filter: " + drive.drive_ + " (it is a: " + strEx::itos(drvType) + ")";
       return NSCAPI::returnUNKNOWN;
     } else if ((bFilter)&&(!bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) {
-      message = "UNKNOWN: Drive does not match the current filter: " + drive + " (it is a: " + strEx::itos(drvType) + ")";
+      message = "UNKNOWN: Drive does not match the current filter: " + drive.drive_ + " (it is a: " + strEx::itos(drvType) + ")";
       return NSCAPI::returnUNKNOWN;
     }
@@ -200 +200 @@
     ULARGE_INTEGER totalNumberOfBytes;
     ULARGE_INTEGER totalNumberOfFreeBytes;
-    if (!GetDiskFreeSpaceEx(drive.c_str(), &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes)) {
-      message = "UNKNOWN: Could not get free space for: " + drive;
+    if (!GetDiskFreeSpaceEx(drive.drive_.c_str(), &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes)) {
+      message = "UNKNOWN: Could not get free space for: " + drive.drive_;
       return NSCAPI::returnUNKNOWN;
     }
@@ -216 +216 @@
       checkHolders::drive_size usedSpace = totalNumberOfBytes.QuadPart-totalNumberOfFreeBytes.QuadPart;
       checkHolders::drive_size totalSpace = totalNumberOfBytes.QuadPart;
-      if (crit.max.hasBounds() && crit.max.checkMAX(usedSpace, totalSpace)) {
-        tStr += crit.max.prettyPrint(drive, usedSpace, totalSpace) + " > critical";
+      if (drive.crit_.max.hasBounds() && drive.crit_.max.checkMAX(usedSpace, totalSpace)) {
+        tStr += drive.crit_.max.prettyPrint(drive.drive_, usedSpace, totalSpace) + " > critical";
         NSCHelper::escalteReturnCodeToCRIT(returnCode);
-      } else if (crit.min.hasBounds() && crit.min.checkMIN(usedSpace, totalSpace)) {
-        tStr = crit.min.prettyPrint(drive, usedSpace, totalSpace) + " < critical";
+      } else if (drive.crit_.min.hasBounds() && drive.crit_.min.checkMIN(usedSpace, totalSpace)) {
+        tStr = drive.crit_.min.prettyPrint(drive.drive_, usedSpace, totalSpace) + " < critical";
         NSCHelper::escalteReturnCodeToCRIT(returnCode);
-      } else if (warn.max.hasBounds() && warn.max.checkMAX(usedSpace, totalSpace)) {
-        tStr = warn.max.prettyPrint(drive, usedSpace, totalSpace) + " > warning";
+      } else if (drive.warn_.max.hasBounds() && drive.warn_.max.checkMAX(usedSpace, totalSpace)) {
+        tStr = drive.warn_.max.prettyPrint(drive.drive_, usedSpace, totalSpace) + " > warning";
         NSCHelper::escalteReturnCodeToWARN(returnCode);
-      } else if (warn.min.hasBounds() && warn.min.checkMIN(usedSpace, totalSpace)) {
-        tStr = warn.min.prettyPrint(drive, usedSpace, totalSpace) + " < warning";
+      } else if (drive.warn_.min.hasBounds() && drive.warn_.min.checkMIN(usedSpace, totalSpace)) {
+        tStr = drive.warn_.min.prettyPrint(drive.drive_, usedSpace, totalSpace) + " < warning";
         NSCHelper::escalteReturnCodeToWARN(returnCode);
       } else if (bShowAll) {
-        tStr = drive + ": " + strEx::itos_as_BKMG(usedSpace);
-      }
-      perf += checkHolders::SizeMaxMinPercentage<>::printPerf(drive, usedSpace, totalSpace, warn, crit);
+        tStr = drive.drive_ + ": " + strEx::itos_as_BKMG(usedSpace);
+      }
+      perf += checkHolders::SizeMaxMinPercentage<>::printPerf(drive.drive_, usedSpace, totalSpace, drive.warn_, drive.crit_);
       if (!message.empty() && !tStr.empty())
         message += ", ";
@@ -245 +245 @@
 }
 
+struct PathConatiner {
+  checkHolders::SizeMaxMin<> warn_;
+  checkHolders::SizeMaxMin<> crit_;
+  std::string drive_;
+  std::string alias_;
+  PathConatiner(std::string drive, checkHolders::SizeMaxMin<> warn, checkHolders::SizeMaxMin<> crit) 
+    : drive_(drive), warn_(warn), crit_(crit) 
+  {}
+  PathConatiner(std::string drive, std::string alias, checkHolders::SizeMaxMin<> warn, checkHolders::SizeMaxMin<> crit) 
+    : drive_(drive), alias_(alias), warn_(warn), crit_(crit) 
+  {}
+  std::string getPath() {
+    return drive_;
+  }
+  std::string getName() {
+    if (alias_.empty())
+      return drive_;
+    return alias_;
+  }
+};
+
 NSCAPI::nagiosReturn CheckDisk::CheckFileSize(const unsigned int argLen, char **char_args, std::string &message, std::string &perf) {
-  // CheckFileSize
-  // request: CheckFileSize <option> <option>...
-  // <option>     MaxWarn=<size gmkb>
-  //          MaxCrit=<size gmkb>
-  //          MinWarn=<size gmkb>
-  //          MinCrit=<size gmkb>
-  //          ShowAll
-  //          File=<path>
-  //          File:<shortname>=<path>
-  //
-  // Return: <return state>&<return string>...
-  // <return state> 0 - No errors
-  //          1 - Unknown
-  //          2 - Errors
-  // <size gmkb> is a size with a possible modifier letter (such as G for gigabyte, M for Megabyte, K for kilobyte etc)
-  // Examples:
-  // <return string>  <directory> <size gmkb> ... |<shortname>=<size>:<warn>:<crit>
-  // test: CheckFileSize ShowAll MaxWarn=1024M MaxCrit=4096M File:WIN=c:\WINDOWS\*.*
-  //       CheckFileSize
-  //
-  // check_nscp -H <ip> -p <port> -s <passwd> -c <commandstring>
-  //
-  // ./check_nscp -H 192.168.0.167 -p 1234 -s pwd -c 'CheckFileSize&ShowAll&MaxWarn=1024M&MaxCrit=4096M&File:WIN=c:\WINDOWS\*.*'
-  // WIN: 1G (2110962363B)|WIN:2110962363:1073741824:4294967296
   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
   std::list<std::string> args = arrayBuffer::arrayBuffer2list(argLen, char_args);
@@ -276 +273 @@
     return NSCAPI::returnCRIT;
   }
-  long long maxWarn = 0;
-  long long maxCrit = 0;
-  long long minWarn = 0;
-  long long minCrit = 0;
+  checkHolders::SizeMaxMin<> crit;
+  checkHolders::SizeMaxMin<> warn;
   bool bShowAll = false;
-  std::list<std::pair<std::string,std::string> > paths;
+  std::list<PathConatiner> paths;
 
   std::list<std::string>::const_iterator cit;
@@ -288 +283 @@
     std::pair<std::string,std::string> p = strEx::split(arg,"=");
     if (p.first == "File") {
-      paths.push_back(std::pair<std::string,std::string>("",p.second));
+      paths.push_back(PathConatiner(p.second, warn, crit));
     } else if (p.first == "MaxWarn") {
-      maxWarn = strEx::stoi64_as_BKMG(p.second);
+      warn.max.set(p.second);
     } else if (p.first == "MinWarn") {
-      minWarn = strEx::stoi64_as_BKMG(p.second);
+      warn.min.set(p.second);
     } else if (p.first == "MaxCrit") {
-      maxCrit = strEx::stoi64_as_BKMG(p.second);
+      crit.max.set(p.second);
     } else if (p.first == "MinCrit") {
-      minCrit = strEx::stoi64_as_BKMG(p.second);
+      crit.min.set(p.second);
     } else if (p.first == SHOW_ALL) {
       bShowAll = true;
@@ -302 +297 @@
       std::pair<std::string,std::string> p2 = strEx::split(p.first,":");
       if (p2.first == "File") {
-        paths.push_back(std::pair<std::string,std::string>(p2.second,p.second));
+        paths.push_back(PathConatiner(p.second, p2.second, warn, crit));
       } else {
         message = "Unknown command: " + p.first;
@@ -313 +308 @@
   }
 
-  std::list<std::pair<std::string,std::string> >::const_iterator pit;
+  std::list<PathConatiner>::const_iterator pit;
   for (pit = paths.begin(); pit != paths.end(); ++pit) {
+    PathConatiner path = (*pit);
     std::string tstr;
     GetSize sizeFinder;
-    std::string sName = (*pit).first;
-    if (sName.empty())
-      sName = (*pit).second;
-    RecursiveScanDirectory((*pit).second, sizeFinder);
-
-    if ((maxCrit!=0) && (sizeFinder.getSize() > maxCrit)) {
-      tstr = sName + ": " + strEx::itos_as_BKMG(sizeFinder.getSize());
-      returnCode = NSCAPI::returnCRIT;
-    } else if (sizeFinder.getSize() < minCrit) {
-      tstr = sName + ": " + strEx::itos_as_BKMG(sizeFinder.getSize());
+    std::string sName = path.getName();
+    RecursiveScanDirectory(path.getPath(), sizeFinder);
+
+    if (path.crit_.max.hasBounds() && path.crit_.max.checkMAX(sizeFinder.getSize())) {
+      tstr += path.crit_.max.prettyPrint(sName, sizeFinder.getSize()) + " > critical";
       NSCHelper::escalteReturnCodeToCRIT(returnCode);
-    } else if ((maxWarn!=0)&&(sizeFinder.getSize() > maxWarn)) {
-      tstr = sName +  ": " + strEx::itos_as_BKMG(sizeFinder.getSize());
+    } else if (path.crit_.min.hasBounds() && path.crit_.min.checkMIN(sizeFinder.getSize())) {
+      tstr += path.crit_.min.prettyPrint(sName, sizeFinder.getSize()) + " < critical";
+      NSCHelper::escalteReturnCodeToCRIT(returnCode);
+    } else if (path.warn_.max.hasBounds() && path.warn_.max.checkMAX(sizeFinder.getSize())) {
+      tstr += path.warn_.max.prettyPrint(sName, sizeFinder.getSize()) + " > warning";
       NSCHelper::escalteReturnCodeToWARN(returnCode);
-    } else if (sizeFinder.getSize() < minWarn) {
-      tstr = sName +  ": " + strEx::itos_as_BKMG(sizeFinder.getSize());
+    } else if (path.warn_.min.hasBounds() && path.warn_.min.checkMIN(sizeFinder.getSize())) {
+      tstr += path.warn_.min.prettyPrint(sName, sizeFinder.getSize()) + " < warning";
       NSCHelper::escalteReturnCodeToWARN(returnCode);
     } else if (bShowAll) {
       tstr = sName +  ": " + strEx::itos_as_BKMG(sizeFinder.getSize());
     }
-    if (!(*pit).first.empty())
-      perf += (*pit).first + "=" + strEx::itos(sizeFinder.getSize()) + ";" + strEx::itos(maxWarn) + ";" + strEx::itos(maxCrit) + " ";
+    perf += checkHolders::SizeMaxMin<>::printPerf(sName, sizeFinder.getSize(), path.warn_, path.crit_);
     if (!message.empty() && !tstr.empty())
       message += ", ";
     if (!tstr.empty())
-      message += tstr;
+      message = tstr;
   }
   if (message.empty())
@@ -351 +344 @@
 }
 
-
-#define BUFFER_SIZE 1024*64
-
 NSCAPI::nagiosReturn CheckDisk::handleCommand(const strEx::blindstr command, const unsigned int argLen, char **char_args, std::string &msg, std::string &perf) {
   if (command == "CheckFileSize") {

trunk/modules/CheckSystem/CheckSystem.cpp

@@ -593 +593 @@
     try {
       PDH::PDHQuery pdh;
-      PDHCollectors::StaticPDHCounterListenerInt counter;
+      PDHCollectors::StaticPDHCounterListener<double, PDH_FMT_DOUBLE> counter;
       std::string name = (*it).first;
       if (name.empty())
@@ -601 +601 @@
       pdh.collect();
       if (bNSCLientCompatible) {
-//        std::cout << counter.getValue() << std::endl;
         msg += strEx::itos(counter.getValue());
       } else {
@@ -632 +631 @@
   if (msg.empty())
     msg = "OK all counters within bounds.";
-  else
+  else if (!bNSCLientCompatible)
     msg = NSCHelper::translateReturn(returnCode) + ": " + msg;
   return returnCode;

trunk/modules/CheckSystem/PDHCollector.cpp

@@ -50 +50 @@
 */
 DWORD PDHCollector::threadProc(LPVOID lpParameter) {
+  hStopEvent_ = CreateEvent(NULL, TRUE, FALSE, NULL);
+  if (!hStopEvent_) {
+    NSC_LOG_ERROR_STD("Create StopEvent failed: " + strEx::itos(GetLastError()));
+    return 0;
+  }
   PDH::PDHQuery pdh;
   pdh.addCounter(NSCModuleHelper::getSettingsString(C_SYSTEM_SECTION_TITLE, C_SYSTEM_MEM_PAGE_LIMIT, C_SYSTEM_MEM_PAGE_LIMIT_DEFAULT), &memCmtLim);
@@ -63 +68 @@
   }
 
-  hStopEvent_ = CreateEvent(NULL, TRUE, FALSE, NULL);
-  if (!hStopEvent_) {
-    NSC_LOG_ERROR_STD("Create StopEvent failed: " + strEx::itos(GetLastError()));
-    return 0;
-  }
 
   do {

trunk/modules/CheckSystem/PDHCollector.h

@@ -30 +30 @@
   int checkIntervall_;
 
-  PDHCollectors::StaticPDHCounterListenerInt memCmtLim;
-  PDHCollectors::StaticPDHCounterListenerInt memCmt;
-  PDHCollectors::StaticPDHCounterListenerInt upTime;
-  PDHCollectors::RoundINTPDHBufferListener cpu;
+  PDHCollectors::StaticPDHCounterListener<__int64, PDH_FMT_LARGE> memCmtLim;
+  PDHCollectors::StaticPDHCounterListener<__int64, PDH_FMT_LARGE> memCmt;
+  PDHCollectors::StaticPDHCounterListener<__int64, PDH_FMT_LARGE> upTime;
+  PDHCollectors::RoundINTPDHBufferListener<__int64, PDH_FMT_LARGE> cpu;
 
 public:

trunk/modules/NSClientListener/NSClientListener.cpp

@@ -180 +180 @@
     case REQ_SERVICESTATE:  // Some check_nt commands return the return code (coded as a string)
     case REQ_PROCSTATE:
-      return NSCHelper::translateReturn(ret) + "&" + message;
+      return strEx::itos(NSCHelper::nagios2int(ret)) + "& " + message;
 
     default:        // "New" check_nscp also returns performance data