Changeset c09c225 in nscp for modules/CheckDisk

Timestamp:

09/25/08 19:58:20 (5 years ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2, stable

Children:

7531979

Parents:

bb8b6d1

Message:

2008-09-24 MickeM - 0.3.5

• Fixed issue with CheckServiceState and CheckAll? (it now works) + Added new check: CheckFile2 which has the same syntax as the event log filtering.

Usage: CheckFile2 file=c:\test\*.txt filter=in filter+creation=<24h "syntax=%filename% was created %creation%" MinWarn=0 MinCrit=0

Location:

modules/CheckDisk

Files:

• CheckDisk.cpp (modified) (5 diffs)
• CheckDisk.h (modified) (1 diff)

modules/CheckDisk/CheckDisk.cpp

@@ -365 +365 @@
 
 struct file_filter {
-  filters::filter_all_numeric<unsigned long long, checkHolders::disk_size_handler<checkHolders::disk_size_type> > fileSize;
-  filters::filter_all_times fileCreation;
-  filters::filter_all_times fileAccessed;
-  filters::filter_all_times fileWritten;
+  filters::filter_all_numeric<unsigned long long, checkHolders::disk_size_handler<checkHolders::disk_size_type> > size;
+  filters::filter_all_times creation;
+  filters::filter_all_times accessed;
+  filters::filter_all_times written;
   static const __int64 MSECS_TO_100NS = 10000;
 
   inline bool hasFilter() {
-    return fileSize.hasFilter() || fileCreation.hasFilter() || 
-      fileAccessed.hasFilter() || fileWritten.hasFilter();
+    return size.hasFilter() || creation.hasFilter() || 
+      accessed.hasFilter() || written.hasFilter();
   }
   bool matchFilter(const file_info &value) const {
-    if ((fileSize.hasFilter())&&(fileSize.matchFilter(value.ullSize)))
+    if ((size.hasFilter())&&(size.matchFilter(value.ullSize)))
       return true;
-    else if ((fileCreation.hasFilter())&&(fileCreation.matchFilter((value.ullNow-value.ullCreationTime)/MSECS_TO_100NS)))
+    else if ((creation.hasFilter())&&(creation.matchFilter((value.ullNow-value.ullCreationTime)/MSECS_TO_100NS)))
       return true;
-    else if ((fileAccessed.hasFilter())&&(fileAccessed.matchFilter((value.ullNow-value.ullLastAccessTime)/MSECS_TO_100NS)))
+    else if ((accessed.hasFilter())&&(accessed.matchFilter((value.ullNow-value.ullLastAccessTime)/MSECS_TO_100NS)))
       return true;
-    else if ((fileWritten.hasFilter())&&(fileWritten.matchFilter((value.ullNow-value.ullLastWriteTime)/MSECS_TO_100NS)))
+    else if ((written.hasFilter())&&(written.matchFilter((value.ullNow-value.ullLastWriteTime)/MSECS_TO_100NS)))
       return true;
     return false;
   }
+
+  std::wstring getValue() const {
+    if (size.hasFilter())
+      return _T("size: ") + size.getValue();
+    if (creation.hasFilter())
+      return _T("creation: ") + creation.getValue();
+    if (accessed.hasFilter())
+      return _T("accessed: ") + accessed.getValue();
+    if (written.hasFilter())
+      return _T("written: ") + written.getValue();
+    return _T("UNknown...");
+  }
+
 };
 
@@ -480 +493 @@
 };
 
