Changeset 250

Timestamp:

02/05/10 09:40:25 (2 years ago)

Author:

mickem

Message:

Reintegrated stable branch and removed some project files (no longer needed) (part x of many)

Location:

trunk/modules

Files:

• CheckDisk/CheckDisk-2005.vcproj (deleted)
• CheckDisk/CheckDisk-2008.vcproj (deleted)
• CheckDisk/CheckDisk.cpp (modified) (42 diffs)
• CheckDisk/CheckDisk.h (modified) (1 diff)
• CheckDisk/Jamfile (deleted)
• CheckEventLog/CheckEventLog-2005.vcproj (deleted)
• CheckEventLog/CheckEventLog-2008.vcproj (deleted)
• CheckEventLog/CheckEventLog.cpp (modified) (3 diffs)
• CheckEventLog/Jamfile (deleted)
• CheckExternalScripts/CheckExternalScripts-2005.vcproj (deleted)
• CheckExternalScripts/CheckExternalScripts-2008.vcproj (deleted)
• CheckExternalScripts/CheckExternalScripts.cpp (modified) (1 diff)
• CheckExternalScripts/Jamfile (deleted)
• CheckHelpers/CheckHelpers-2005.vcproj (deleted)
• CheckHelpers/CheckHelpers-2008.vcproj (deleted)
• CheckHelpers/CheckHelpers.cpp (modified) (3 diffs)
• CheckHelpers/CheckHelpers.h (modified) (1 diff)
• CheckHelpers/Jamfile (deleted)
• CheckSystem/CheckSystem-2005.vcproj (deleted)
• CheckSystem/CheckSystem-2008.vcproj (deleted)
• CheckSystem/CheckSystem.cpp (modified) (6 diffs)
• CheckSystem/CheckSystem.h (modified) (1 diff)
• CheckSystem/Jamfile (deleted)
• CheckSystem/PDHCollector.cpp (modified) (2 diffs)
• CheckSystem/PDHCollector.h (modified) (1 diff)
• CheckTaskSched/CheckTaskSched-2005.vcproj (deleted)
• CheckTaskSched/CheckTaskSched-2008.vcproj (deleted)
• CheckTaskSched/Jamfile (deleted)
• CheckWMI/CheckWMI-2005.vcproj (deleted)
• CheckWMI/CheckWMI-2008.vcproj (deleted)
• CheckWMI/Jamfile (deleted)
• DebugLogMetrics/DebugLogMetrics-2005.vcproj (deleted)
• DebugLogMetrics/DebugLogMetrics-2008.vcproj (deleted)
• DebugLogMetrics/Jamfile (deleted)
• FileLogger/FileLogger-2005.vcproj (deleted)
• FileLogger/FileLogger-2008.vcproj (deleted)
• FileLogger/Jamfile (deleted)
• LUAScript/Jamfile (deleted)
• LUAScript/LUAScript-2005.vcproj (deleted)
• LUAScript/LUAScript-2008.vcproj (deleted)
• NRPEClient/Jamfile (deleted)
• NRPEClient/NRPEClient-2005.vcproj (deleted)
• NRPEClient/NRPEClient.cpp (modified) (4 diffs)
• NRPEClient/NRPEClient.h (modified) (1 diff)
• NRPEServer/Jamfile (deleted)
• NRPEServer/NRPEListener-2005.vcproj (deleted)
• NRPEServer/NRPEListener-2008.vcproj (deleted)
• NRPEServer/NRPEServer.cpp (modified) (2 diffs)
• NSCAAgent/Jamfile (deleted)
• NSCAAgent/NSCAAgent-2005.vcproj (deleted)
• NSCAAgent/NSCAAgent-2008.vcproj (deleted)
• NSClientListener/Jamfile (deleted)
• NSClientListener/NSClientListener-2005.vcproj (deleted)
• NSClientListener/NSClientListener-2008.vcproj (deleted)
• RemoteConfiguration/Jamfile (deleted)
• RemoteConfiguration/RemoteConfiguration-2005.vcproj (deleted)
• RemoteConfiguration/RemoteConfiguration-2008.vcproj (deleted)
• SysTray/Jamfile (deleted)
• SysTray/SysTray-2005.vcproj (deleted)
• SysTray/SysTray-2008.vcproj (deleted)

trunk/modules/CheckDisk/CheckDisk.cpp

@@ -26 +26 @@
 #include <error.hpp>
 #include <file_helpers.hpp>
+#include <checkHelpers.hpp>
 
 CheckDisk gCheckDisk;
@@ -40 +41 @@
 }
 
