Changeset b4110d8 in nscp


Ignore:
Timestamp:
02/05/10 09:40:25 (3 years ago)
Author:
Michael Medin <michael@…>
Branches:
master, 0.4.0, 0.4.1, 0.4.2
Children:
61008dc
Parents:
65e933e
Message:

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

Location:
modules
Files:
47 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • modules/CheckDisk/CheckDisk.cpp

    r7f9c823 rb4110d8  
    2626#include <error.hpp> 
    2727#include <file_helpers.hpp> 
     28#include <checkHelpers.hpp> 
    2829 
    2930CheckDisk gCheckDisk; 
    … …  
    4041} 
    4142 
     43bool is_directory(DWORD dwAttr) { 
     44  return ((dwAttr != INVALID_FILE_ATTRIBUTES) && ((dwAttr&FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)); 
     45} 
     46 
    4247bool CheckDisk::loadModule(NSCAPI::moduleLoadMode mode) { 
     48 
    4349  try { 
    4450    NSCModuleHelper::registerCommand(_T("CheckFileSize"), _T("Check or directory a file and verify its size.")); 
    … …  
    6874  virtual void report_warning(std::wstring error) = 0; 
    6975}; 
     76 
    7077 
    7178 
    … …  
    141148      if (file_helpers::checks::is_directory(wfd.dwFileAttributes)) { 
    142149        if ( (wcscmp(wfd.cFileName, _T(".")) != 0) && (wcscmp(wfd.cFileName, _T("..")) != 0) ) 
    143           recursive_scan<finder_function>(dir + _T("\\") + wfd.cFileName, pattern, current_level+1, max_level, f, errors); 
     150          recursive_scan<finder_function>(dir + _T("\\") + wfd.cFileName, pattern, current_level+1, max_level, f, errors, debug); 
    144151      } 
    145152    } while (FindNextFile(hFind, &wfd)); 
    … …  
    164171  bool bFilterFixed = false; 
    165172  bool bFilterCDROM = false; 
    166   bool bCheckAll = false; 
     173  bool bFilterNoRootDir = false; 
     174  bool bCheckAllDrives = false; 
    167175  bool bCheckAllOthers = false; 
    168176  bool bNSClient = false; 
    169177  bool bPerfData = true; 
    170178  std::list<DriveContainer> drives; 
     179  std::wstring strCheckAll; 
    171180 
    172181  MAP_OPTIONS_BEGIN(args) 
    … …  
    178187    MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterRemovable, _T("REMOVABLE")) 
    179188    MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterRemote, _T("REMOTE")) 
     189    MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterNoRootDir, _T("NO_ROOT_DIR")) 
    180190    MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    181191    MAP_OPTIONS_BOOL_TRUE(NSCLIENT, bNSClient) 
    182     MAP_OPTIONS_BOOL_TRUE(CHECK_ALL, bCheckAll) 
     192    //MAP_OPTIONS_BOOL_TRUE(CHECK_ALL, bCheckAll) 
     193    MAP_OPTIONS_STR(CHECK_ALL, strCheckAll) 
    183194    MAP_OPTIONS_BOOL_TRUE(CHECK_ALL_OTHERS, bCheckAllOthers) 
    184195    MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2) 
    … …  
    194205  bFilter = bFilterFixed || bFilterCDROM  || bFilterRemote || bFilterRemovable; 
    195206 
    196   if (drives.size() == 0) 
    197     bCheckAll = true; 
    198  
    199   if (bCheckAll) { 
     207  if ((drives.size() == 0) && strCheckAll.empty()) 
     208    bCheckAllDrives = true; 
     209 
     210  if (strCheckAll == _T("volumes")) { 
     211 
     212    DWORD bufSize = GetLogicalDriveStrings(0, NULL)+5; 
     213    TCHAR *buffer = new TCHAR[bufSize+10]; 
     214    if (GetLogicalDriveStrings(bufSize, buffer)>0) { 
     215      while (buffer[0] != 0) { 
     216        std::wstring drv = buffer; 
     217 
     218        UINT drvType = GetDriveType(drv.c_str()); 
     219        if (  
     220          ((!bFilter)&&(drvType == DRIVE_FIXED))  || 
     221          ((bFilter)&&(bFilterFixed)&&(drvType==DRIVE_FIXED)) || 
     222          ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
     223          ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
     224          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) || 
     225          ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR))  
     226          ) 
     227          drives.push_back(DriveContainer(drv, tmpObject.warn, tmpObject.crit)); 
     228 
     229        buffer = &buffer[drv.size()]; 
     230        buffer++; 
     231      } 
     232    } else { 
     233      NSC_LOG_ERROR_STD(_T("Failed to get buffer size: ") + error::lookup::last_error()); 
     234    } 
     235  } 
     236 
     237  if (bCheckAllDrives) { 
    200238    DWORD dwDrives = GetLogicalDrives(); 
    201239    int idx = 0; 
    … …  
    209247          ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
    210248          ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
    211           ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) ) 
     249          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) || 
     250          ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR))  
     251          ) 
    212252          drives.push_back(DriveContainer(drv, tmpObject.warn, tmpObject.crit)); 
    213253      } 
    … …  
    229269          ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
    230270          ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
    231           ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) )   
     271          ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) || 
     272          ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR))  
     273          )   
    232274        { 
    233275          bool bFound = false; 
    … …  
    258300      message = _T("UNKNOWN: Drive is not a fixed drive: ") + drive.getAlias() + _T(" (it is a ") + get_filter(drvType) + _T(" drive)"); 
    259301      return NSCAPI::returnUNKNOWN; 
    260     } else if ( (bFilter)&&( (!bFilterFixed)&&((drvType==DRIVE_FIXED)||(drvType==DRIVE_NO_ROOT_DIR))) || 
     302    } else if ( (bFilter)&& 
     303      ( 
     304      ((!bFilterFixed)&&((drvType==DRIVE_FIXED)||(drvType==DRIVE_NO_ROOT_DIR))) || 
    261305      ((!bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
    262306      ((!bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
    263       ((!bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) ) { 
    264         message = _T("UNKNOWN: Drive does not match the current filter: ") + drive.getAlias() + _T(" (it is a ") + get_filter(drvType) + _T(" drive)"); 
     307      ((!bFilterRemovable)&&(drvType==DRIVE_REMOVABLE))  
     308      )) { 
     309        message = _T("UNKNOWN: Drive does not match the current filter: ") + drive.getAlias() + _T(" (add FilterType=") + get_filter(drvType) + _T(" to check this drive)"); 
    265310        return NSCAPI::returnUNKNOWN; 
    266311    } 
    … …  
    270315    ULARGE_INTEGER totalNumberOfFreeBytes; 
    271316    if (!GetDiskFreeSpaceEx(drive.data.c_str(), &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes)) { 
    272       message = _T("UNKNOWN: Could not get free space for: ") + drive.getAlias() + _T(" ") + drive.data + _T(" reason: ") + error::lookup::last_error(); 
    273       return NSCAPI::returnUNKNOWN; 
     317      message = _T("CRITICAL: Could not get free space for: ") + drive.getAlias() + _T(" ") + drive.data + _T(" reason: ") + error::lookup::last_error(); 
     318      return NSCAPI::returnCRIT; 
    274319    } 
    275320 
    … …  
    298343std::wstring CheckDisk::get_filter(unsigned int drvType) { 
    299344  if (drvType==DRIVE_FIXED) 
    300     return _T("fixed"); 
     345    return _T("FIXED"); 
    301346  if (drvType==DRIVE_NO_ROOT_DIR) 
    302     return _T("no_root"); 
     347    return _T("NO_ROOT_DIR"); 
    303348  if (drvType==DRIVE_CDROM) 
    304     return _T("cdrom"); 
     349    return _T("CDROM"); 
    305350  if (drvType==DRIVE_REMOTE) 
    306     return _T("remote"); 
     351    return _T("REMOTE"); 
    307352  if (drvType==DRIVE_REMOVABLE) 
    308     return _T("removable"); 
     353    return _T("REMOVABLE"); 
    309354  return _T("unknown: ") + strEx::itos(drvType); 
    310355} 
    … …  
    351396  std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    352397  bool bPerfData = true; 
     398  bool debug = false; 
    353399  if (args.empty()) { 
    354400    message = _T("Missing argument(s)."); 
    … …  
    365411    MAP_OPTIONS_STR(_T("MaxCrit"), tmpObject.crit.max) 
    366412    MAP_OPTIONS_STR(_T("MinCrit"), tmpObject.crit.min) 
     413    MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    367414    MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    368415    MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2) 
    … …  
    384431    NSC_error errors; 
    385432    pattern_type splitpath = split_pattern(path.data); 
    386     recursive_scan<get_size>(splitpath.first, splitpath.second, -1, -1, sizeFinder, &errors); 
     433    recursive_scan<get_size>(splitpath.first, splitpath.second, -1, -1, sizeFinder, &errors, debug); 
    387434    if (sizeFinder.hasError()) { 
    388435      message = _T("File not found check log for details"); 
    … …  
    404451 
    405452struct file_info { 
    406   file_info() : ullCreationTime(0) {} 
    407   file_info(const BY_HANDLE_FILE_INFORMATION info, std::wstring filename_) : filename(filename_), ullCreationTime(0) { 
     453 
     454  std::wstring error; 
     455  bool has_error; 
     456 
     457  static file_info get(std::wstring path, std::wstring file) { 
     458    return get_2(path, file); 
     459  } 
     460  static file_info get(file_finder_data data) { 
     461    return file_info(data.wfd, data.path, data.wfd.cFileName); 
     462  } 
     463 
     464  static file_info get_2(std::wstring path, std::wstring file) { 
     465    WIN32_FILE_ATTRIBUTE_DATA data; 
     466    if (!GetFileAttributesEx((path + _T("\\") + file).c_str(), GetFileExInfoStandard, reinterpret_cast<LPVOID>(&data))) { 
     467      file_info ret; 
     468      ret.error = _T("Could not open file (2) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error(); 
     469      return ret; 
     470    } 
     471    return file_info(data, path, file); 
     472  } 
     473  static file_info get_1(std::wstring path, std::wstring file) { 
     474    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); 
     475    if (hFile == INVALID_HANDLE_VALUE) { 
     476      file_info ret; 
     477      ret.error = _T("Could not open file (1) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error(); 
     478      return ret; 
     479    } 
     480    BY_HANDLE_FILE_INFORMATION _info; 
     481    GetFileInformationByHandle(hFile, &_info); 
     482    CloseHandle(hFile); 
     483    return file_info(_info, path, file); 
     484  } 
     485 
     486  file_info()  
     487    : ullCreationTime(0) 
     488    , ullLastAccessTime(0) 
     489    , ullLastWriteTime(0) 
     490    , ullSize(0) 
     491    , cached_version(false, _T(""))  
     492    , cached_count(false, 0) 
     493  {} 
     494  file_info(const WIN32_FILE_ATTRIBUTE_DATA info, std::wstring path_, std::wstring filename_)  
     495    : path(path_) 
     496    , filename(filename_) 
     497    , ullCreationTime(0) 
     498    , ullLastAccessTime(0) 
     499    , ullLastWriteTime(0) 
     500    , ullSize(0) 
     501    , cached_version(false, _T(""))  
     502    , cached_count(false, 0) 
     503  { 
    408504    ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
    409505    ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
    … …  
    411507    ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
    412508  }; 
     509  file_info(const BY_HANDLE_FILE_INFORMATION info, std::wstring path_, std::wstring filename_)  
     510    : path(path_) 
     511    , filename(filename_) 
     512    , ullCreationTime(0) 
     513    , ullLastAccessTime(0) 
     514    , ullLastWriteTime(0) 
     515    , ullSize(0) 
     516    , cached_version(false, _T(""))  
     517    , cached_count(false, 0) 
     518  { 
     519    ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
     520    ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
     521    ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime); 
     522    ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
     523  }; 
     524  file_info(const WIN32_FIND_DATA info, std::wstring path_, std::wstring filename_)  
     525    : path(path_) 
     526    , filename(filename_) 
     527    , ullCreationTime(0) 
     528    , ullLastAccessTime(0) 
     529    , ullLastWriteTime(0) 
     530    , ullSize(0) 
     531    , cached_version(false, _T(""))  
     532    , cached_count(false, 0) 
     533  { 
     534    ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
     535    ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
     536    ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime); 
     537    ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
     538  }; 
     539  file_info(std::wstring path_, std::wstring filename_)  
     540    : path(path_) 
     541    , filename(filename_) 
     542    , ullCreationTime(0) 
     543    , ullLastAccessTime(0) 
     544    , ullLastWriteTime(0) 
     545    , ullSize(0) 
     546    , cached_version(false, _T(""))  
     547    , cached_count(false, 0) 
     548  { 
     549  }; 
    413550 
    414551  unsigned long long ullSize; 
    415   unsigned long long ullCreationTime; 
    416   unsigned long long ullLastAccessTime; 
    417   unsigned long long ullLastWriteTime; 
    418   unsigned long long ullNow; 
     552  __int64 ullCreationTime; 
     553  __int64 ullLastAccessTime; 
     554  __int64 ullLastWriteTime; 
     555  __int64 ullNow; 
    419556  std::wstring filename; 
    420  
     557  std::wstring path; 
     558  std::pair<bool,std::wstring> cached_version; 
     559  std::pair<bool,unsigned long> cached_count; 
     560 
     561  static const __int64 MSECS_TO_100NS = 10000; 
     562 
     563  __int64 get_creation() { 
     564    return (ullNow-ullCreationTime)/MSECS_TO_100NS; 
     565  } 
     566  __int64 get_access() { 
     567    return (ullNow-ullLastAccessTime)/MSECS_TO_100NS; 
     568  } 
     569  __int64 get_write() { 
     570    return (ullNow-ullLastWriteTime)/MSECS_TO_100NS; 
     571  } 
    421572  std::wstring render(std::wstring syntax) { 
     573    strEx::replace(syntax, _T("%path%"), path); 
    422574    strEx::replace(syntax, _T("%filename%"), filename); 
    423575    strEx::replace(syntax, _T("%creation%"), strEx::format_filetime(ullCreationTime, DATE_FORMAT)); 
    424576    strEx::replace(syntax, _T("%access%"), strEx::format_filetime(ullLastAccessTime, DATE_FORMAT)); 
    425577    strEx::replace(syntax, _T("%write%"), strEx::format_filetime(ullLastWriteTime, DATE_FORMAT)); 
     578/* 
     579    strEx::replace(syntax, _T("%creation-d%"), strEx::format_filetime(ullCreationTime, DATE_FORMAT)); 
     580    strEx::replace(syntax, _T("%access-d%"), strEx::format_filetime(ullLastAccessTime, DATE_FORMAT)); 
     581    strEx::replace(syntax, _T("%write-d%"), strEx::format_filetime(ullLastWriteTime, DATE_FORMAT)); 
     582*/ 
    426583    strEx::replace(syntax, _T("%size%"), strEx::itos_as_BKMG(ullSize)); 
     584    if (cached_version.first) 
     585      strEx::replace(syntax, _T("%version%"), cached_version.second); 
     586    if (cached_count.first) 
     587      strEx::replace(syntax, _T("%line-count%"), strEx::itos(cached_count.second)); 
    427588    return syntax; 
    428589  } 
    429590 
     591  std::wstring get_version() { 
     592    if (cached_version.first) 
     593      return cached_version.second; 
     594    std::wstring fullpath = path+_T("\\")+filename; 
     595 
     596    DWORD dwDummy; 
     597    DWORD dwFVISize = GetFileVersionInfoSize(fullpath.c_str(),&dwDummy); 
     598    LPBYTE lpVersionInfo = new BYTE[dwFVISize+1]; 
     599    GetFileVersionInfo(fullpath.c_str(),0,dwFVISize,lpVersionInfo); 
     600    UINT uLen; 
     601    VS_FIXEDFILEINFO *lpFfi; 
     602    VerQueryValue( lpVersionInfo , _T("\\") , (LPVOID *)&lpFfi , &uLen ); 
     603    DWORD dwFileVersionMS = lpFfi->dwFileVersionMS; 
     604    DWORD dwFileVersionLS = lpFfi->dwFileVersionLS; 
     605    delete [] lpVersionInfo; 
     606    DWORD dwLeftMost = HIWORD(dwFileVersionMS); 
     607    DWORD dwSecondLeft = LOWORD(dwFileVersionMS); 
     608    DWORD dwSecondRight = HIWORD(dwFileVersionLS); 
     609    DWORD dwRightMost = LOWORD(dwFileVersionLS); 
     610    cached_version.second = strEx::itos(dwLeftMost) + _T(".") + 
     611      strEx::itos(dwSecondLeft) + _T(".") + 
     612      strEx::itos(dwSecondRight) + _T(".") + 
     613      strEx::itos(dwRightMost); 
     614    cached_version.first = true; 
     615    return cached_version.second; 
     616  } 
     617 
     618  unsigned long get_line_count() { 
     619    if (cached_count.first) 
     620      return cached_count.second; 
     621 
     622    unsigned long count = 0; 
     623    std::wstring fullpath = path+_T("\\")+filename; 
     624    FILE * pFile = fopen(strEx::wstring_to_string(fullpath).c_str(),"r");; 
     625    if (pFile==NULL)  
     626      return 0; 
     627    char c; 
     628    do { 
     629      c = fgetc (pFile); 
     630      if (c == '\r') { 
     631        c = fgetc (pFile); 
     632        count++; 
     633      } else if (c == '\n') { 
     634        c = fgetc (pFile); 
     635        count++; 
     636      } 
     637    } while (c != EOF); 
     638    fclose (pFile); 
     639    cached_count.second = count; 
     640    cached_count.first = true; 
     641    return cached_count.second; 
     642  } 
    430643}; 
    431644 
    … …  
    435648  filters::filter_all_times accessed; 
    436649  filters::filter_all_times written; 
    437   static const __int64 MSECS_TO_100NS = 10000; 
     650  filters::filter_all_strings version; 
     651  filters::filter_all_num_ul line_count; 
    438652 
    439653  inline bool hasFilter() { 
    … …  
    441655      accessed.hasFilter() || written.hasFilter(); 
    442656  } 
    443   bool matchFilter(const file_info &value) const { 
     657  bool matchFilter(file_info &value) const { 
    444658    if ((size.hasFilter())&&(size.matchFilter(value.ullSize))) 
    445659      return true; 
    446     else if ((creation.hasFilter())&&(creation.matchFilter((value.ullNow-value.ullCreationTime)/MSECS_TO_100NS))) 
     660    else if (creation.hasFilter()&&creation.matchFilter(value.get_creation())) 
    447661      return true; 
    448     else if ((accessed.hasFilter())&&(accessed.matchFilter((value.ullNow-value.ullLastAccessTime)/MSECS_TO_100NS))) 
     662    else if (accessed.hasFilter()&&accessed.matchFilter(value.get_access())) 
    449663      return true; 
    450     else if ((written.hasFilter())&&(written.matchFilter((value.ullNow-value.ullLastWriteTime)/MSECS_TO_100NS))) 
     664    else if (written.hasFilter()&&written.matchFilter(value.get_write())) 
     665      return true; 
     666    else if ((version.hasFilter())&&(version.matchFilter(value.get_version()))) 
     667      return true; 
     668    else if ((line_count.hasFilter())&&(line_count.matchFilter(value.get_line_count()))) 
    451669      return true; 
    452670    return false; 
    … …  
    462680    if (written.hasFilter()) 
    463681      return _T("written: ") + written.getValue(); 
     682    if (version.hasFilter()) 
     683      return _T("written: ") + version.getValue(); 
     684    if (line_count.hasFilter()) 
     685      return _T("written: ") + line_count.getValue(); 
    464686    return _T("UNknown..."); 
    465687  } 
    … …  
    477699    if (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes)) 
    478700      return true; 
     701 
     702    file_info info = file_info::get(ffd); 
     703    if (!info.error.empty()) { 
     704      setError(ffd.errors, info.error); 
     705      return false; 
     706    } 
     707    return false; 
     708    /* 
    479709    BY_HANDLE_FILE_INFORMATION _info; 
    480710 
    481     HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
     711    HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    482712      0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    483713    if (hFile == INVALID_HANDLE_VALUE) { 
    … …  
    487717    GetFileInformationByHandle(hFile, &_info); 
    488718    CloseHandle(hFile); 
    489     info = file_info(_info, ffd.wfd.cFileName); 
     719    info = file_info(_info, ffd.path, ffd.wfd.cFileName); 
    490720    return false; 
     721    */ 
    491722  } 
    492723  inline const bool hasError() const { 
    … …  
    516747    if (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes)) 
    517748      return true; 
     749 
     750    file_info info = file_info::get(ffd); 
     751    if (!info.error.empty()) { 
     752      setError(ffd.errors, info.error); 
     753      return true; 
     754    } 
     755    /* 
    518756    BY_HANDLE_FILE_INFORMATION _info; 
    519757 
    520     HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
     758    HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    521759      0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    522760    if (hFile == INVALID_HANDLE_VALUE) { 
    … …  
    526764    GetFileInformationByHandle(hFile, &_info); 
    527765    CloseHandle(hFile); 
    528     file_info info(_info, ffd.wfd.cFileName); 
     766    file_info info(_info, ffd.path, ffd.wfd.cFileName); 
    529767    info.ullNow = now; 
     768    */ 
    530769 
    531770    for (std::list<file_filter>::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) { 
    … …  
    581820  std::wstring message; 
    582821  std::wstring syntax; 
    583   std::wstring alias; 
     822  //std::wstring alias; 
    584823  unsigned long long now; 
    585824  unsigned int hit_count; 
    586  
    587   file_filter_function_ex() : hit_count(0), error(false), debug_(false), bFilterIn(true), bFilterAll(true) {} 
     825  unsigned int file_count; 
     826  std::wstring last_error; 
     827  unsigned int error_count; 
     828 
     829  file_filter_function_ex() : hit_count(0), file_count(0), error(false), debug_(false), bFilterIn(true), bFilterAll(true), error_count(0) {} 
    588830  result_type operator()(argument_type ffd) { 
    589     if (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes)) 
     831    if (is_directory(ffd.wfd.dwFileAttributes)) 
    590832      return true; 
     833 
     834    file_info info = file_info::get(ffd); 
     835    if (!info.error.empty()) { 
     836      setError(ffd.errors, info.error); 
     837      return true; 
     838    } 
     839    /* 
    591840    BY_HANDLE_FILE_INFORMATION _info; 
    592841 
    593     HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
     842    HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    594843      0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    595844    if (hFile == INVALID_HANDLE_VALUE) { 
    … …  
    599848    GetFileInformationByHandle(hFile, &_info); 
    600849    CloseHandle(hFile); 
    601     file_info info(_info, ffd.wfd.cFileName); 
     850    file_info info(_info, ffd.path, ffd.wfd.cFileName); 
    602851    info.ullNow = now; 
     852    */ 
    603853 
    604854    bool bMatch = !bFilterIn; 
    … …  
    609859      if ((mode == filter_minus)&&(bTmpMatched)) { 
    610860        // a -<filter> hit so thrash item and bail out! 
    611         //if (debug_) 
     861        if (debug_) 
    612862          NSC_DEBUG_MSG_STD(_T("Matched: - ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax)); 
    613863        bMatch = false; 
    … …  
    615865      } else if ((mode == filter_plus)&&(!bTmpMatched)) { 
    616866        // a +<filter> missed hit so thrash item and bail out! 
    617         //if (debug_) 
     867        if (debug_) 
    618868          NSC_DEBUG_MSG_STD(_T("Matched (missed): + ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax)); 
    619869        bMatch = false; 
    … …  
    626876    } 
    627877 
    628     NSC_DEBUG_MSG_STD(_T("result: ") + strEx::itos(bFilterIn) + _T(" -- ") + strEx::itos(bMatch)); 
     878    //NSC_DEBUG_MSG_STD(_T("result: ") + strEx::itos(bFilterIn) + _T(" -- ") + strEx::itos(bMatch)); 
    629879    if ((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch)) { 
    630880      strEx::append_list(message, info.render(syntax)); 
     881      /* 
    631882      if (alias.length() < 16) 
    632883        strEx::append_list(alias, info.filename); 
    633884      else 
    634885        strEx::append_list(alias, std::wstring(_T("..."))); 
     886        */ 
    635887      hit_count++; 
    636888    } 
     889    file_count++; 
    637890    return true; 
    638891  } 
    … …  
    643896    if (errors != NULL) 
    644897      errors->report_error(msg); 
     898    last_error = msg; 
     899    error_count++; 
    645900    error = true; 
    646901  } 
     902 
     903  std::wstring render(std::wstring syntax) { 
     904    strEx::replace(syntax, _T("%list%"), message); 
     905    strEx::replace(syntax, _T("%matches%"), strEx::itos(hit_count)); 
     906    strEx::replace(syntax, _T("%files%"), strEx::itos(file_count)); 
     907    return syntax; 
     908  } 
     909 
     910  bool has_filter() { 
     911    return !filter_chain.empty(); 
     912  } 
     913 
    647914}; 
     915 
    648916 
    649917NSCAPI::nagiosReturn CheckDisk::getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    … …  
    657925  std::wstring format = _T("%Y years %m mon %d days %H hours %M min %S sec"); 
    658926  std::wstring path; 
     927  bool debug = false; 
    659928  find_first_file_info finder; 
    660929  MAP_OPTIONS_BEGIN(stl_args) 
    661930    MAP_OPTIONS_STR(_T("path"), path) 
    662931    MAP_OPTIONS_STR(_T("date"), format) 
     932    MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    663933    MAP_OPTIONS_FALLBACK(format) 
    664934  MAP_OPTIONS_END() 
    … …  
    671941  NSC_error errors; 
    672942  pattern_type splitpath = split_pattern(path); 
    673   recursive_scan<find_first_file_info>(splitpath.first, splitpath.second, -1, -1, finder, &errors); 
     943  recursive_scan<find_first_file_info>(splitpath.first, splitpath.second, -1, -1, finder, &errors, debug); 
    674944  if (finder.hasError()) { 
    675945    message = _T("File not found (check log for details)"); 
    … …  
    702972  bool bPerfData = true; 
    703973  unsigned int max_dir_depth = -1; 
     974  bool debug = false; 
    704975 
    705976  try { 
    … …  
    713984      MAP_OPTIONS_STR2INT(_T("max-dir-depth"), max_dir_depth) 
    714985      MAP_OPTIONS_PUSH(_T("file"), paths) 
     986      MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    715987      MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out")) 
    716988      MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterAll, _T("all"), _T("any")) 
    … …  
    7351007  for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) { 
    7361008    pattern_type path = split_pattern(*pit); 
    737     recursive_scan<file_filter_function>(path.first, path.second, 0, max_dir_depth, finder, &errors); 
     1009    recursive_scan<file_filter_function>(path.first, path.second, 0, max_dir_depth, finder, &errors, debug); 
    7381010    if (finder.hasError()) { 
    7391011      message = _T("File not found: ") + (*pit) + _T(" check log for details."); 
    … …  
    7581030} 
    7591031 
    760 #define MAP_FILTER(value, obj, filtermode) \ 
    761       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)); } 
     1032#define MAP_FILTER(value, obj) \ 
     1033    else if (p__.first == _T("filter+"##value)) { file_filter filter; filter.obj = p__.second; \ 
     1034      finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_plus, filter)); } \ 
     1035    else if (p__.first == _T("filter-"##value)) { file_filter filter; filter.obj = p__.second; \ 
     1036      finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_minus, filter)); } \ 
     1037    else if (p__.first == _T("filter."##value)) { file_filter filter; filter.obj = p__.second; \ 
     1038      finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_normal, filter)); } 
    7621039 
    7631040NSCAPI::nagiosReturn CheckDisk::CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    … …  
    7771054  CheckFileContainer query; 
    7781055  std::wstring syntax = _T("%filename%"); 
     1056  std::wstring masterSyntax = _T("%list%"); 
    7791057  std::wstring alias; 
    7801058  std::wstring pattern = _T("*.*"); 
    7811059  bool bPerfData = true; 
    7821060  int max_dir_depth = -1; 
     1061  bool debug = false; 
     1062  bool ignoreError = false; 
    7831063 
    7841064  try { 
    … …  
    7881068      MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    7891069      MAP_OPTIONS_STR(_T("syntax"), syntax) 
     1070      MAP_OPTIONS_STR(_T("master-syntax"), masterSyntax) 
    7901071      MAP_OPTIONS_PUSH(_T("path"), paths) 
    7911072      MAP_OPTIONS_STR(_T("pattern"), pattern) 
    7921073      MAP_OPTIONS_STR(_T("alias"), alias) 
    7931074      MAP_OPTIONS_PUSH(_T("file"), paths) 
     1075      MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
     1076      MAP_OPTIONS_BOOL_TRUE(_T("ignore-errors"), ignoreError) 
    7941077      MAP_OPTIONS_STR2INT(_T("max-dir-depth"), max_dir_depth) 
    7951078      MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out")) 
    … …  
    8021085      */ 
    8031086 
    804       MAP_FILTER(_T("filter+size"), size, filter_plus) 
    805       MAP_FILTER(_T("filter+creation"), creation, filter_plus) 
    806       MAP_FILTER(_T("filter+written"), written, filter_plus) 
    807       MAP_FILTER(_T("filter+accessed"), accessed, filter_plus) 
    808  
     1087      MAP_FILTER(_T("size"), size) 
     1088      MAP_FILTER(_T("creation"), creation) 
     1089      MAP_FILTER(_T("written"), written) 
     1090      MAP_FILTER(_T("accessed"), accessed) 
     1091      MAP_FILTER(_T("version"), version) 
     1092      MAP_FILTER(_T("line-count"), line_count) 
     1093/* 
    8091094      MAP_FILTER(_T("filter.size"), size, filter_normal) 
    8101095      MAP_FILTER(_T("filter.creation"), creation, filter_normal) 
    8111096      MAP_FILTER(_T("filter.written"), written, filter_normal) 
    8121097      MAP_FILTER(_T("filter.accessed"), accessed, filter_normal) 
     1098      MAP_FILTER(_T("filter.version"), version, filter_normal) 
    8131099 
    8141100      MAP_FILTER(_T("filter-size"), size, filter_minus) 
    … …  
    8161102      MAP_FILTER(_T("filter-written"), written, filter_minus) 
    8171103      MAP_FILTER(_T("filter-accessed"), accessed, filter_minus) 
    818  
     1104      MAP_FILTER(_T("filter-version"), version, filter_minus) 
     1105*/ 
    8191106      MAP_OPTIONS_MISSING(message, _T("Unknown argument: ")) 
    8201107      MAP_OPTIONS_END() 
    … …  
    8251112    message = e.getMessage(); 
    8261113    return NSCAPI::returnUNKNOWN; 
    827     } 
    828     FILETIME now; 
    829     GetSystemTimeAsFileTime(&now); 
    830     finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
    831     finder.syntax = syntax; 
    832     NSC_error errors; 
    833     for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) { 
    834       recursive_scan<file_filter_function_ex>(*pit, pattern, 0, max_dir_depth, finder, &errors); 
    835       if (finder.hasError()) { 
    836         message = _T("Error when scanning: ") + (*pit) + _T(" check log for details."); 
    837         return NSCAPI::returnUNKNOWN; 
    838       } 
    839     } 
    840     message = finder.message; 
    841     if (!alias.empty()) 
    842       query.alias = alias; 
     1114  } 
     1115  if (paths.empty()) { 
     1116    message = _T("Missing path argument"); 
     1117    return NSCAPI::returnUNKNOWN; 
     1118  } 
     1119  if (!finder.has_filter()) { 
     1120    message = _T("Missing filter argument"); 
     1121    return NSCAPI::returnUNKNOWN; 
     1122  } 
     1123  FILETIME now; 
     1124  GetSystemTimeAsFileTime(&now); 
     1125  finder.debug_ = debug; 
     1126  finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
     1127  if (debug) 
     1128    NSC_DEBUG_MSG_STD(_T("NOW: ") + strEx::format_filetime(finder.now)); 
     1129  finder.syntax = syntax; 
     1130  NSC_error errors; 
     1131  for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) { 
     1132    recursive_scan<file_filter_function_ex>(*pit, pattern, 0, max_dir_depth, finder, &errors, debug); 
     1133    if (!ignoreError && finder.hasError()) { 
     1134      message = _T("Error when scanning: ") + (*pit) + _T(" check log for details (") + strEx::itos(finder.error_count) + _T(": ") + finder.last_error + _T(")"); 
     1135      return NSCAPI::returnUNKNOWN; 
     1136    } 
     1137  } 
     1138  message  = finder.render(masterSyntax); 
     1139  if (!alias.empty()) 
     1140    query.alias = alias; 
     1141  else 
     1142    query.alias = _T("found files"); 
     1143  query.runCheck(finder.hit_count, returnCode, message, perf); 
     1144  if ((truncate > 0) && (message.length() > (truncate-4))) { 
     1145    message = message.substr(0, truncate-4) + _T("..."); 
     1146    //perf = _T(""); 
     1147  } 
     1148  if (message.empty()) 
     1149    message = _T("CheckFile ok"); 
     1150  return returnCode; 
     1151} 
     1152struct file_container : public file_info { 
     1153  std::wstring error_; 
     1154 
     1155  static file_container get(std::wstring file, unsigned long long now) { 
     1156 
     1157    BY_HANDLE_FILE_INFORMATION _info; 
     1158 
     1159    HANDLE hFile = CreateFile(file.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
     1160      0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
     1161    if (hFile == INVALID_HANDLE_VALUE) { 
     1162      return file_container(file, _T("Could not open file: ") + file); 
     1163    } 
     1164    GetFileInformationByHandle(hFile, &_info); 
     1165    CloseHandle(hFile); 
     1166    file_container info(_info, file); 
     1167    info.ullNow = now; 
     1168    return info; 
     1169  } 
     1170 
     1171 
     1172  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)) {} 
     1173  file_container(std::wstring file, std::wstring error) : error_(error), file_info(file_helpers::meta::get_path(file), file_helpers::meta::get_filename(file)) {} 
     1174 
     1175  bool has_errors() { 
     1176    return !error_.empty(); 
     1177  } 
     1178  std::wstring get_error() { 
     1179    return error_; 
     1180  } 
     1181 
     1182}; 
     1183 
     1184typedef checkHolders::ExactBounds<checkHolders::NumericBounds<checkHolders::disk_size_type, checkHolders::disk_size_handler<checkHolders::disk_size_type> > > ExactBoundsDiscSize; 
     1185 
     1186 
     1187typedef checkHolders::CheckContainer<checkHolders::ExactBoundsULong> ExactULongContainer; 
     1188typedef checkHolders::CheckContainer<ExactBoundsDiscSize> DiscSizeContainer; 
     1189typedef checkHolders::CheckContainer<checkHolders::ExactBoundsTime> DateTimeContainer; 
     1190 
     1191struct check_file_size : public checkHolders::check_proxy_container<file_container, DiscSizeContainer> { 
     1192  check_file_size() { set_alias(_T("size")); } 
     1193  checkHolders::disk_size_type get_value(file_container &value) { 
     1194    return value.ullSize; 
     1195  } 
     1196}; 
     1197struct check_file_line_count : public checkHolders::check_proxy_container<file_container, ExactULongContainer> { 
     1198  check_file_line_count() { set_alias(_T("line-count")); } 
     1199  unsigned long get_value(file_container &value) { 
     1200    return value.get_line_count(); 
     1201  } 
     1202}; 
     1203struct check_file_dates : public checkHolders::check_proxy_container<file_container, DateTimeContainer> { 
     1204  enum type_type { 
     1205    date_access, date_creation, date_written 
     1206  } ; 
     1207  type_type type_; 
     1208  check_file_dates(type_type type) : type_(type)  
     1209  {  
     1210    if (type_ == date_creation) 
     1211      set_alias(_T("creation"));  
     1212    else if (type_ == date_access) 
     1213      set_alias(_T("access"));  
     1214    else if (type_ == date_written) 
     1215      set_alias(_T("written"));  
    8431216    else 
    844       query.alias = finder.alias; 
    845     if (query.alias.empty()) 
    846       query.alias = _T("no files found"); 
    847     query.runCheck(finder.hit_count, returnCode, message, perf); 
    848     if ((truncate > 0) && (message.length() > (truncate-4))) 
    849       message = message.substr(0, truncate-4) + _T("..."); 
    850     if (message.empty()) 
    851       message = _T("CheckFile ok"); 
    852     return returnCode; 
    853 } 
    854  
     1217      set_alias(_T("unknown date type"));  
     1218  } 
     1219  unsigned long long get_value(file_container &value) { 
     1220    if (type_ == date_creation) 
     1221      return value.ullCreationTime; 
     1222    if (type_ == date_access) 
     1223      return value.ullLastAccessTime; 
     1224    if (type_ == date_written) 
     1225      return value.ullLastWriteTime; 
     1226    return -1; 
     1227  } 
     1228}; 
     1229 
     1230typedef checkHolders::check_multi_container<file_container> check_file_multi; 
     1231struct check_file_factories { 
     1232  static checkHolders::check_proxy_interface<file_container>* size() { 
     1233    return new check_file_size(); 
     1234  } 
     1235  static checkHolders::check_proxy_interface<file_container>* line_count() { 
     1236    return new check_file_line_count(); 
     1237  } 
     1238  static checkHolders::check_proxy_interface<file_container>* access() { 
     1239    return new check_file_dates(check_file_dates::date_access); 
     1240  } 
     1241  static checkHolders::check_proxy_interface<file_container>* creation() { 
     1242    return new check_file_dates(check_file_dates::date_creation); 
     1243  } 
     1244  static checkHolders::check_proxy_interface<file_container>* written() { 
     1245    return new check_file_dates(check_file_dates::date_written); 
     1246  } 
     1247}; 
     1248 
     1249#define MAP_FACTORY_PB(value, obj) \ 
     1250    else if ((p__.first == _T("check")) && (p__.second == ##value)) { checker.add_check(check_file_factories::obj()); } 
     1251 
     1252 
     1253NSCAPI::nagiosReturn CheckDisk::CheckSingleFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
     1254  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
     1255  std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
     1256  check_file_multi checker; 
     1257  typedef std::pair<int,file_filter> filteritem_type; 
     1258  typedef std::list<filteritem_type > filterlist_type; 
     1259  if (stl_args.empty()) { 
     1260    message = _T("Missing argument(s)."); 
     1261    return NSCAPI::returnUNKNOWN; 
     1262  } 
     1263  std::list<std::wstring> files; 
     1264  unsigned int truncate = 0; 
     1265  std::wstring syntax = _T("%filename%"); 
     1266  std::wstring alias; 
     1267  bool bPerfData = true; 
     1268 
     1269  try { 
     1270    MAP_OPTIONS_BEGIN(stl_args) 
     1271      //MAP_OPTIONS_NUMERIC_ALL(query, _T("")) 
     1272      MAP_OPTIONS_STR2INT(_T("truncate"), truncate) 
     1273      MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
     1274      MAP_OPTIONS_STR(_T("syntax"), syntax) 
     1275      MAP_OPTIONS_STR(_T("alias"), alias) 
     1276      MAP_OPTIONS_PUSH(_T("file"), files) 
     1277      MAP_OPTIONS_EXACT_NUMERIC_ALL_MULTI(checker, _T("")) 
     1278      MAP_FACTORY_PB(_T("size"), size) 
     1279      MAP_FACTORY_PB(_T("line-count"), line_count) 
     1280      MAP_FACTORY_PB(_T("creation"), creation) 
     1281      MAP_FACTORY_PB(_T("access"), access) 
     1282      MAP_FACTORY_PB(_T("written"), written) 
     1283      /* 
     1284      MAP_FILTER(_T("creation"), creation) 
     1285      MAP_FILTER(_T("written"), written) 
     1286      MAP_FILTER(_T("accessed"), accessed) 
     1287      MAP_FILTER(_T("version"), version) 
     1288      MAP_FILTER(_T("line-count"), line_count) 
     1289      */ 
     1290      MAP_OPTIONS_MISSING(message, _T("Unknown argument: ")) 
     1291      MAP_OPTIONS_END() 
     1292  } catch (filters::parse_exception e) { 
     1293    message = e.getMessage(); 
     1294    return NSCAPI::returnUNKNOWN; 
     1295  } catch (filters::filter_exception e) { 
     1296    message = e.getMessage(); 
     1297    return NSCAPI::returnUNKNOWN; 
     1298  } 
     1299  FILETIME now; 
     1300  GetSystemTimeAsFileTime(&now); 
     1301  unsigned __int64 nowi64 = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
     1302  //finder.syntax = syntax; 
     1303  for (std::list<std::wstring>::const_iterator pit = files.begin(); pit != files.end(); ++pit) { 
     1304    file_container info = file_container::get(*pit, nowi64); 
     1305    checker.alias = info.render(syntax); 
     1306    checker.runCheck(info, returnCode, message, perf); 
     1307  } 
     1308  if ((truncate > 0) && (message.length() > (truncate-4))) { 
     1309    message = message.substr(0, truncate-4) + _T("..."); 
     1310    perf = _T(""); 
     1311  } 
     1312  if (message.empty()) 
     1313    message = _T("CheckSingleFile ok"); 
     1314  return returnCode; 
     1315} 
    8551316NSCAPI::nagiosReturn CheckDisk::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) { 
    8561317  if (command == _T("CheckFileSize")) { 
    … …  
    8621323  } else if (command == _T("CheckFile2")) { 
    8631324    return CheckFile2(argLen, char_args, msg, perf); 
     1325  } else if (command == _T("CheckSingleFile")) { 
     1326    return CheckSingleFile(argLen, char_args, msg, perf); 
    8641327  } else if (command == _T("getFileAge")) { 
    8651328    return getFileAge(argLen, char_args, msg, perf); 

  • modules/CheckDisk/CheckDisk.h

    r739db5a rb4110d8  
    5757  NSCAPI::nagiosReturn CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    5858  NSCAPI::nagiosReturn getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     59  NSCAPI::nagiosReturn CheckSingleFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    5960 
    6061private: 

  • modules/CheckEventLog/CheckEventLog.cpp

    r7f9c823 rb4110d8  
    5757    syntax_ = SETTINGS_GET_STRING(event_log::SYNTAX); 
    5858    buffer_length_ = SETTINGS_GET_INT(event_log::BUFFER_SIZE); 
     59    buffer_length_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_BUFFER, EVENTLOG_BUFFER_DEFAULT); 
    5960  } catch (NSCModuleHelper::NSCMHExcpetion &e) { 
    6061    NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_); 
    … …  
    228229    return pevlr_->EventType; 
    229230  } 
    230 /* 
     231 
    231232  std::wstring userSID() const { 
    232233    if (pevlr_->UserSidOffset == 0) 
    233       return ""; 
     234      return _T(""); 
    234235    PSID p = reinterpret_cast<PSID>(reinterpret_cast<LPBYTE>(pevlr_) + + pevlr_->UserSidOffset); 
    235     LPSTR user = new CHAR[1025]; 
    236     LPSTR domain = new CHAR[1025]; 
    237     DWORD userLen = 1024; 
    238     DWORD domainLen = 1024; 
     236    DWORD userLen = 0; 
     237    DWORD domainLen = 0; 
    239238    SID_NAME_USE sidName; 
     239 
     240    LookupAccountSid(NULL, p, NULL, &userLen, NULL, &domainLen, &sidName); 
     241    LPTSTR user = new TCHAR[userLen+10]; 
     242    LPTSTR domain = new TCHAR[domainLen+10]; 
     243 
    240244    LookupAccountSid(NULL, p, user, &userLen, domain, &domainLen, &sidName); 
    241245    user[userLen] = 0; 
    242246    domain[domainLen] = 0; 
    243     return std::wstring(domain) + "\\" + std::wstring(user); 
    244   } 
    245   */ 
     247    std::wstring ustr = user; 
     248    std::wstring dstr = domain; 
     249    delete [] user; 
     250    delete [] domain; 
     251    if (!dstr.empty()) 
     252      dstr = dstr + _T("\\"); 
     253    if (ustr.empty() && dstr.empty()) 
     254      return _T("missing"); 
     255 
     256    return dstr + ustr; 
     257  } 
    246258 
    247259  std::wstring enumStrings() const { 
    … …  
    405417    strEx::replace(syntax, _T("%strings%"), enumStrings()); 
    406418    strEx::replace(syntax, _T("%id%"), strEx::itos(eventID())); 
     419    strEx::replace(syntax, _T("%user%"), userSID()); 
    407420    return syntax; 
    408421  } 

  • modules/CheckExternalScripts/CheckExternalScripts.cpp

    r3080680 rb4110d8  
    2727#include <config.h> 
    2828#include <strEx.h> 
     29#include <file_helpers.hpp> 
    2930#include <file_helpers.hpp> 
    3031 

  • modules/CheckHelpers/CheckHelpers.cpp

    r2018659 rb4110d8  
    2626 
    2727CheckHelpers gCheckHelpers; 
    28 #ifdef _WIN32 
    29 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) 
    30 { 
    31   NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call); 
    32   return TRUE; 
    33 } 
    34 #endif 
    3528 
    3629CheckHelpers::CheckHelpers() { 
    … …  
    9386    NSCModuleHelper::InjectSimpleCommand(new_command, arguments, message, perf); 
    9487    return NSCAPI::returnOK; 
     88  } else if (command == _T("CheckVersion")) { 
     89    message = NSCModuleHelper::getApplicationVersionString(); 
     90    return NSCAPI::returnOK; 
     91  } else if (command == _T("CheckOK")) { 
     92    return checkSimpleStatus(NSCAPI::returnOK, arguments, message, perf); 
     93  } else if (command == _T("CheckWARNING")) { 
     94    return checkSimpleStatus(NSCAPI::returnWARN, arguments, message, perf); 
     95  } else if (command == _T("CheckCRITICAL")) { 
     96    return checkSimpleStatus(NSCAPI::returnCRIT, arguments, message, perf); 
    9597  } else if (command == _T("CheckAlwaysCRITICAL")) { 
    9698    if (arguments.size() < 1) { 
    … …  
    162164 
    163165 
     166NSC_WRAP_DLL(); 
    164167NSC_WRAPPERS_MAIN_DEF(gCheckHelpers); 
    165168NSC_WRAPPERS_IGNORE_MSG_DEF(); 

  • modules/CheckHelpers/CheckHelpers.h

    r2018659 rb4110d8  
    5252  NSCAPI::nagiosReturn checkMultiple(const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5353  NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
     54  NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf); 
    5455}; 

  • modules/CheckSystem/CheckSystem.cpp

    r7f9c823 rb4110d8  
    135135            std::wstring error; 
    136136            bool bStatus = true; 
    137             if (PDH::Enumerations::validate(counter, error)) { 
     137            if (PDH::PDHResolver::validate(counter, error, false)) { 
    138138              status.push_back(_T("open")); 
    139139            } else { 
    … …  
    212212          std::wcout << _T("testing: ") << counter << _T(": "); 
    213213          std::wstring error; 
    214           if (PDH::Enumerations::validate(counter, error)) { 
     214          if (PDH::PDHResolver::validate(counter, error, false)) { 
    215215            std::wcout << _T(" found "); 
    216216          } else { 
    … …  
    10301030  unsigned int averageDelay = 1000; 
    10311031  CounterContainer tmpObject; 
     1032  bool bExpandIndex = false; 
     1033  bool bForceReload = false; 
    10321034 
    10331035  MAP_OPTIONS_BEGIN(stl_args) 
    … …  
    10431045    MAP_OPTIONS_BOOL_EX(_T("Averages"), bCheckAverages, _T("true"), _T("false")) 
    10441046    MAP_OPTIONS_BOOL_TRUE(NSCLIENT, bNSClient) 
     1047    MAP_OPTIONS_BOOL_TRUE(_T("index"), bExpandIndex) 
     1048    MAP_OPTIONS_BOOL_TRUE(_T("reload"), bForceReload) 
    10451049    MAP_OPTIONS_FIRST_CHAR('\\', tmpObject.data, counters.push_back(tmpObject)) 
    10461050    MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2) 
    … …  
    10541058    MAP_OPTIONS_FALLBACK_AND(tmpObject.data, counters.push_back(tmpObject)) 
    10551059  MAP_OPTIONS_END() 
     1060 
     1061  if (counters.empty()) { 
     1062    msg = _T("No counters specified"); 
     1063    return NSCAPI::returnUNKNOWN; 
     1064  } 
     1065 
    10561066  for (std::list<CounterContainer>::const_iterator cit = counters.begin(); cit != counters.end(); ++cit) { 
    10571067    CounterContainer counter = (*cit); 
    10581068    try { 
    10591069      std::wstring tstr; 
    1060       if (!PDH::Enumerations::validate(counter.data, tstr)) { 
     1070      if (bExpandIndex) { 
     1071        PDH::PDHResolver::expand_index(counter.data); 
     1072      } 
     1073      if (!PDH::PDHResolver::validate(counter.data, tstr, bForceReload)) { 
    10611074        NSC_LOG_ERROR_STD(_T("ERROR: Counter not found: ") + counter.data + _T(": ") + tstr); 
    10621075        if (bNSClient) { 
    … …  
    10641077          //msg = _T("0"); 
    10651078        } else { 
    1066           //msg = tstr; 
    1067           //msg += _T(" (") + counter.getAlias() + _T("|") + counter.data + _T(")"); 
     1079          msg = _T("CRIT: Counter not found: ") + counter.data + _T(": ") + tstr; 
     1080          return NSCAPI::returnCRIT; 
    10681081        } 
    1069         //return NSCHelper::translateReturn(invalidStatus); 
    10701082      } 
    10711083      PDH::PDHQuery pdh; 

  • modules/CheckSystem/CheckSystem.h

    r5da0459 rb4110d8  
    2121#pragma once 
    2222 
     23#include <pdh.hpp> 
    2324#include "PDHCollector.h" 
    2425#include <CheckMemory.h> 

  • modules/CheckSystem/PDHCollector.cpp

    rd5356c1 rb4110d8  
    3030  unsigned int i = strEx::stoui_as_time(s, checkIntervall_*100); 
    3131  cpu.resize(i/(checkIntervall_*100)+10); 
     32  std::wstring subsystem = NSCModuleHelper::getSettingsString(C_SYSTEM_SECTION_TITLE, C_SYSTEM_PDH_SUBSYSTEM, C_SYSTEM_PDH_SUBSYSTEM_DEFAULT); 
     33  if (subsystem == C_SYSTEM_PDH_SUBSYSTEM_DEFAULT) { 
     34  } else if (subsystem == _T("thread-safe")) { 
     35    PDH::PDHFactory::set_threadSafe(); 
     36  } else { 
     37    NSC_LOG_ERROR_STD(_T("Unknown PDH subsystem (") + subsystem + _T(") valid values are: fast and thread-safe")); 
     38  } 
    3239} 
    3340 
    … …  
    103110    if (bUseIndex) { 
    104111      NSC_DEBUG_MSG_STD(_T("Using index to retrive counternames")); 
    105       proc = _T("\\") + pdh.lookupIndex(238) + _T("(_total)\\") + pdh.lookupIndex(6); 
    106       uptime = _T("\\") + pdh.lookupIndex(2) + _T("\\") + pdh.lookupIndex(674); 
    107       memCl = _T("\\") + pdh.lookupIndex(4) + _T("\\") + pdh.lookupIndex(30); 
    108       memCb = _T("\\") + pdh.lookupIndex(4) + _T("\\") + pdh.lookupIndex(26); 
     112      proc = _T("\\") + PDH::PDHResolver::lookupIndex(238) + _T("(_total)\\") + PDH::PDHResolver::lookupIndex(6); 
     113      uptime = _T("\\") + PDH::PDHResolver::lookupIndex(2) + _T("\\") + PDH::PDHResolver::lookupIndex(674); 
     114      memCl = _T("\\") + PDH::PDHResolver::lookupIndex(4) + _T("\\") + PDH::PDHResolver::lookupIndex(30); 
     115      memCb = _T("\\") + PDH::PDHResolver::lookupIndex(4) + _T("\\") + PDH::PDHResolver::lookupIndex(26); 
    109116    } else { 
    110       //settings_core settings; 
    111       NSC_LOG_ERROR_STD(_T("REPORT THIS: counters.defs file handling has not been (re)added!!!")); 
    112       return false; 
    113       /* 
    114       @TODO: FIXME 
    115       SettingsT settings; 
     117      settings_core settings; 
    116118      settings.setFile(NSCModuleHelper::getBasePath(),  _T("counters.defs"), true); 
    117119      NSC_DEBUG_MSG_STD(_T("Detected language: ") + settings.getString(section, _T("Description"), _T("Not found")) + _T(" (") + section + _T(")")); 

  • modules/CheckSystem/PDHCollector.h

    rdd02c15 rb4110d8  
    2121#pragma once 
    2222 
    23 #include "PDHCollectors.h" 
     23#include <pdh.hpp> 
    2424#include <thread.h> 
    2525#include <MutexRW.h> 

  • modules/NRPEClient/NRPEClient.cpp

    rc0d7e82 rb4110d8  
    2828#include <strEx.h> 
    2929#include <boost/filesystem.hpp> 
     30#include <strEx.h> 
    3031 
    3132 
    3233NRPEClient gNRPEClient; 
    33  
    34 #ifdef _WIN32 
    35 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) 
    36 { 
    37   NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call); 
    38   return TRUE; 
    39 } 
    40 #endif 
    4134 
    4235NRPEClient::NRPEClient() : buffer_length_(0) { 
    … …  
    9487 
    9588void NRPEClient::addCommand(strEx::blindstr key, std::wstring args) { 
     89#ifndef USE_BOOST 
     90  NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str() + _T(" boost not avalible!")); 
     91#else 
    9692  try { 
    9793 
    … …  
    130126    NSC_LOG_ERROR_STD(_T("Could not parse: ") + key.c_str()); 
    131127  } 
     128#endif 
    132129} 
    133130 
    … …  
    442439 
    443440 
     441NSC_WRAP_DLL(); 
    444442NSC_WRAPPERS_MAIN_DEF(gNRPEClient); 
    445443NSC_WRAPPERS_IGNORE_MSG_DEF(); 

  • modules/NRPEClient/NRPEClient.h

    rc0d7e82 rb4110d8  
    127127  nrpe::packet send_ssl(std::wstring host, int port, int timeout, nrpe::packet packet); 
    128128  void add_options(po::options_description &desc, nrpe_connection_data &command_data); 
    129  
     129#ifdef USE_BOOST 
     130#endif 
    130131 
    131132private: 

  • modules/NRPEServer/NRPEServer.cpp

    rc4d4219 rb4110d8  
    2727 
    2828NRPEListener gNRPEListener; 
    29  
    30 #ifdef _WIN32 
    31 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) 
    32 { 
    33   NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call); 
    34   return TRUE; 
    35 } 
    36 #endif 
    3729 
    3830NRPEListener::NRPEListener() : noPerfData_(false), buffer_length_(0) { 
    … …  
    308300// } 
    309301 
     302NSC_WRAP_DLL(); 
    310303NSC_WRAPPERS_MAIN_DEF(gNRPEListener); 
    311304NSC_WRAPPERS_IGNORE_MSG_DEF(); 
Note: See TracChangeset for help on using the changeset viewer.