Changeset 227

Timestamp:

12/13/09 22:35:12 (2 years ago)

Author:

mickem

Message:

2009-12-13 MickeM

+ Added new command: CheckSingleFile? to check spects of a single file use like so:

CheckSingleFile? file=d:\nrpe_512.pem warn=>100 check=line-count warn=>100 crit=>170 check=size

+ Added option debug to CheckFile2 to enable priting of debug information
+ Added ignore-errors to "ignore" any filesystem related errors (NOTICE this is probably not what you want)
+ Added master-syntax to CheckFile2 to change the overall message like so:

It takes three options (and char data):

• %list% A list of all "files" (syntax controls this)
• %files% number of files
• %matches% number of files matched

CheckFile2 MinWarn=10 MinCrit=10 path=D:\WINDOWS\system32 filter+size=gt:0 truncate=10 ignore-errors "master-syntax=%matches%/%files%"
OK:7177/7...|'found files'=7177;10;10;

Location:

branches/stable

Files:

• . (modified) (1 prop)
• AutoBuild.h (modified) (1 diff)
• changelog (modified) (1 diff)
• include/checkHelpers.hpp (modified) (5 diffs)
• include/file_helpers.hpp (modified) (1 diff)
• include/utils.h (modified) (1 diff)
• modules/CheckDisk/CheckDisk.cpp (modified) (30 diffs)
• modules/CheckDisk/CheckDisk.h (modified) (1 diff)

branches/stable

@@ -14 +14 @@
 NSClient++-2005.suo
 *.bak
+build.log

@@ -14 +14 @@
 NSClient++-2005.suo
 *.bak
+build.log

branches/stable/AutoBuild.h

@@ -3 +3 @@
 // change the FALSE to TRUE for autoincrement of build number
 #define INCREMENT_VERSION TRUE
-#define FILEVER        0,3,7,496
-#define PRODUCTVER     0,3,7,496
-#define STRFILEVER     _T("0.3.7.496")
-#define STRPRODUCTVER  _T("0.3.7.496")
-#define STRPRODUCTDATE  _T("2009-12-06")
+#define FILEVER        0,3,7,512
+#define PRODUCTVER     0,3,7,512
+#define STRFILEVER     _T("0.3.7.512")
+#define STRPRODUCTVER  _T("0.3.7.512")
+#define STRPRODUCTDATE  _T("2009-12-13")
 #endif // AUTOBUILD_H

branches/stable/changelog

@@ -6 +6 @@
  * Fix depend onservice LanManWorkStation (old win)
  * Fix RtlStringFromGUID problem on NT4
+
+2009-12-13 MickeM
+ + Added new command: CheckSingleFile to check spects of a single file use like so:
+   CheckSingleFile file=d:\nrpe_512.pem warn=>100 check=line-count warn=>100 crit=>170 check=size
+ + Added option debug to CheckFile2 to enable priting of debug information
+ + Added ignore-errors to "ignore" any filesystem related errors (NOTICE this is probably not what you want)
+ + Added master-syntax to CheckFile2 to change the overall message like so:
+    It takes three options (and char data):
+     * %list% A list of all "files" (syntax controls this)
+     * %files% number of files
+     * %matches% number of files matched
+    CheckFile2 MinWarn=10 MinCrit=10 path=D:\WINDOWS\system32 filter+size=gt:0 truncate=10 ignore-errors "master-syntax=%matches%/%files%"
+    OK:7177/7...|'found files'=7177;10;10;
 
 2009-12-06 MickeM

branches/stable/include/checkHelpers.hpp

@@ -27 +27 @@
 
 namespace checkHolders {
+
 
 
@@ -88 +89 @@
   }
 