+bool is_directory(DWORD dwAttr) {
+  return ((dwAttr != INVALID_FILE_ATTRIBUTES) && ((dwAttr&FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY));
+}
+
 bool CheckDisk::loadModule(NSCAPI::moduleLoadMode mode) {
+
   try {
     NSCModuleHelper::registerCommand(_T("CheckFileSize"), _T("Check or directory a file and verify its size."));
@@ -68 +74 @@
   virtual void report_warning(std::wstring error) = 0;
 };
+
 
 
@@ -141 +148 @@
       if (file_helpers::checks::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));
@@ -164 +171 @@
   bool bFilterFixed = false;
   bool bFilterCDROM = false;
-  bool bCheckAll = false;
+  bool bFilterNoRootDir = false;
+  bool bCheckAllDrives = false;
   bool bCheckAllOthers = false;
   bool bNSClient = false;
   bool bPerfData = true;
   std::list<DriveContainer> drives;
+  std::wstring strCheckAll;
 
   MAP_OPTIONS_BEGIN(args)
@@ -178 +187 @@
     MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterRemovable, _T("REMOVABLE"))
     MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterRemote, _T("REMOTE"))
+    MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterNoRootDir, _T("NO_ROOT_DIR"))
     MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
     MAP_OPTIONS_BOOL_TRUE(NSCLIENT, bNSClient)
-    MAP_OPTIONS_BOOL_TRUE(CHECK_ALL, bCheckAll)
+    //MAP_OPTIONS_BOOL_TRUE(CHECK_ALL, bCheckAll)
+    MAP_OPTIONS_STR(CHECK_ALL, strCheckAll)
     MAP_OPTIONS_BOOL_TRUE(CHECK_ALL_OTHERS, bCheckAllOthers)
     MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2)
@@ -194 +205 @@
   bFilter = bFilterFixed || bFilterCDROM  || bFilterRemote || bFilterRemovable;
 
-  if (drives.size() == 0)
-    bCheckAll = true;
-
-  if (bCheckAll) {
+  if ((drives.size() == 0) && strCheckAll.empty())
+    bCheckAllDrives = true;
+
+  if (strCheckAll == _T("volumes")) {
+
+    DWORD bufSize = GetLogicalDriveStrings(0, NULL)+5;
+    TCHAR *buffer = new TCHAR[bufSize+10];
+    if (GetLogicalDriveStrings(bufSize, buffer)>0) {
+      while (buffer[0] != 0) {
+        std::wstring drv = buffer;
+
+        UINT drvType = GetDriveType(drv.c_str());
+        if ( 
+          ((!bFilter)&&(drvType == DRIVE_FIXED))  ||
+          ((bFilter)&&(bFilterFixed)&&(drvType==DRIVE_FIXED)) ||
+          ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) ||
+          ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) ||
+          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) ||
+          ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR)) 
+          )
+          drives.push_back(DriveContainer(drv, tmpObject.warn, tmpObject.crit));
+
+        buffer = &buffer[drv.size()];
+        buffer++;
+      }
+    } else {
+      NSC_LOG_ERROR_STD(_T("Failed to get buffer size: ") + error::lookup::last_error());
+    }
+  }
+
+  if (bCheckAllDrives) {
     DWORD dwDrives = GetLogicalDrives();
     int idx = 0;
@@ -209 +247 @@
           ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) ||
           ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) ||
-          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) )
+          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) ||
+          ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR)) 
+          )
           drives.push_back(DriveContainer(drv, tmpObject.warn, tmpObject.crit));
       }
@@ -229 +269 @@
           ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) ||
           ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) ||