+
+
+struct file_filter_function_ex : public baseFinderFunction
+{
+  static const int filter_plus = 1;
+  static const int filter_minus = 2;
+  static const int filter_normal = 3;
+
+  typedef std::pair<int,file_filter> filteritem_type;
+  typedef std::list<filteritem_type > filterlist_type;
+  filterlist_type filter_chain;
+  bool bFilterAll;
+  bool bFilterIn;
+  bool error;
+  bool debug_;
+  std::wstring message;
+  std::wstring syntax;
+  std::wstring alias;
+  unsigned long long now;
+  unsigned int hit_count;
+
+  file_filter_function_ex() : hit_count(0), error(false), debug_(false), bFilterIn(true), bFilterAll(true) {}
+  result_type operator()(argument_type ffd) {
+    if ((ffd.wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
+      return true;
+    BY_HANDLE_FILE_INFORMATION _info;
+
+    HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).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) {
+      setError(_T("Could not open file: ") + ffd.path + _T("\\") + ffd.wfd.cFileName + _T(": ") + error::lookup::last_error());
+    }
+    GetFileInformationByHandle(hFile, &_info);
+    CloseHandle(hFile);
+    file_info info(_info, ffd.wfd.cFileName);
+    info.ullNow = now;
+
+    bool bMatch = !bFilterIn;
+    for (filterlist_type::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) {
+      bool bTmpMatched = (*cit3).second.matchFilter(info);
+      int mode = (*cit3).first;
+
+      if ((mode == filter_minus)&&(bTmpMatched)) {
+        // a -<filter> hit so thrash item and bail out!
+        //if (debug_)
+          NSC_DEBUG_MSG_STD(_T("Matched: - ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax));
+        bMatch = false;
+        break;
+      } else if ((mode == filter_plus)&&(!bTmpMatched)) {
+        // a +<filter> missed hit so thrash item and bail out!
+        //if (debug_)
+          NSC_DEBUG_MSG_STD(_T("Matched (missed): + ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax));
+        bMatch = false;
+        break;
+      } else if (bTmpMatched) {
+        if (debug_)
+          NSC_DEBUG_MSG_STD(_T("Matched: . (contiunue): ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax));
+        bMatch = true;
+      }
+    }
+
+    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));
+      if (alias.length() < 16)
+        strEx::append_list(alias, info.filename);
+      else
+        strEx::append_list(alias, std::wstring(_T("...")));
+      hit_count++;
+    }
+    return true;
+  }
+  inline const bool hasError() const {
+    return error;
+  }
+  inline void setError(std::wstring) {
+    error = true;
+  }
+};
+
+
 NSCAPI::nagiosReturn CheckDisk::getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) {
   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
@@ -544 +638 @@
       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out"))
       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterAll, _T("all"), _T("any"))
-      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-size"), fileSize, finder.filter_chain)
-      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-creation"), fileCreation, finder.filter_chain)
-      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-written"), fileWritten, finder.filter_chain)
-      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-accessed"), fileAccessed, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-size"), size, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-creation"), creation, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-written"), written, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-accessed"), accessed, finder.filter_chain)
       MAP_OPTIONS_MISSING(message, _T("Unknown argument: "))
       MAP_OPTIONS_END()
@@ -585 +679 @@
 }
 
+#define MAP_FILTER(value, obj, filtermode) \
+      else if (p__.first == value) { file_filter filter; filter.obj = p__.second; finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filtermode, filter)); }
+
+NSCAPI::nagiosReturn CheckDisk::CheckFile2(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);
+  typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsUInteger> CheckFileContainer;
+  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;
+  }
+  file_filter_function_ex finder;
+  PathContainer tmpObject;
+  std::list<std::wstring> paths;
+  unsigned int truncate = 0;
+  CheckFileContainer query;
+  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_PUSH(_T("path"), paths)
+      MAP_OPTIONS_STR(_T("alias"), alias)
+      MAP_OPTIONS_PUSH(_T("file"), paths)
+      MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out"))
+      MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterAll, _T("all"), _T("any"))
+      /*
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-size"), fileSize, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-creation"), fileCreation, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-written"), fileWritten, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-accessed"), fileAccessed, finder.filter_chain)
+      */
+
+      MAP_FILTER(_T("filter+size"), size, filter_plus)
+      MAP_FILTER(_T("filter+creation"), creation, filter_plus)
+      MAP_FILTER(_T("filter+written"), written, filter_plus)
+      MAP_FILTER(_T("filter+accessed"), accessed, filter_plus)
+
+      MAP_FILTER(_T("filter.size"), size, filter_normal)
+      MAP_FILTER(_T("filter.creation"), creation, filter_normal)
+      MAP_FILTER(_T("filter.written"), written, filter_normal)
+      MAP_FILTER(_T("filter.accessed"), accessed, filter_normal)
+
+      MAP_FILTER(_T("filter-size"), size, filter_minus)
+      MAP_FILTER(_T("filter-creation"), creation, filter_minus)
+      MAP_FILTER(_T("filter-written"), written, filter_minus)
+      MAP_FILTER(_T("filter-accessed"), accessed, filter_minus)
+
+      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);
+    finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime);
+    finder.syntax = syntax;
+    for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) {
+      recursive_scan<file_filter_function_ex>((*pit), finder);
+      if (finder.hasError()) {
+        message = _T("Error when scanning: ") + (*pit);
+        return NSCAPI::returnUNKNOWN;
+      }
+    }
+    message = finder.message;
+    if (!alias.empty())
+      query.alias = alias;
+    else
+      query.alias = finder.alias;
+    if (query.alias.empty())
+      query.alias = _T("no files found");
+    query.runCheck(finder.hit_count, returnCode, message, perf);
+    if ((truncate > 0) && (message.length() > (truncate-4)))
+      message = message.substr(0, truncate-4) + _T("...");
+    if (message.empty())
+      message = _T("CheckFile 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")) {
@@ -592 +776 @@
   } else if (command == _T("CheckFile")) {
     return CheckFile(argLen, char_args, msg, perf);
+  } else if (command == _T("CheckFile2")) {
+    return CheckFile2(argLen, char_args, msg, perf);
   } else if (command == _T("getFileAge")) {
     return getFileAge(argLen, char_args, msg, perf);

modules/CheckDisk/CheckDisk.h

@@ -55 +55 @@
   NSCAPI::nagiosReturn CheckDriveSize(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf);
   NSCAPI::nagiosReturn CheckFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf);
+  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);