+
   typedef enum {showLong, showShort, showProblems, showUnknown} showType;
   template <class TContents>
   struct CheckContainer {
     typedef CheckContainer<TContents> TThisType;
+    typedef typename TContents::TValueType TPayloadValueType;
     TContents warn;
     TContents crit;
@@ -129 +132 @@
     }
     std::wstring gatherPerfData(typename TContents::TValueType &value) {
-      return crit.gatherPerfData(getAlias(), value, warn, crit);
+      if (crit.hasBounds())
+        return crit.gatherPerfData(getAlias(), value, warn, crit);
+      else if (warn.hasBounds())
+        return warn.gatherPerfData(getAlias(), value, warn, crit);
+      else
+        return getAlias() + _T(": ERROR");
     }
     bool hasBounds() {
@@ -156 +164 @@
         message += tstr;
       //std::wcout << _T("result: ") << tstr << _T("--") << std::endl;
+    }
+  };
+
+
+  template <class value_type>
+  struct check_proxy_interface {
+    virtual bool showAll() = 0;
+    virtual std::wstring gatherPerfData(value_type &value) = 0;
+    virtual bool hasBounds() = 0;
+    virtual void runCheck(value_type &value, NSCAPI::nagiosReturn &returnCode, std::wstring &message, std::wstring &perf) = 0;
+    virtual void set_warn_bound(std::wstring value) = 0;
+    virtual void set_crit_bound(std::wstring value) = 0;
+    //virtual std::wstring get_default_alias() = 0;
+
+  };
+
+
+  //typedef enum {showLong, showShort, showProblems, showUnknown} showType;
+  template <class container_value_type, class impl_type>
+  class check_proxy_container : public check_proxy_interface<container_value_type> {
+    typedef check_proxy_container<container_value_type, impl_type> TThisType;
+    impl_type impl_;
+  public:
+    virtual typename impl_type::TPayloadValueType get_value(container_value_type &value) = 0;
+
+    void set_warn_bound(std::wstring value) {
+      impl_.warn = value;
+    }
+    void set_crit_bound(std::wstring value) {
+      impl_.crit = value;
+    }
+    void set_alias(std::wstring value) {
+      impl_.alias = value;
+    }
+
+
+    check_proxy_container() {}
+    /*
+    void setDefault(TThisType def) {
+      if (!warn.hasBounds())
+        warn = def.warn;
+      if (!crit.hasBounds())
+        crit = def.crit;
+      if (show == showUnknown)
+        show = def.show;
+    }
+    */
+    bool showAll() {
+      return impl_.showAll();
+    }
+    std::wstring gatherPerfData(container_value_type &value) {
+      typename impl_type::TPayloadValueType real_value = get_value(value);
+      return impl_.gatherPerfData(real_value);
+    }
+    bool hasBounds() {
+      return impl_.hasBounds();
+    }
+    void runCheck(container_value_type &value, NSCAPI::nagiosReturn &returnCode, std::wstring &message, std::wstring &perf) {
+      typename impl_type::TPayloadValueType real_value = get_value(value);
+      return impl_.runCheck(real_value, returnCode, message, perf);
+    }
+  };
+
+
+  template <class value_type>
+  struct check_multi_container {
+    typedef check_multi_container<value_type> TThisType;
+    typedef check_proxy_interface<value_type> check_type;
+    typedef std::list<check_type*> check_list_type;
+    check_list_type checks_;
+    std::wstring data;
+    std::wstring alias;
+
+    std::wstring cached_warn_;
+    std::wstring cached_crit_;
+
+    showType show;
+    bool perfData;
+
+    void set_warn_bound(std::wstring value) {
+//      if (checks_.empty())
+        cached_warn_ = value;
+//      else
+//        (checks_.back())->set_warn_bound(value);
+    }
+    void set_crit_bound(std::wstring value) {
+//      if (checks_.empty())
+        cached_crit_ = value;
+//      else
+//        (checks_.back())->set_crit_bound(value);
+    }
+
+    void add_check(check_type *check) {
+      if (check != NULL) {
+        if (!cached_warn_.empty())
+          check->set_warn_bound(cached_warn_);
+        if (!cached_crit_.empty())
+          check->set_crit_bound(cached_crit_);
+        checks_.push_back(check);
+      }
+      cached_warn_ = _T("");
+      cached_crit_ = _T("");
+    }
+
+    check_multi_container() : show(showUnknown), perfData(true)
+    {}
+  private:
+    check_multi_container(const TThisType &other) 
+      : data(other.data), alias(other.alias), checks_(other.checks_), show(other.show) 
+    {}
+  public:
+    ~check_multi_container() {
+      for (check_list_type::iterator it=checks_.begin(); it != checks_.end(); ++it) {
+        delete *it;
+      }
+      checks_.clear();
+    }
+    std::wstring getAlias() {
+      if (alias.empty())
+        return data;
+      return alias;
+    }
+    void setDefault(TThisType def) {
+      if (show == showUnknown)
+        show = def.show;
+    }
+    bool showAll() {
+      return show != showProblems;
+    }
+    std::wstring gatherPerfData(value_type &value) {
+      std::wstring ret;
+      for (check_list_type::const_iterator cit=checks_.begin(); cit != checks_.end(); ++cit) {
+        ret += (*cit)->gatherPerfData((*cit)->getAlias(), value);
+      }
+    }
+    bool hasBounds() {
+      for (check_list_type::const_iterator cit=checks_.begin(); cit != checks_.end(); ++cit) {
+        if ((*cit)->hasBounds())
+          return true;
+      }
+      return false;
+    }
+    void runCheck(value_type &value, NSCAPI::nagiosReturn &returnCode, std::wstring &message, std::wstring &perf) {
+      for (check_list_type::const_iterator cit=checks_.begin(); cit != checks_.end(); ++cit) {
+        (*cit)->runCheck(value, returnCode, message, perf);
+      }
+      std::wcout << _T("result: ") << message << std::endl;
     }
   };