-          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) )  
+          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) ||
+          ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR)) 
+          )  
         {
           bool bFound = false;
@@ -258 +300 @@
       message = _T("UNKNOWN: Drive is not a fixed drive: ") + drive.getAlias() + _T(" (it is a ") + get_filter(drvType) + _T(" drive)");
       return NSCAPI::returnUNKNOWN;
-    } else if ( (bFilter)&&( (!bFilterFixed)&&((drvType==DRIVE_FIXED)||(drvType==DRIVE_NO_ROOT_DIR))) ||
+    } else if ( (bFilter)&&
+      (
+      ((!bFilterFixed)&&((drvType==DRIVE_FIXED)||(drvType==DRIVE_NO_ROOT_DIR))) ||
       ((!bFilterCDROM)&&(drvType==DRIVE_CDROM)) ||
       ((!bFilterRemote)&&(drvType==DRIVE_REMOTE)) ||
-      ((!bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) ) {
-        message = _T("UNKNOWN: Drive does not match the current filter: ") + drive.getAlias() + _T(" (it is a ") + get_filter(drvType) + _T(" drive)");
+      ((!bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) 
+      )) {
+        message = _T("UNKNOWN: Drive does not match the current filter: ") + drive.getAlias() + _T(" (add FilterType=") + get_filter(drvType) + _T(" to check this drive)");
         return NSCAPI::returnUNKNOWN;
     }
@@ -270 +315 @@
     ULARGE_INTEGER totalNumberOfFreeBytes;
     if (!GetDiskFreeSpaceEx(drive.data.c_str(), &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes)) {
-      message = _T("UNKNOWN: Could not get free space for: ") + drive.getAlias() + _T(" ") + drive.data + _T(" reason: ") + error::lookup::last_error();
-      return NSCAPI::returnUNKNOWN;
+      message = _T("CRITICAL: Could not get free space for: ") + drive.getAlias() + _T(" ") + drive.data + _T(" reason: ") + error::lookup::last_error();
+      return NSCAPI::returnCRIT;
     }
 
@@ -298 +343 @@
 std::wstring CheckDisk::get_filter(unsigned int drvType) {
   if (drvType==DRIVE_FIXED)
-    return _T("fixed");
+    return _T("FIXED");
   if (drvType==DRIVE_NO_ROOT_DIR)
-    return _T("no_root");
+    return _T("NO_ROOT_DIR");
   if (drvType==DRIVE_CDROM)
-    return _T("cdrom");
+    return _T("CDROM");
   if (drvType==DRIVE_REMOTE)
-    return _T("remote");
+    return _T("REMOTE");
   if (drvType==DRIVE_REMOVABLE)
-    return _T("removable");
+    return _T("REMOVABLE");
   return _T("unknown: ") + strEx::itos(drvType);
 }
@@ -351 +396 @@
   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args);
   bool bPerfData = true;
+  bool debug = false;
   if (args.empty()) {
     message = _T("Missing argument(s).");
@@ -365 +411 @@
     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)
@@ -384 +431 @@
     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");
@@ -404 +451 @@
 
 struct file_info {
-  file_info() : ullCreationTime(0) {}
-  file_info(const BY_HANDLE_FILE_INFORMATION info, std::wstring filename_) : filename(filename_), ullCreationTime(0) {
+
+  std::wstring error;
+  bool has_error;
+
+  static file_info get(std::wstring path, std::wstring file) {
+    return get_2(path, file);
+  }
+  static file_info get(file_finder_data data) {
+    return file_info(data.wfd, data.path, data.wfd.cFileName);
+  }
+
+  static file_info get_2(std::wstring path, std::wstring file) {
+    WIN32_FILE_ATTRIBUTE_DATA data;
+    if (!GetFileAttributesEx((path + _T("\\") + file).c_str(), GetFileExInfoStandard, reinterpret_cast<LPVOID>(&data))) {
+      file_info ret;
+      ret.error = _T("Could not open file (2) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error();
+      return ret;
+    }
+    return file_info(data, path, file);
+  }
+  static file_info get_1(std::wstring path, std::wstring file) {
+    HANDLE hFile = CreateFile((path + _T("\\") + file).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+    if (hFile == INVALID_HANDLE_VALUE) {
+      file_info ret;
+      ret.error = _T("Could not open file (1) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error();
+      return ret;
+    }
+    BY_HANDLE_FILE_INFORMATION _info;
+    GetFileInformationByHandle(hFile, &_info);
+    CloseHandle(hFile);
+    return file_info(_info, path, file);
+  }
+
+  file_info() 
+    : ullCreationTime(0)
+    , ullLastAccessTime(0)
+    , ullLastWriteTime(0)
+    , ullSize(0)
+    , cached_version(false, _T("")) 
+    , cached_count(false, 0)
+  {}
+  file_info(const WIN32_FILE_ATTRIBUTE_DATA 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)
+  {
     ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow);
     ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime);
@@ -411 +507 @@
     ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime);
   };
+  file_info(const BY_HANDLE_FILE_INFORMATION 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)
+  {
+    ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow);
+    ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime);
+    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(const WIN32_FIND_DATA 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)
+  {
+    ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow);
+    ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime);
+    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)
+  {
+  };
 
   unsigned long long ullSize;
-  unsigned long long ullCreationTime;
-  unsigned long long ullLastAccessTime;
-  unsigned long long ullLastWriteTime;
-  unsigned long long ullNow;
+  __int64 ullCreationTime;
+  __int64 ullLastAccessTime;
+  __int64 ullLastWriteTime;
+  __int64 ullNow;
   std::wstring filename;
-
+  std::wstring path;
+  std::pair<bool,std::wstring> cached_version;
+  std::pair<bool,unsigned long> cached_count;
+
+  static const __int64 MSECS_TO_100NS = 10000;
+
+  __int64 get_creation() {
+    return (ullNow-ullCreationTime)/MSECS_TO_100NS;
+  }
+  __int64 get_access() {
+    return (ullNow-ullLastAccessTime)/MSECS_TO_100NS;
+  }
+  __int64 get_write() {
+    return (ullNow-ullLastWriteTime)/MSECS_TO_100NS;
+  }
   std::wstring render(std::wstring syntax) {
+    strEx::replace(syntax, _T("%path%"), path);
     strEx::replace(syntax, _T("%filename%"), filename);
     strEx::replace(syntax, _T("%creation%"), strEx::format_filetime(ullCreationTime, DATE_FORMAT));
     strEx::replace(syntax, _T("%access%"), strEx::format_filetime(ullLastAccessTime, DATE_FORMAT));
     strEx::replace(syntax, _T("%write%"), strEx::format_filetime(ullLastWriteTime, DATE_FORMAT));
+/*
+    strEx::replace(syntax, _T("%creation-d%"), strEx::format_filetime(ullCreationTime, DATE_FORMAT));
+    strEx::replace(syntax, _T("%access-d%"), strEx::format_filetime(ullLastAccessTime, DATE_FORMAT));
+    strEx::replace(syntax, _T("%write-d%"), strEx::format_filetime(ullLastWriteTime, DATE_FORMAT));
+*/
     strEx::replace(syntax, _T("%size%"), strEx::itos_as_BKMG(ullSize));
+    if (cached_version.first)
+      strEx::replace(syntax, _T("%version%"), cached_version.second);
+    if (cached_count.first)
+      strEx::replace(syntax, _T("%line-count%"), strEx::itos(cached_count.second));
     return syntax;
   }
 
+  std::wstring get_version() {
+    if (cached_version.first)
+      return cached_version.second;
+    std::wstring fullpath = path+_T("\\")+filename;
+
+    DWORD dwDummy;
+    DWORD dwFVISize = GetFileVersionInfoSize(fullpath.c_str(),&dwDummy);
+    LPBYTE lpVersionInfo = new BYTE[dwFVISize+1];
+    GetFileVersionInfo(fullpath.c_str(),0,dwFVISize,lpVersionInfo);
+    UINT uLen;
+    VS_FIXEDFILEINFO *lpFfi;
+    VerQueryValue( lpVersionInfo , _T("\\") , (LPVOID *)&lpFfi , &uLen );
+    DWORD dwFileVersionMS = lpFfi->dwFileVersionMS;
+    DWORD dwFileVersionLS = lpFfi->dwFileVersionLS;
+    delete [] lpVersionInfo;
+    DWORD dwLeftMost = HIWORD(dwFileVersionMS);
+    DWORD dwSecondLeft = LOWORD(dwFileVersionMS);
+    DWORD dwSecondRight = HIWORD(dwFileVersionLS);
+    DWORD dwRightMost = LOWORD(dwFileVersionLS);
+    cached_version.second = strEx::itos(dwLeftMost) + _T(".") +
+      strEx::itos(dwSecondLeft) + _T(".") +
+      strEx::itos(dwSecondRight) + _T(".") +
+      strEx::itos(dwRightMost);
+    cached_version.first = true;
+    return cached_version.second;
+  }
+
+  unsigned long get_line_count() {
+    if (cached_count.first)
+      return cached_count.second;
+
+    unsigned long count = 0;
+    std::wstring fullpath = path+_T("\\")+filename;
+    FILE * pFile = fopen(strEx::wstring_to_string(fullpath).c_str(),"r");;
+    if (pFile==NULL) 
+      return 0;
+    char c;
+    do {
+      c = fgetc (pFile);
+      if (c == '\r') {
+        c = fgetc (pFile);
+        count++;
+      } else if (c == '\n') {
+        c = fgetc (pFile);
+        count++;
+      }
+    } while (c != EOF);
+    fclose (pFile);
+    cached_count.second = count;
+    cached_count.first = true;
+    return cached_count.second;
+  }
 };
 
@@ -435 +648 @@
   filters::filter_all_times accessed;
   filters::filter_all_times written;
-  static const __int64 MSECS_TO_100NS = 10000;
+  filters::filter_all_strings version;
+  filters::filter_all_num_ul line_count;
 
   inline bool hasFilter() {
@@ -441 +655 @@
       accessed.hasFilter() || written.hasFilter();
   }