@@ -878 +1033 @@
   };
   typedef ExactBounds<NumericBounds<unsigned long int, int_handler> > ExactBoundsULongInteger;
+  typedef ExactBounds<NumericBounds<unsigned int, int_handler> > ExactBoundsUInteger;
+  typedef ExactBounds<NumericBounds<unsigned long, int_handler> > ExactBoundsULong;
+  typedef ExactBounds<NumericBounds<time_type, time_handler<__int64> > > ExactBoundsTime;
 
   //typedef MaxMinBounds<NumericPercentageBounds<PercentageValueType<int ,int>, int_handler> > MaxMinPercentageBoundsInteger;

branches/stable/include/file_helpers.hpp

@@ -30 +30 @@
     }
   };
+  class meta {
+  public:
+    static std::wstring get_path(std::wstring file) {
+      std::wstring::size_type pos = file.find_last_of('\\');
+      if (pos == std::wstring::npos) {
+        return file;
+      }
+      return file.substr(0, pos);
+    }
+    static std::wstring get_filename(std::wstring file) {
+      std::wstring::size_type pos = file.find_last_of('\\');
+      if (pos == std::wstring::npos || ++pos == std::wstring::npos) {
+        return _T("");
+      }
+      return file.substr(pos);
+    }
+  };
 
   class patterns {

branches/stable/include/utils.h

@@ -61 +61 @@
       else if (p__.first == (_T("crit") postfix)) { obj.crit = p__.second; } \
 
+#define MAP_OPTIONS_EXACT_NUMERIC_ALL_MULTI(obj, postfix) \
+      else if (p__.first == (_T("warn") postfix)) { obj.set_warn_bound(p__.second); } \
+      else if (p__.first == (_T("crit") postfix)) { obj.set_crit_bound(p__.second); } \
+
 #define MAP_OPTIONS_PUSH_WTYPE(type, value, obj, list) \
       else if (p__.first == value) { type o; o.obj = p__.second; list.push_back(o); }

branches/stable/modules/CheckDisk/CheckDisk.cpp

@@ -26 +26 @@
 #include <error.hpp>
 #include <file_helpers.hpp>
+#include <checkHelpers.hpp>
 
 CheckDisk gCheckDisk;
@@ -108 +109 @@
 
 template <class finder_function>
-void recursive_scan(std::wstring dir, std::wstring pattern, int current_level, int max_level, finder_function & f, error_reporter * errors) {
+void recursive_scan(std::wstring dir, std::wstring pattern, int current_level, int max_level, finder_function & f, error_reporter * errors, bool debug) {
   if ((max_level != -1) && (current_level > max_level))
     return;
@@ -114 +115 @@
 
   DWORD fileAttr = GetFileAttributes(dir.c_str());
-  NSC_DEBUG_MSG_STD(_T("Input is: ") + dir + _T(" / ") + strEx::ihextos(fileAttr));
+  if (debug) NSC_DEBUG_MSG_STD(_T("Input is: ") + dir + _T(" / ") + strEx::ihextos(fileAttr));
 
   if (!is_directory(fileAttr)) {
-    NSC_DEBUG_MSG_STD(_T("Found a file dont do recursive scan: ") + dir);
+    if (debug) NSC_DEBUG_MSG_STD(_T("Found a file dont do recursive scan: ") + dir);
     // It is a file check it an return (dont check recursivly)
     pattern_type single_path = split_path_ex(dir);
-    NSC_DEBUG_MSG_STD(_T("Path is: ") + single_path.first);
+    if (debug) NSC_DEBUG_MSG_STD(_T("Path is: ") + single_path.first);
     HANDLE hFind = FindFirstFile(dir.c_str(), &wfd);
     if (hFind != INVALID_HANDLE_VALUE) {
@@ -129 +130 @@
   }
   std::wstring file_pattern = dir + _T("\\") + pattern;
-  NSC_DEBUG_MSG_STD(_T("File pattern: ") + file_pattern);
+  if (debug) NSC_DEBUG_MSG_STD(_T("File pattern: ") + file_pattern);
   HANDLE hFind = FindFirstFile(file_pattern.c_str(), &wfd);
   if (hFind != INVALID_HANDLE_VALUE) {
@@ -139 +140 @@
   }
   std::wstring dir_pattern = dir + _T("\\*.*");
-  NSC_DEBUG_MSG_STD(_T("File pattern: ") + dir_pattern);
+  if (debug) NSC_DEBUG_MSG_STD(_T("File pattern: ") + dir_pattern);
   hFind = FindFirstFile(dir_pattern.c_str(), &wfd);
   if (hFind != INVALID_HANDLE_VALUE) {
@@ -145 +146 @@
       if (is_directory(wfd.dwFileAttributes)) {
         if ( (wcscmp(wfd.cFileName, _T(".")) != 0) && (wcscmp(wfd.cFileName, _T("..")) != 0) )
-          recursive_scan<finder_function>(dir + _T("\\") + wfd.cFileName, pattern, current_level+1, max_level, f, errors);
+          recursive_scan<finder_function>(dir + _T("\\") + wfd.cFileName, pattern, current_level+1, max_level, f, errors, debug);
       }
     } while (FindNextFile(hFind, &wfd));
@@ -355 +356 @@
   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args);
   bool bPerfData = true;
+  bool debug = false;
   if (args.empty()) {
     message = _T("Missing argument(s).");
@@ -369 +371 @@
     MAP_OPTIONS_STR(_T("MaxCrit"), tmpObject.crit.max)
     MAP_OPTIONS_STR(_T("MinCrit"), tmpObject.crit.min)
+    MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug)
     MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
     MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2)
@@ -388 +391 @@
     NSC_error errors;
     pattern_type splitpath = split_pattern(path.data);
-    recursive_scan<get_size>(splitpath.first, splitpath.second, -1, -1, sizeFinder, &errors);
+    recursive_scan<get_size>(splitpath.first, splitpath.second, -1, -1, sizeFinder, &errors, debug);
     if (sizeFinder.hasError()) {
       message = _T("File not found check log for details");
@@ -410 +413 @@
   file_info() 
     : ullCreationTime(0)
+    , ullLastAccessTime(0)
+    , ullLastWriteTime(0)
+    , ullSize(0)
     , cached_version(false, _T("")) 
     , cached_count(false, 0)
@@ -417 +423 @@
     , filename(filename_)
     , ullCreationTime(0)
+    , ullLastAccessTime(0)
+    , ullLastWriteTime(0)
+    , ullSize(0)
     , cached_version(false, _T("")) 
     , cached_count(false, 0)
@@ -424 +433 @@
     ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime);
     ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime);
+  };
+  file_info(std::wstring path_, std::wstring filename_) 
+    : path(path_)
+    , filename(filename_)
+    , ullCreationTime(0)
+    , ullLastAccessTime(0)
+    , ullLastWriteTime(0)
+    , ullSize(0)
+    , cached_version(false, _T("")) 
+    , cached_count(false, 0)
+  {
   };
 