-  bool matchFilter(const file_info &value) const {
+  bool matchFilter(file_info &value) const {
     if ((size.hasFilter())&&(size.matchFilter(value.ullSize)))
       return true;
-    else if ((creation.hasFilter())&&(creation.matchFilter((value.ullNow-value.ullCreationTime)/MSECS_TO_100NS)))
+    else if (creation.hasFilter()&&creation.matchFilter(value.get_creation()))
       return true;
-    else if ((accessed.hasFilter())&&(accessed.matchFilter((value.ullNow-value.ullLastAccessTime)/MSECS_TO_100NS)))
+    else if (accessed.hasFilter()&&accessed.matchFilter(value.get_access()))
       return true;
-    else if ((written.hasFilter())&&(written.matchFilter((value.ullNow-value.ullLastWriteTime)/MSECS_TO_100NS)))
+    else if (written.hasFilter()&&written.matchFilter(value.get_write()))
+      return true;
+    else if ((version.hasFilter())&&(version.matchFilter(value.get_version())))
+      return true;
+    else if ((line_count.hasFilter())&&(line_count.matchFilter(value.get_line_count())))
       return true;
     return false;
@@ -462 +680 @@
     if (written.hasFilter())
       return _T("written: ") + written.getValue();
+    if (version.hasFilter())
+      return _T("written: ") + version.getValue();
+    if (line_count.hasFilter())
+      return _T("written: ") + line_count.getValue();
     return _T("UNknown...");
   }
@@ -477 +699 @@
     if (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes))
       return true;
+
+    file_info info = file_info::get(ffd);
+    if (!info.error.empty()) {
+      setError(ffd.errors, info.error);
+      return false;
+    }
+    return false;
+    /*
     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,
+    HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
     if (hFile == INVALID_HANDLE_VALUE) {
@@ -487 +717 @@
     GetFileInformationByHandle(hFile, &_info);
     CloseHandle(hFile);
-    info = file_info(_info, ffd.wfd.cFileName);
+    info = file_info(_info, ffd.path, ffd.wfd.cFileName);
     return false;
+    */
   }
   inline const bool hasError() const {
@@ -516 +747 @@
     if (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes))
       return true;
+
+    file_info info = file_info::get(ffd);
+    if (!info.error.empty()) {
+      setError(ffd.errors, info.error);
+      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,
+    HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
     if (hFile == INVALID_HANDLE_VALUE) {
@@ -526 +764 @@
     GetFileInformationByHandle(hFile, &_info);
     CloseHandle(hFile);
-    file_info info(_info, ffd.wfd.cFileName);
+    file_info info(_info, ffd.path, ffd.wfd.cFileName);
     info.ullNow = now;
+    */
 
     for (std::list<file_filter>::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) {
@@ -581 +820 @@
   std::wstring message;
   std::wstring syntax;
-  std::wstring alias;
+  //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) {}
+  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 (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes))
+    if (is_directory(ffd.wfd.dwFileAttributes))
       return true;
+
+    file_info info = file_info::get(ffd);
+    if (!info.error.empty()) {
+      setError(ffd.errors, info.error);
+      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,
+    HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
     if (hFile == INVALID_HANDLE_VALUE) {
@@ -599 +848 @@
     GetFileInformationByHandle(hFile, &_info);
     CloseHandle(hFile);
-    file_info info(_info, ffd.wfd.cFileName);
+    file_info info(_info, ffd.path, ffd.wfd.cFileName);
     info.ullNow = now;
+    */
 
     bool bMatch = !bFilterIn;
@@ -609 +859 @@
       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;
@@ -615 +865 @@
       } 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;
@@ -626 +876 @@
     }
 
-    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));
+      /*
       if (alias.length() < 16)
         strEx::append_list(alias, info.filename);
       else
         strEx::append_list(alias, std::wstring(_T("...")));
+        */
       hit_count++;
     }
+    file_count++;
     return true;
   }
@@ -643 +896 @@
     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;
+  }
+
+  bool has_filter() {
+    return !filter_chain.empty();
+  }
+
 };
+
 
 NSCAPI::nagiosReturn CheckDisk::getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) {
@@ -657 +925 @@
   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()
@@ -671 +941 @@
   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)");
@@ -702 +972 @@
   bool bPerfData = true;
   unsigned int max_dir_depth = -1;
+  bool debug = false;
 
   try {
@@ -713 +984 @@
       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"))
@@ -735 +1007 @@
   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.");
@@ -758 +1030 @@
 }
 
-#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)); }
+#define MAP_FILTER(value, obj) \
+    else if (p__.first == _T("filter+"##value)) { file_filter filter; filter.obj = p__.second; \
+      finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_plus, filter)); } \
+    else if (p__.first == _T("filter-"##value)) { file_filter filter; filter.obj = p__.second; \
+      finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_minus, filter)); } \
+    else if (p__.first == _T("filter."##value)) { file_filter filter; filter.obj = p__.second; \
+      finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_normal, filter)); }
 
 NSCAPI::nagiosReturn CheckDisk::CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) {
@@ -777 +1054 @@
   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 {
@@ -788 +1068 @@
       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"))
@@ -802 +1085 @@
       */
 
-      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("size"), size)
+      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_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.version"), version, filter_normal)
 
       MAP_FILTER(_T("filter-size"), size, filter_minus)
@@ -816 +1102 @@
       MAP_FILTER(_T("filter-written"), written, filter_minus)
       MAP_FILTER(_T("filter-accessed"), accessed, filter_minus)
-
+      MAP_FILTER(_T("filter-version"), version, filter_minus)
+*/
       MAP_OPTIONS_MISSING(message, _T("Unknown argument: "))
       MAP_OPTIONS_END()
@@ -825 +1112 @@
     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;
-    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.");
-        return NSCAPI::returnUNKNOWN;
-      }
-    }
-    message = finder.message;
-    if (!alias.empty())
-      query.alias = alias;
+  }
+  if (paths.empty()) {
+    message = _T("Missing path argument");
+    return NSCAPI::returnUNKNOWN;
+  }
+  if (!finder.has_filter()) {
+    message = _T("Missing filter argument");
+    return NSCAPI::returnUNKNOWN;
+  }
+  FILETIME now;
+  GetSystemTimeAsFileTime(&now);
+  finder.debug_ = debug;
+  finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime);
+  if (debug)
+    NSC_DEBUG_MSG_STD(_T("NOW: ") + strEx::format_filetime(finder.now));
+  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, 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.render(masterSyntax);
+  if (!alias.empty())
+    query.alias = alias;
+  else
+    query.alias = _T("found files");
+  query.runCheck(finder.hit_count, returnCode, message, perf);
+  if ((truncate > 0) && (message.length() > (truncate-4))) {
+    message = message.substr(0, truncate-4) + _T("...");
+    //perf = _T("");
+  }
+  if (message.empty())
+    message = _T("CheckFile ok");
+  return returnCode;
+}
+struct file_container : public file_info {
+  std::wstring error_;
+
+  static file_container get(std::wstring file, unsigned long long now) {
+
+    BY_HANDLE_FILE_INFORMATION _info;
+
+    HANDLE hFile = CreateFile(file.c_str(), FILE_READ_ATTRIBUTES, 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;
+  }
+
+
+  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
-      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;
-}
-
+      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);
+  }
+};
+
+#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 = file_container::get(*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")) {
@@ -862 +1323 @@
   } 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);

trunk/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:

trunk/modules/CheckEventLog/CheckEventLog.cpp

@@ -57 +57 @@
     syntax_ = SETTINGS_GET_STRING(event_log::SYNTAX);
     buffer_length_ = SETTINGS_GET_INT(event_log::BUFFER_SIZE);
+    buffer_length_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_BUFFER, EVENTLOG_BUFFER_DEFAULT);
   } catch (NSCModuleHelper::NSCMHExcpetion &e) {
     NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_);
@@ -228 +229 @@
     return pevlr_->EventType;
   }
-/*
+
   std::wstring userSID() const {
     if (pevlr_->UserSidOffset == 0)
-      return "";
+      return _T("");
     PSID p = reinterpret_cast<PSID>(reinterpret_cast<LPBYTE>(pevlr_) + + pevlr_->UserSidOffset);
-    LPSTR user = new CHAR[1025];
-    LPSTR domain = new CHAR[1025];
-    DWORD userLen = 1024;
-    DWORD domainLen = 1024;
+    DWORD userLen = 0;
+    DWORD domainLen = 0;
     SID_NAME_USE sidName;
+
+    LookupAccountSid(NULL, p, NULL, &userLen, NULL, &domainLen, &sidName);
+    LPTSTR user = new TCHAR[userLen+10];
+    LPTSTR domain = new TCHAR[domainLen+10];
+
     LookupAccountSid(NULL, p, user, &userLen, domain, &domainLen, &sidName);
     user[userLen] = 0;
     domain[domainLen] = 0;
-    return std::wstring(domain) + "\\" + std::wstring(user);
-  }
-  */
+    std::wstring ustr = user;
+    std::wstring dstr = domain;
+    delete [] user;
+    delete [] domain;
+    if (!dstr.empty())
+      dstr = dstr + _T("\\");
+    if (ustr.empty() && dstr.empty())
+      return _T("missing");
+
+    return dstr + ustr;
+  }
 
   std::wstring enumStrings() const {
@@ -405 +417 @@
     strEx::replace(syntax, _T("%strings%"), enumStrings());
     strEx::replace(syntax, _T("%id%"), strEx::itos(eventID()));
+    strEx::replace(syntax, _T("%user%"), userSID());
     return syntax;
   }

trunk/modules/CheckExternalScripts/CheckExternalScripts.cpp

@@ -27 +27 @@
 #include <config.h>
 #include <strEx.h>
+#include <file_helpers.hpp>
 #include <file_helpers.hpp>
 

trunk/modules/CheckHelpers/CheckHelpers.cpp