@@ -489 +509 @@
     do {
       c = fgetc (pFile);
-      if (c == '\n') count++;
+      if (c == '\r') {
+        c = fgetc (pFile);
+        count++;
+      } else if (c == '\n') {
+        c = fgetc (pFile);
+        count++;
+      }
     } while (c != EOF);
     fclose (pFile);
@@ -662 +688 @@
   unsigned long long now;
   unsigned int hit_count;
-
-  file_filter_function_ex() : hit_count(0), error(false), debug_(false), bFilterIn(true), bFilterAll(true) {}
+  unsigned int file_count;
+  std::wstring last_error;
+  unsigned int error_count;
+
+  file_filter_function_ex() : hit_count(0), file_count(0), error(false), debug_(false), bFilterIn(true), bFilterAll(true), error_count(0) {}
   result_type operator()(argument_type ffd) {
     if (is_directory(ffd.wfd.dwFileAttributes))
@@ -687 +716 @@
       if ((mode == filter_minus)&&(bTmpMatched)) {
         // a -<filter> hit so thrash item and bail out!
-        //if (debug_)
+        if (debug_)
           NSC_DEBUG_MSG_STD(_T("Matched: - ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax));
         bMatch = false;
@@ -693 +722 @@
       } else if ((mode == filter_plus)&&(!bTmpMatched)) {
         // a +<filter> missed hit so thrash item and bail out!
-        //if (debug_)
+        if (debug_)
           NSC_DEBUG_MSG_STD(_T("Matched (missed): + ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax));
         bMatch = false;
@@ -704 +733 @@
     }
 
-    NSC_DEBUG_MSG_STD(_T("result: ") + strEx::itos(bFilterIn) + _T(" -- ") + strEx::itos(bMatch));
+    //NSC_DEBUG_MSG_STD(_T("result: ") + strEx::itos(bFilterIn) + _T(" -- ") + strEx::itos(bMatch));
     if ((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch)) {
       strEx::append_list(message, info.render(syntax));
@@ -715 +744 @@
       hit_count++;
     }
+    file_count++;
     return true;
   }
@@ -723 +753 @@
     if (errors != NULL)
       errors->report_error(msg);
+    last_error = msg;
+    error_count++;
     error = true;
   }
+
+  std::wstring render(std::wstring syntax) {
+    strEx::replace(syntax, _T("%list%"), message);
+    strEx::replace(syntax, _T("%matches%"), strEx::itos(hit_count));
+    strEx::replace(syntax, _T("%files%"), strEx::itos(file_count));
+    return syntax;
+  }
+
 };
 
@@ -738 +778 @@
   std::wstring format = _T("%Y years %m mon %d days %H hours %M min %S sec");
   std::wstring path;
+  bool debug = false;
   find_first_file_info finder;
   MAP_OPTIONS_BEGIN(stl_args)
     MAP_OPTIONS_STR(_T("path"), path)
     MAP_OPTIONS_STR(_T("date"), format)
+    MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug)
     MAP_OPTIONS_FALLBACK(format)
   MAP_OPTIONS_END()
@@ -752 +794 @@
   NSC_error errors;
   pattern_type splitpath = split_pattern(path);
-  recursive_scan<find_first_file_info>(splitpath.first, splitpath.second, -1, -1, finder, &errors);
+  recursive_scan<find_first_file_info>(splitpath.first, splitpath.second, -1, -1, finder, &errors, debug);
   if (finder.hasError()) {
     message = _T("File not found (check log for details)");
@@ -783 +825 @@
   bool bPerfData = true;
   unsigned int max_dir_depth = -1;
+  bool debug = false;
 
   try {
@@ -794 +837 @@
       MAP_OPTIONS_STR2INT(_T("max-dir-depth"), max_dir_depth)
       MAP_OPTIONS_PUSH(_T("file"), paths)
+      MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug)
       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out"))
       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterAll, _T("all"), _T("any"))
@@ -816 +860 @@
   for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) {
     pattern_type path = split_pattern(*pit);
-    recursive_scan<file_filter_function>(path.first, path.second, 0, max_dir_depth, finder, &errors);
+    recursive_scan<file_filter_function>(path.first, path.second, 0, max_dir_depth, finder, &errors, debug);
     if (finder.hasError()) {
       message = _T("File not found: ") + (*pit) + _T(" check log for details.");
@@ -863 +907 @@
   CheckFileContainer query;
   std::wstring syntax = _T("%filename%");
+  std::wstring masterSyntax = _T("%list%");
   std::wstring alias;
   std::wstring pattern = _T("*.*");
   bool bPerfData = true;
   int max_dir_depth = -1;
+  bool debug = false;
+  bool ignoreError = false;
 
   try {
@@ -874 +921 @@
       MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
       MAP_OPTIONS_STR(_T("syntax"), syntax)
+      MAP_OPTIONS_STR(_T("master-syntax"), masterSyntax)
       MAP_OPTIONS_PUSH(_T("path"), paths)
       MAP_OPTIONS_STR(_T("pattern"), pattern)
       MAP_OPTIONS_STR(_T("alias"), alias)
       MAP_OPTIONS_PUSH(_T("file"), paths)
+      MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug)
+      MAP_OPTIONS_BOOL_TRUE(_T("ignore-errors"), ignoreError)
       MAP_OPTIONS_STR2INT(_T("max-dir-depth"), max_dir_depth)
       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out"))
@@ -918 +968 @@
     FILETIME now;
     GetSystemTimeAsFileTime(&now);
+    finder.debug_ = debug;
     finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime);
     finder.syntax = syntax;
     NSC_error errors;
     for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) {
-      recursive_scan<file_filter_function_ex>(*pit, pattern, 0, max_dir_depth, finder, &errors);
-      if (finder.hasError()) {
-        message = _T("Error when scanning: ") + (*pit) + _T(" check log for details.");
+      recursive_scan<file_filter_function_ex>(*pit, pattern, 0, max_dir_depth, finder, &errors, debug);
+      if (!ignoreError && finder.hasError()) {
+        message = _T("Error when scanning: ") + (*pit) + _T(" check log for details (") + strEx::itos(finder.error_count) + _T(": ") + finder.last_error + _T(")");
         return NSCAPI::returnUNKNOWN;
       }
     }
-    message = finder.message;
+    message  = finder.render(masterSyntax);
     if (!alias.empty())
       query.alias = alias;
@@ -936 +987 @@
     if ((truncate > 0) && (message.length() > (truncate-4))) {
       message = message.substr(0, truncate-4) + _T("...");
-      perf = _T("");
+      //perf = _T("");
     }
     if (message.empty())
@@ -942 +993 @@
     return returnCode;
 }