@@ -26 +26 @@
 
 CheckHelpers gCheckHelpers;
-#ifdef _WIN32
-BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
-{
-  NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
-  return TRUE;
-}
-#endif
 
 CheckHelpers::CheckHelpers() {
@@ -93 +86 @@
     NSCModuleHelper::InjectSimpleCommand(new_command, arguments, message, perf);
     return NSCAPI::returnOK;
+  } else if (command == _T("CheckVersion")) {
+    message = NSCModuleHelper::getApplicationVersionString();
+    return NSCAPI::returnOK;
+  } else if (command == _T("CheckOK")) {
+    return checkSimpleStatus(NSCAPI::returnOK, arguments, message, perf);
+  } else if (command == _T("CheckWARNING")) {
+    return checkSimpleStatus(NSCAPI::returnWARN, arguments, message, perf);
+  } else if (command == _T("CheckCRITICAL")) {
+    return checkSimpleStatus(NSCAPI::returnCRIT, arguments, message, perf);
   } else if (command == _T("CheckAlwaysCRITICAL")) {
     if (arguments.size() < 1) {
@@ -162 +164 @@
 
 
+NSC_WRAP_DLL();
 NSC_WRAPPERS_MAIN_DEF(gCheckHelpers);
 NSC_WRAPPERS_IGNORE_MSG_DEF();

trunk/modules/CheckHelpers/CheckHelpers.h

@@ -52 +52 @@
   NSCAPI::nagiosReturn checkMultiple(const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf);
   NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf);
+  NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf);
 };

trunk/modules/CheckSystem/CheckSystem.cpp

@@ -135 +135 @@
             std::wstring error;
             bool bStatus = true;