-
+struct file_container : public file_info {
+  std::wstring error_;
+  
+
+  file_container(const BY_HANDLE_FILE_INFORMATION info, std::wstring file) : file_info(info, file_helpers::meta::get_path(file), file_helpers::meta::get_filename(file)) {}
+  file_container(std::wstring file, std::wstring error) : error_(error), file_info(file_helpers::meta::get_path(file), file_helpers::meta::get_filename(file)) {}
+
+  bool has_errors() {
+    return !error_.empty();
+  }
+  std::wstring get_error() {
+    return error_;
+  }
+
+};
+
+typedef checkHolders::ExactBounds<checkHolders::NumericBounds<checkHolders::disk_size_type, checkHolders::disk_size_handler<checkHolders::disk_size_type> > > ExactBoundsDiscSize;
+
+
+typedef checkHolders::CheckContainer<checkHolders::ExactBoundsULong> ExactULongContainer;
+typedef checkHolders::CheckContainer<ExactBoundsDiscSize> DiscSizeContainer;
+typedef checkHolders::CheckContainer<checkHolders::ExactBoundsTime> DateTimeContainer;
+
+struct check_file_size : public checkHolders::check_proxy_container<file_container, DiscSizeContainer> {
+  check_file_size() { set_alias(_T("size")); }
+  checkHolders::disk_size_type get_value(file_container &value) {
+    return value.ullSize;
+  }
+};
+struct check_file_line_count : public checkHolders::check_proxy_container<file_container, ExactULongContainer> {
+  check_file_line_count() { set_alias(_T("line-count")); }
+  unsigned long get_value(file_container &value) {
+    return value.get_line_count();
+  }
+};
+struct check_file_dates : public checkHolders::check_proxy_container<file_container, DateTimeContainer> {
+  enum type_type {
+    date_access, date_creation, date_written
+  } ;
+  type_type type_;
+  check_file_dates(type_type type) : type_(type) 
+  { 
+    if (type_ == date_creation)
+      set_alias(_T("creation")); 
+    else if (type_ == date_access)
+      set_alias(_T("access")); 
+    else if (type_ == date_written)
+      set_alias(_T("written")); 
+    else
+      set_alias(_T("unknown date type")); 
+  }
+  unsigned long long get_value(file_container &value) {
+    if (type_ == date_creation)
+      return value.ullCreationTime;
+    if (type_ == date_access)
+      return value.ullLastAccessTime;
+    if (type_ == date_written)
+      return value.ullLastWriteTime;
+    return -1;
+  }
+};
+
+typedef checkHolders::check_multi_container<file_container> check_file_multi;
+struct check_file_factories {
+  static checkHolders::check_proxy_interface<file_container>* size() {
+    return new check_file_size();
+  }
+  static checkHolders::check_proxy_interface<file_container>* line_count() {
+    return new check_file_line_count();
+  }
+  static checkHolders::check_proxy_interface<file_container>* access() {
+    return new check_file_dates(check_file_dates::date_access);
+  }
+  static checkHolders::check_proxy_interface<file_container>* creation() {
+    return new check_file_dates(check_file_dates::date_creation);
+  }
+  static checkHolders::check_proxy_interface<file_container>* written() {
+    return new check_file_dates(check_file_dates::date_written);
+  }
+};
+
+file_container get_file_info(std::wstring file, unsigned long long now) {
+
+  BY_HANDLE_FILE_INFORMATION _info;
+
+  HANDLE hFile = CreateFile(file.c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+    0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+  if (hFile == INVALID_HANDLE_VALUE) {
+    return file_container(file, _T("Could not open file: ") + file);
+  }
+  GetFileInformationByHandle(hFile, &_info);
+  CloseHandle(hFile);
+  file_container info(_info, file);
+  info.ullNow = now;
+  return info;
+}
+
+#define MAP_FACTORY_PB(value, obj) \
+    else if ((p__.first == _T("check")) && (p__.second == ##value)) { checker.add_check(check_file_factories::obj()); }
+
+
+NSCAPI::nagiosReturn CheckDisk::CheckSingleFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) {
+  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
+  std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
+  check_file_multi checker;
+  typedef std::pair<int,file_filter> filteritem_type;
+  typedef std::list<filteritem_type > filterlist_type;
+  if (stl_args.empty()) {
+    message = _T("Missing argument(s).");
+    return NSCAPI::returnUNKNOWN;
+  }
+  std::list<std::wstring> files;
+  unsigned int truncate = 0;
+  std::wstring syntax = _T("%filename%");
+  std::wstring alias;
+  bool bPerfData = true;
+
+  try {
+    MAP_OPTIONS_BEGIN(stl_args)
+      //MAP_OPTIONS_NUMERIC_ALL(query, _T(""))
+      MAP_OPTIONS_STR2INT(_T("truncate"), truncate)
+      MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
+      MAP_OPTIONS_STR(_T("syntax"), syntax)
+      MAP_OPTIONS_STR(_T("alias"), alias)
+      MAP_OPTIONS_PUSH(_T("file"), files)
+      MAP_OPTIONS_EXACT_NUMERIC_ALL_MULTI(checker, _T(""))
+      MAP_FACTORY_PB(_T("size"), size)
+      MAP_FACTORY_PB(_T("line-count"), line_count)
+      MAP_FACTORY_PB(_T("creation"), creation)
+      MAP_FACTORY_PB(_T("access"), access)
+      MAP_FACTORY_PB(_T("written"), written)
+      /*
+      MAP_FILTER(_T("creation"), creation)
+      MAP_FILTER(_T("written"), written)
+      MAP_FILTER(_T("accessed"), accessed)
+      MAP_FILTER(_T("version"), version)
+      MAP_FILTER(_T("line-count"), line_count)
+      */
+      MAP_OPTIONS_MISSING(message, _T("Unknown argument: "))
+      MAP_OPTIONS_END()
+  } catch (filters::parse_exception e) {
+    message = e.getMessage();
+    return NSCAPI::returnUNKNOWN;
+  } catch (filters::filter_exception e) {
+    message = e.getMessage();
+    return NSCAPI::returnUNKNOWN;
+  }
+  FILETIME now;
+  GetSystemTimeAsFileTime(&now);
+  unsigned __int64 nowi64 = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime);
+  //finder.syntax = syntax;
+  for (std::list<std::wstring>::const_iterator pit = files.begin(); pit != files.end(); ++pit) {
+    file_container info = get_file_info(*pit, nowi64);
+    checker.alias = info.render(syntax);
+    checker.runCheck(info, returnCode, message, perf);
+  }
+  if ((truncate > 0) && (message.length() > (truncate-4))) {
+    message = message.substr(0, truncate-4) + _T("...");
+    perf = _T("");
+  }
+  if (message.empty())
+    message = _T("CheckSingleFile ok");
+  return returnCode;
+}
 NSCAPI::nagiosReturn CheckDisk::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) {
   if (command == _T("CheckFileSize")) {
@@ -952 +1166 @@
   } else if (command == _T("CheckFile2")) {
     return CheckFile2(argLen, char_args, msg, perf);
+  } else if (command == _T("CheckSingleFile")) {
+    return CheckSingleFile(argLen, char_args, msg, perf);
   } else if (command == _T("getFileAge")) {
     return getFileAge(argLen, char_args, msg, perf);

branches/stable/modules/CheckDisk/CheckDisk.h

@@ -57 +57 @@
   NSCAPI::nagiosReturn CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf);
   NSCAPI::nagiosReturn getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf);
+  NSCAPI::nagiosReturn CheckSingleFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf);
 
 private:

@@ -14 +14 @@
 NSClient++-2005.suo
 *.bak
+build.log