-            if (PDH::Enumerations::validate(counter, error)) {
+            if (PDH::PDHResolver::validate(counter, error, false)) {
               status.push_back(_T("open"));
             } else {
@@ -212 +212 @@
           std::wcout << _T("testing: ") << counter << _T(": ");
           std::wstring error;
-          if (PDH::Enumerations::validate(counter, error)) {
+          if (PDH::PDHResolver::validate(counter, error, false)) {
             std::wcout << _T(" found ");
           } else {
@@ -1030 +1030 @@
   unsigned int averageDelay = 1000;
   CounterContainer tmpObject;
+  bool bExpandIndex = false;
+  bool bForceReload = false;
 
   MAP_OPTIONS_BEGIN(stl_args)
@@ -1043 +1045 @@
     MAP_OPTIONS_BOOL_EX(_T("Averages"), bCheckAverages, _T("true"), _T("false"))
     MAP_OPTIONS_BOOL_TRUE(NSCLIENT, bNSClient)
+    MAP_OPTIONS_BOOL_TRUE(_T("index"), bExpandIndex)
+    MAP_OPTIONS_BOOL_TRUE(_T("reload"), bForceReload)
     MAP_OPTIONS_FIRST_CHAR('\\', tmpObject.data, counters.push_back(tmpObject))
     MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2)
@@ -1054 +1058 @@
     MAP_OPTIONS_FALLBACK_AND(tmpObject.data, counters.push_back(tmpObject))
   MAP_OPTIONS_END()
+
+  if (counters.empty()) {
+    msg = _T("No counters specified");
+    return NSCAPI::returnUNKNOWN;
+  }
+
   for (std::list<CounterContainer>::const_iterator cit = counters.begin(); cit != counters.end(); ++cit) {
     CounterContainer counter = (*cit);
     try {
       std::wstring tstr;
-      if (!PDH::Enumerations::validate(counter.data, tstr)) {
+      if (bExpandIndex) {
+        PDH::PDHResolver::expand_index(counter.data);
+      }
+      if (!PDH::PDHResolver::validate(counter.data, tstr, bForceReload)) {
         NSC_LOG_ERROR_STD(_T("ERROR: Counter not found: ") + counter.data + _T(": ") + tstr);
         if (bNSClient) {
@@ -1064 +1077 @@
           //msg = _T("0");
         } else {
-          //msg = tstr;
-          //msg += _T(" (") + counter.getAlias() + _T("|") + counter.data + _T(")");
+          msg = _T("CRIT: Counter not found: ") + counter.data + _T(": ") + tstr;
+          return NSCAPI::returnCRIT;
         }
-        //return NSCHelper::translateReturn(invalidStatus);
       }
       PDH::PDHQuery pdh;

trunk/modules/CheckSystem/CheckSystem.h

@@ -21 +21 @@
 #pragma once
 
+#include <pdh.hpp>
 #include "PDHCollector.h"
 #include <CheckMemory.h>

trunk/modules/CheckSystem/PDHCollector.cpp

@@ -30 +30 @@
   unsigned int i = strEx::stoui_as_time(s, checkIntervall_*100);
   cpu.resize(i/(checkIntervall_*100)+10);
+  std::wstring subsystem = NSCModuleHelper::getSettingsString(C_SYSTEM_SECTION_TITLE, C_SYSTEM_PDH_SUBSYSTEM, C_SYSTEM_PDH_SUBSYSTEM_DEFAULT);
+  if (subsystem == C_SYSTEM_PDH_SUBSYSTEM_DEFAULT) {
+  } else if (subsystem == _T("thread-safe")) {
+    PDH::PDHFactory::set_threadSafe();
+  } else {
+    NSC_LOG_ERROR_STD(_T("Unknown PDH subsystem (") + subsystem + _T(") valid values are: fast and thread-safe"));
+  }
 }
 
@@ -103 +110 @@
     if (bUseIndex) {
       NSC_DEBUG_MSG_STD(_T("Using index to retrive counternames"));
-      proc = _T("\\") + pdh.lookupIndex(238) + _T("(_total)\\") + pdh.lookupIndex(6);
-      uptime = _T("\\") + pdh.lookupIndex(2) + _T("\\") + pdh.lookupIndex(674);
-      memCl = _T("\\") + pdh.lookupIndex(4) + _T("\\") + pdh.lookupIndex(30);
-      memCb = _T("\\") + pdh.lookupIndex(4) + _T("\\") + pdh.lookupIndex(26);
+      proc = _T("\\") + PDH::PDHResolver::lookupIndex(238) + _T("(_total)\\") + PDH::PDHResolver::lookupIndex(6);
+      uptime = _T("\\") + PDH::PDHResolver::lookupIndex(2) + _T("\\") + PDH::PDHResolver::lookupIndex(674);
+      memCl = _T("\\") + PDH::PDHResolver::lookupIndex(4) + _T("\\") + PDH::PDHResolver::lookupIndex(30);
+      memCb = _T("\\") + PDH::PDHResolver::lookupIndex(4) + _T("\\") + PDH::PDHResolver::lookupIndex(26);
     } else {
-      //settings_core settings;
-      NSC_LOG_ERROR_STD(_T("REPORT THIS: counters.defs file handling has not been (re)added!!!"));
-      return false;
-      /*
-      @TODO: FIXME
-      SettingsT settings;
+      settings_core settings;
       settings.setFile(NSCModuleHelper::getBasePath(),  _T("counters.defs"), true);
       NSC_DEBUG_MSG_STD(_T("Detected language: ") + settings.getString(section, _T("Description"), _T("Not found")) + _T(" (") + section + _T(")"));

trunk/modules/CheckSystem/PDHCollector.h

@@ -21 +21 @@
 #pragma once
 
-#include "PDHCollectors.h"
+#include <pdh.hpp>
 #include <thread.h>
 #include <MutexRW.h>

trunk/modules/NRPEClient/NRPEClient.cpp

@@ -28 +28 @@
 #include <strEx.h>
 #include <boost/filesystem.hpp>
+#include <strEx.h>
 
 
 NRPEClient gNRPEClient;
-
-#ifdef _WIN32
-BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
-{
-  NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
-  return TRUE;
-}
-#endif
 
 NRPEClient::NRPEClient() : buffer_length_(0) {
@@ -94 +87 @@
 
 void NRPEClient::addCommand(strEx::blindstr key, std::wstring args) {
+#ifndef USE_BOOST
+  NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str() + _T(" boost not avalible!"));
+#else
   try {
 
@@ -130 +126 @@
     NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str());
   }
+#endif
 }
 
@@ -442 +439 @@
 
 
+NSC_WRAP_DLL();
 NSC_WRAPPERS_MAIN_DEF(gNRPEClient);
 NSC_WRAPPERS_IGNORE_MSG_DEF();

trunk/modules/NRPEClient/NRPEClient.h

@@ -127 +127 @@
   nrpe::packet send_ssl(std::wstring host, int port, int timeout, nrpe::packet packet);
   void add_options(po::options_description &desc, nrpe_connection_data &command_data);
-
+#ifdef USE_BOOST
+#endif
 
 private:

trunk/modules/NRPEServer/NRPEServer.cpp

@@ -27 +27 @@
 
 NRPEListener gNRPEListener;
-
-#ifdef _WIN32
-BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
-{
-  NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
-  return TRUE;
-}
-#endif
 
 NRPEListener::NRPEListener() : noPerfData_(false), buffer_length_(0) {
@@ -308 +300 @@
 // }
 
+NSC_WRAP_DLL();
 NSC_WRAPPERS_MAIN_DEF(gNRPEListener);
 NSC_WRAPPERS_IGNORE_MSG_DEF();