Changeset 275 for trunk


Ignore:
Timestamp:
06/30/10 23:11:51 (20 months ago)
Author:
mickem
Message:

Some initial design concepts for CheckDIsk (not building yet)

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/nscapi/nscapi_plugin_wrapper.hpp

    r271 r275  
    171171      virtual NSCAPI::nagiosReturn handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf) = 0; 
    172172    }; 
     173 
     174    class CommandImpl { 
     175 
     176    public: 
     177      NSCAPI::nagiosReturn handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &response) { 
     178 
     179        std::wstring command = char_command; 
     180        PluginCommand::RequestMessage request_message; 
     181        request_message.ParseFromString(request); 
     182 
     183        if (request_message.payload_size() != 1) { 
     184          return NSCAPI::returnIgnored; 
     185        } 
     186        ::PluginCommand::Request req_payload = request_message.payload().Get(0); 
     187 
     188        PluginCommand::ResponseMessage response_message; 
     189        ::PluginCommand::Header* hdr = response_message.mutable_header(); 
     190 
     191        hdr->set_type(PluginCommand::Header_Type_RESPONSE); 
     192        hdr->set_version(PluginCommand::Header_Version_VERSION_1); 
     193 
     194        PluginCommand::Response *resp_payload = response_message.add_payload(); 
     195 
     196        handleCommand(command, &req_payload, resp_payload); 
     197 
     198 
     199        resp_payload->set_version(PluginCommand::Response_Version_VERSION_1); 
     200        response_message.SerializeToString(&response); 
     201 
     202        return NSCAPI::returnOK; 
     203      } 
     204 
     205      virtual void handleCommand(std::wstring command, PluginCommand::Request *request, PluginCommand::Response *response) = 0; 
     206    }; 
    173207  } 
    174208}; 

  • trunk/include/settings/macros.h

    r273 r275  
    9595#define LOG_SECTION "/settings/log" 
    9696 
     97#define CHECK_DISK_SECTION "/settings/check/disk" 
    9798 
    9899  namespace settings_def { 
    … …  
    321322  } 
    322323 
     324  namespace check_disk { 
     325    DEFINE_PATH(SECTION, CHECK_DISK_SECTION); 
     326    DESCRIBE_SETTING(SECTION, "CHECK DISK SECTION", ""); 
     327 
     328    DEFINE_SETTING_B(SHOW_ERRORS, CHECK_DISK_SECTION, "show errors", false); 
     329    DESCRIBE_SETTING_ADVANCED(SHOW_ERRORS, "", "???"); 
     330     
     331  } 
    323332 
    324333  namespace nsca { 

  • trunk/modules/CheckDisk/CheckDisk.cpp

    r273 r275  
    3030CheckDisk gCheckDisk; 
    3131 
    32 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) 
    33 { 
    34   NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call); 
    35   return TRUE; 
    36 } 
    37  
    3832CheckDisk::CheckDisk() : show_errors_(false) { 
    3933} 
    … …  
    4842 
    4943  try { 
    50     NSCModuleHelper::registerCommand(_T("CheckFileSize"), _T("Check or directory a file and verify its size.")); 
    51     NSCModuleHelper::registerCommand(_T("CheckDriveSize"), _T("Check the size (free-space) of a drive or volume.")); 
    52     NSCModuleHelper::registerCommand(_T("CheckFile"), _T("Check various aspects of a file and/or folder.")); 
     44    GET_CORE()->registerCommand(_T("check_drive"), _T("Check the disk space usage of a drive or volume.")); 
     45    GET_CORE()->registerCommand(_T("check_file"), _T("Check a single file and/or folder.")); 
     46    GET_CORE()->registerCommand(_T("check_files"), _T("Check a set of files and/or directories")); 
    5347 
    54     show_errors_ = NSCModuleHelper::getSettingsInt(CHECK_DISK_SECTION_TITLE, CHECK_DISK_SHOW_ERRORS, CHECK_DISK_SHOW_ERRORS_DEFAULT)==1; 
    55   } catch (NSCModuleHelper::NSCMHExcpetion &e) { 
     48    show_errors_ = SETTINGS_GET_BOOL(check_disk::SHOW_ERRORS); 
     49  } catch (nscapi::nscapi_exception &e) { 
    5650    NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_); 
    5751  } catch (...) { 
    … …  
    7165} 
    7266 
    73 class error_reporter { 
    74 public: 
    75   virtual void report_error(std::wstring error) = 0; 
    76   virtual void report_warning(std::wstring error) = 0; 
    77   virtual bool has_error() = 0; 
    78   virtual std::wstring get_error() = 0; 
     67using namespace boost::filesystem; 
     68 
     69struct find_options { 
     70  bool recursive; 
     71  int max_depth; 
     72  int current_depth; 
     73  bool single_file; 
     74 
     75  find_options() : current_depth(0), single_file(false) {} 
     76 
     77  inline find_options go_down() {  
     78    find_options op = *this; 
     79    op.current_depth++; 
     80    return op; 
     81  } 
     82  inline bool has_all(std::list<file_item> & files) { 
     83    return single_file; 
     84  } 
     85}; 
     86struct file_item { 
     87  bool is_directory() { 
     88    return true; 
     89  } 
     90  bool is_file() { 
     91    return false; 
     92  } 
     93  std::wstring get_name() { 
     94    return _T("hello"); 
     95  } 
     96}; 
     97 
     98struct file_filter { 
     99  virtual bool matches(file_item &) = 0; 
    79100}; 
    80101 
    81102 
     103bool find_files(const boost::filesystem::wpath & path, const find_options options, file_filter filter, std::list<file_item> & files) 
     104{ 
     105  if ( !exists( path ) ) return false; 
     106  directory_iterator end_itr; // default construction yields past-the-end 
     107  for ( directory_iterator itr(path); itr != end_itr; ++itr ) { 
     108    if ( is_directory(itr->status()) ) { 
     109      if (find_files(itr->path(), options.go_down(), filter, files) && options.has_all(files)) 
     110        return true; 
     111    } else { 
     112      file_item file(itr->leaf()); 
     113      if (filter.matches(file)) { 
     114        files.push_back(file); 
     115        if (options.has_all(files)) 
     116          return true; 
     117      } 
     118    } 
     119  } 
     120  return false; 
     121} 
    82122 
    83 struct file_finder_data { 
    84   file_finder_data(const WIN32_FIND_DATA wfd_, const std::wstring path_, error_reporter *errors_) : wfd(wfd_), path(path_), errors(errors_) {} 
    85   const WIN32_FIND_DATA wfd; 
    86   const std::wstring path; 
    87   error_reporter *errors; 
    88 }; 
    89 typedef std::unary_function<const file_finder_data&, bool> baseFinderFunction; 
     123void CheckDisk::check_file(PluginCommand::Request *request, PluginCommand::Response *response) { 
     124  const boost::filesystem::wpath & path; 
     125  const find_options options(...); 
     126  file_filter filter(...); 
     127  std::list<file_item> files; 
    90128 
    91 struct get_size : public baseFinderFunction 
    92 { 
    93   get_size() : size(0) { } 
    94   result_type operator()(argument_type ffd) { 
    95     if (!file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes)) { 
    96       size += (ffd.wfd.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)ffd.wfd.nFileSizeLow; 
    97     } 
    98     return true; 
    99   } 
    100   inline unsigned long long getSize() { 
    101     return size; 
    102   } 
    103   inline void setError(error_reporter *errors, std::wstring msg) { 
    104     if (errors != NULL) 
    105       errors->report_error(msg); 
    106   } 
    107 private:   
    108   unsigned long long size; 
    109 }; 
    110129 
    111 template <class finder_function> 
    112 void recursive_scan(std::wstring dir, std::wstring pattern, int current_level, int max_level, finder_function & f, error_reporter * errors) { 
    113   if ((max_level != -1) && (current_level > max_level)) 
    114     return; 
    115   WIN32_FIND_DATA wfd; 
    116130 
    117   DWORD fileAttr = GetFileAttributes(dir.c_str()); 
    118   NSC_DEBUG_MSG_STD(_T("Input is: ") + dir + _T(" / ") + strEx::ihextos(fileAttr)); 
    119  
    120   if (!file_helpers::checks::is_directory(fileAttr)) { 
    121     NSC_DEBUG_MSG_STD(_T("Found a file dont do recursive scan: ") + dir); 
    122     // It is a file check it an return (dont check recursivly) 
    123     pattern_type single_path = split_path_ex(dir); 
    124     NSC_DEBUG_MSG_STD(_T("Path is: ") + single_path.first); 
    125     HANDLE hFind = FindFirstFile(dir.c_str(), &wfd); 
    126     if (hFind != INVALID_HANDLE_VALUE) { 
    127       f(file_finder_data(wfd, single_path.first, errors)); 
    128       FindClose(hFind); 
    129     } 
    130     return; 
    131   } 
    132   std::wstring file_pattern = dir + _T("\\") + pattern; 
    133   NSC_DEBUG_MSG_STD(_T("File pattern: ") + file_pattern); 
    134   HANDLE hFind = FindFirstFile(file_pattern.c_str(), &wfd); 
    135   if (hFind != INVALID_HANDLE_VALUE) { 
    136     do { 
    137       if (!f(file_finder_data(wfd, dir, errors))) 
    138         break; 
    139     } while (FindNextFile(hFind, &wfd)); 
    140     FindClose(hFind); 
    141   } 
    142   std::wstring dir_pattern = dir + _T("\\*.*"); 
    143   NSC_DEBUG_MSG_STD(_T("File pattern: ") + dir_pattern); 
    144   hFind = FindFirstFile(dir_pattern.c_str(), &wfd); 
    145   if (hFind != INVALID_HANDLE_VALUE) { 
    146     do { 
    147       if (file_helpers::checks::is_directory(wfd.dwFileAttributes)) { 
    148         if ( (wcscmp(wfd.cFileName, _T(".")) != 0) && (wcscmp(wfd.cFileName, _T("..")) != 0) ) 
    149           recursive_scan<finder_function>(dir + _T("\\") + wfd.cFileName, pattern, current_level+1, max_level, f, errors, debug); 
    150       } 
    151     } while (FindNextFile(hFind, &wfd)); 
    152     FindClose(hFind); 
    153   } 
     131  find_files(path, options, filter, files); 
    154132} 
    155133 
    156134 
     135void CheckDisk::handleCommand(std::wstring command, PluginCommand::Request *request, PluginCommand::Response *response) { 
     136  if (command == _T("check_file")) 
     137    check_file(request, response); 
    157138 
    158 NSCAPI::nagiosReturn CheckDisk::CheckDriveSize(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    159   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    160   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    161   if (args.empty()) { 
    162     message = _T("Missing argument(s)."); 
    163     return NSCAPI::returnCRIT; 
    164   } 
    165  
    166   DriveContainer tmpObject; 
    167   bool bFilter = false; 
    168   bool bFilterRemote = false; 
    169   bool bFilterRemovable = false; 
    170   bool bFilterFixed = false; 
    171   bool bFilterCDROM = false; 
    172   bool bFilterNoRootDir = false; 
    173   bool bCheckAllDrives = false; 
    174   bool bCheckAllOthers = false; 
    175   bool bNSClient = false; 
    176   bool bPerfData = true; 
    177   std::list<DriveContainer> drives; 
    178   std::wstring strCheckAll; 
    179  
    180   MAP_OPTIONS_BEGIN(args) 
    181     MAP_OPTIONS_STR_AND(_T("Drive"), tmpObject.data, drives.push_back(tmpObject)) 
    182     MAP_OPTIONS_DISK_ALL(tmpObject, _T(""), _T("Free"), _T("Used")) 
    183     MAP_OPTIONS_SHOWALL(tmpObject) 
    184     MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterFixed, _T("FIXED")) 
    185     MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterCDROM, _T("CDROM")) 
    186     MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterRemovable, _T("REMOVABLE")) 
    187     MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterRemote, _T("REMOTE")) 
    188     MAP_OPTIONS_BOOL_VALUE(_T("FilterType"), bFilterNoRootDir, _T("NO_ROOT_DIR")) 
    189     MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    190     MAP_OPTIONS_BOOL_TRUE(NSCLIENT, bNSClient) 
    191     //MAP_OPTIONS_BOOL_TRUE(CHECK_ALL, bCheckAll) 
    192     MAP_OPTIONS_STR(CHECK_ALL, strCheckAll) 
    193     MAP_OPTIONS_BOOL_TRUE(CHECK_ALL_OTHERS, bCheckAllOthers) 
    194     MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2) 
    195       else if (p2.first == _T("Drive")) { 
    196         tmpObject.data = p__.second; 
    197         tmpObject.alias = p2.second; 
    198         drives.push_back(tmpObject); 
    199       } 
    200     MAP_OPTIONS_MISSING_EX(p2, message, _T("Unknown argument: ")) 
    201     MAP_OPTIONS_SECONDARY_END() 
    202   MAP_OPTIONS_FALLBACK_AND(tmpObject.data, drives.push_back(tmpObject)) 
    203   MAP_OPTIONS_END() 
    204   bFilter = bFilterFixed || bFilterCDROM  || bFilterRemote || bFilterRemovable; 
    205  
    206   if ((drives.size() == 0) && strCheckAll.empty()) 
    207     bCheckAllDrives = true; 
    208  
    209   if (strCheckAll == _T("volumes")) { 
    210  
    211     DWORD bufSize = GetLogicalDriveStrings(0, NULL)+5; 
    212     TCHAR *buffer = new TCHAR[bufSize+10]; 
    213     if (GetLogicalDriveStrings(bufSize, buffer)>0) { 
    214       while (buffer[0] != 0) { 
    215         std::wstring drv = buffer; 
    216  
    217         UINT drvType = GetDriveType(drv.c_str()); 
    218         if (  
    219           ((!bFilter)&&(drvType == DRIVE_FIXED))  || 
    220           ((bFilter)&&(bFilterFixed)&&(drvType==DRIVE_FIXED)) || 
    221           ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
    222           ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
    223           ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) || 
    224           ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR))  
    225           ) 
    226           drives.push_back(DriveContainer(drv, tmpObject.warn, tmpObject.crit)); 
    227  
    228         buffer = &buffer[drv.size()]; 
    229         buffer++; 
    230       } 
    231     } else { 
    232       NSC_LOG_ERROR_STD(_T("Failed to get buffer size: ") + error::lookup::last_error()); 
    233     } 
    234   } 
    235  
    236   if (bCheckAllDrives) { 
    237     DWORD dwDrives = GetLogicalDrives(); 
    238     int idx = 0; 
    239     while (dwDrives != 0) { 
    240       if (dwDrives & 0x1) { 
    241         std::wstring drv; 
    242         drv += static_cast<TCHAR>('A' + idx); drv += _T(":\\"); 
    243         UINT drvType = GetDriveType(drv.c_str()); 
    244         if ( ((!bFilter)&&(drvType == DRIVE_FIXED))  || 
    245           ((bFilter)&&(bFilterFixed)&&(drvType==DRIVE_FIXED)) || 
    246           ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
    247           ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
    248           ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) || 
    249           ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR))  
    250           ) 
    251           drives.push_back(DriveContainer(drv, tmpObject.warn, tmpObject.crit)); 
    252       } 
    253       idx++; 
    254       dwDrives >>= 1; 
    255     } 
    256   } 
    257   if (bCheckAllOthers) { 
    258     std::list<DriveContainer> checkdrives; 
    259     DWORD dwDrives = GetLogicalDrives(); 
    260     int idx = 0; 
    261     while (dwDrives != 0) { 
    262       if (dwDrives & 0x1) { 
    263         std::wstring drv; 
    264         drv += static_cast<TCHAR>('A' + idx); drv += _T(":\\"); 
    265         UINT drvType = GetDriveType(drv.c_str()); 
    266         if ( ((!bFilter)&&(drvType == DRIVE_FIXED))  || 
    267           ((bFilter)&&(bFilterFixed)&&(drvType==DRIVE_FIXED)) || 
    268           ((bFilter)&&(bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
    269           ((bFilter)&&(bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
    270           ((bFilter)&&(bFilterRemovable)&&(drvType==DRIVE_REMOVABLE)) || 
    271           ((bFilter)&&(bFilterNoRootDir)&&(drvType==DRIVE_NO_ROOT_DIR))  
    272           )   
    273         { 
    274           bool bFound = false; 
    275           for (std::list<DriveContainer>::const_iterator pit = drives.begin();pit!=drives.end();++pit) { 
    276             DriveContainer drive = (*pit); 
    277             if (_wcsicmp(drive.data.substr(0,1).c_str(), drv.substr(0,1).c_str())==0) 
    278               bFound = true; 
    279           } 
    280           if (!bFound) 
    281             checkdrives.push_back(DriveContainer(drv, tmpObject.warn, tmpObject.crit)); 
    282         } 
    283       } 
    284       idx++; 
    285       dwDrives >>= 1; 
    286     } 
    287     drives = checkdrives; 
    288   } 
    289  
    290  
    291   for (std::list<DriveContainer>::const_iterator pit = drives.begin();pit!=drives.end();++pit) { 
    292     DriveContainer drive = (*pit); 
    293     if (drive.data.length() == 1) 
    294       drive.data += _T(":"); 
    295     drive.perfData = bPerfData; 
    296     UINT drvType = GetDriveType(drive.data.c_str()); 
    297  
    298     if ((!bFilter)&&!((drvType == DRIVE_FIXED)||(drvType == DRIVE_NO_ROOT_DIR))) { 
    299       message = _T("UNKNOWN: Drive is not a fixed drive: ") + drive.getAlias() + _T(" (it is a ") + get_filter(drvType) + _T(" drive)"); 
    300       return NSCAPI::returnUNKNOWN; 
    301     } else if ( (bFilter)&& 
    302       ( 
    303       ((!bFilterFixed)&&((drvType==DRIVE_FIXED)||(drvType==DRIVE_NO_ROOT_DIR))) || 
    304       ((!bFilterCDROM)&&(drvType==DRIVE_CDROM)) || 
    305       ((!bFilterRemote)&&(drvType==DRIVE_REMOTE)) || 
    306       ((!bFilterRemovable)&&(drvType==DRIVE_REMOVABLE))  
    307       )) { 
    308         message = _T("UNKNOWN: Drive does not match the current filter: ") + drive.getAlias() + _T(" (add FilterType=") + get_filter(drvType) + _T(" to check this drive)"); 
    309         return NSCAPI::returnUNKNOWN; 
    310     } 
    311  
    312     ULARGE_INTEGER freeBytesAvailableToCaller; 
    313     ULARGE_INTEGER totalNumberOfBytes; 
    314     ULARGE_INTEGER totalNumberOfFreeBytes; 
    315     if (!GetDiskFreeSpaceEx(drive.data.c_str(), &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes)) { 
    316       message = _T("CRITICAL: Could not get free space for: ") + drive.getAlias() + _T(" ") + drive.data + _T(" reason: ") + error::lookup::last_error(); 
    317       return NSCAPI::returnCRIT; 
    318     } 
    319  
    320     if (bNSClient) { 
    321       if (!message.empty()) 
    322         message += _T("&"); 
    323       message += strEx::itos(totalNumberOfFreeBytes.QuadPart); 
    324       message += _T("&"); 
    325       message += strEx::itos(totalNumberOfBytes.QuadPart); 
    326     } else { 
    327       checkHolders::PercentageValueType<checkHolders::disk_size_type, checkHolders::disk_size_type> value; 
    328       std::wstring tstr; 
    329       value.value = totalNumberOfBytes.QuadPart-totalNumberOfFreeBytes.QuadPart; 
    330       value.total = totalNumberOfBytes.QuadPart; 
    331       drive.setDefault(tmpObject); 
    332       drive.runCheck(value, returnCode, message, perf); 
    333     } 
    334   } 
    335   if (message.empty()) 
    336     message = _T("OK: All drives within bounds."); 
    337   else if (!bNSClient) 
    338     message = NSCHelper::translateReturn(returnCode) + _T(": ") + message; 
    339   return returnCode; 
    340139} 
    341  
    342 std::wstring CheckDisk::get_filter(unsigned int drvType) { 
    343   if (drvType==DRIVE_FIXED) 
    344     return _T("FIXED"); 
    345   if (drvType==DRIVE_NO_ROOT_DIR) 
    346     return _T("NO_ROOT_DIR"); 
    347   if (drvType==DRIVE_CDROM) 
    348     return _T("CDROM"); 
    349   if (drvType==DRIVE_REMOTE) 
    350     return _T("REMOTE"); 
    351   if (drvType==DRIVE_REMOVABLE) 
    352     return _T("REMOVABLE"); 
    353   return _T("unknown: ") + strEx::itos(drvType); 
    354 } 
    355 4 
    356  
    357  
    358 NSCAPI::nagiosReturn CheckDisk::CheckFileSize(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    359   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    360   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    361   bool bPerfData = true; 
    362   bool debug = false; 
    363   if (args.empty()) { 
    364     message = _T("Missing argument(s)."); 
    365     return NSCAPI::returnUNKNOWN; 
    366   } 
    367   PathContainer tmpObject; 
    368   std::list<PathContainer> paths; 
    369  
    370   MAP_OPTIONS_BEGIN(args) 
    371     MAP_OPTIONS_STR_AND(_T("File"), tmpObject.data, paths.push_back(tmpObject)) 
    372     MAP_OPTIONS_SHOWALL(tmpObject) 
    373     MAP_OPTIONS_STR(_T("MaxWarn"), tmpObject.warn.max) 
    374     MAP_OPTIONS_STR(_T("MinWarn"), tmpObject.warn.min) 
    375     MAP_OPTIONS_STR(_T("MaxCrit"), tmpObject.crit.max) 
    376     MAP_OPTIONS_STR(_T("MinCrit"), tmpObject.crit.min) 
    377     MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    378     MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    379     MAP_OPTIONS_SECONDARY_BEGIN(_T(":"), p2) 
    380     else if (p2.first == _T("File")) { 
    381       tmpObject.data = p__.second; 
    382       tmpObject.alias = p2.second; 
    383       paths.push_back(tmpObject); 
    384     } 
    385     MAP_OPTIONS_MISSING_EX(p2, message, _T("Unknown argument: ")) 
    386     MAP_OPTIONS_SECONDARY_END() 
    387     MAP_OPTIONS_MISSING(message, _T("Unknown argument: ")) 
    388   MAP_OPTIONS_END() 
    389  
    390   for (std::list<PathContainer>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) { 
    391     PathContainer path = (*pit); 
    392     std::wstring tstr; 
    393     std::wstring sName = path.getAlias(); 
    394     get_size sizeFinder; 
    395     NSC_error errors; 
    396     pattern_type splitpath = split_pattern(path.data); 
    397     recursive_scan<get_size>(splitpath.first, splitpath.second, -1, -1, sizeFinder, &errors, debug); 
    398     if (sizeFinder.hasError()) { 
    399       message = _T("File not found check log for details"); 
    400       return NSCAPI::returnUNKNOWN; 
    401     } 
    402     path.setDefault(tmpObject); 
    403     path.perfData = bPerfData; 
    404  
    405     checkHolders::disk_size_type size = sizeFinder.getSize(); 
    406     path.runCheck(size, returnCode, message, perf); 
    407   } 
    408   if (message.empty()) 
    409     message = _T("OK all file sizes are within bounds."); 
    410   else 
    411     message = NSCHelper::translateReturn(returnCode) + _T(": ") + message; 
    412   return returnCode; 
    413 } 
    414  
    415  
    416 struct file_info { 
    417  
    418   std::wstring error; 
    419   //bool has_error; 
    420  
    421   static file_info get(__int64 now, std::wstring path, std::wstring file) { 
    422     return get_2(now, path, file); 
    423   } 
    424   static file_info get(__int64 now, file_finder_data data) { 
    425     return file_info(now, data.wfd, data.path, data.wfd.cFileName); 
    426   } 
    427  
    428   static file_info get_2(__int64 now, std::wstring path, std::wstring file) { 
    429     WIN32_FILE_ATTRIBUTE_DATA data; 
    430     if (!GetFileAttributesEx((path + _T("\\") + file).c_str(), GetFileExInfoStandard, reinterpret_cast<LPVOID>(&data))) { 
    431       file_info ret; 
    432       ret.error = _T("Could not open file (2) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error(); 
    433       return ret; 
    434     } 
    435     return file_info(now, data, path, file); 
    436   } 
    437   static file_info get_1(__int64 now, std::wstring path, std::wstring file) { 
    438     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); 
    439     if (hFile == INVALID_HANDLE_VALUE) { 
    440       file_info ret; 
    441       ret.error = _T("Could not open file (1) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error(); 
    442       return ret; 
    443     } 
    444     BY_HANDLE_FILE_INFORMATION _info; 
    445     GetFileInformationByHandle(hFile, &_info); 
    446     CloseHandle(hFile); 
    447     return file_info(now, _info, path, file); 
    448   } 
    449  
    450   file_info()  
    451     : ullCreationTime(0) 
    452     , ullLastAccessTime(0) 
    453     , ullLastWriteTime(0) 
    454     , ullSize(0) 
    455     , ullNow(0) 
    456     , cached_version(false, _T(""))  
    457     , cached_count(false, 0) 
    458   {} 
    459   file_info(__int64 now, const WIN32_FILE_ATTRIBUTE_DATA info, std::wstring path_, std::wstring filename_)  
    460     : path(path_) 
    461     , filename(filename_) 
    462     , ullCreationTime(0) 
    463     , ullLastAccessTime(0) 
    464     , ullLastWriteTime(0) 
    465     , ullSize(0) 
    466     , ullNow(now) 
    467     , cached_version(false, _T(""))  
    468     , cached_count(false, 0) 
    469   { 
    470     ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
    471     ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
    472     ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime); 
    473     ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
    474   }; 
    475   file_info(__int64 now, const BY_HANDLE_FILE_INFORMATION info, std::wstring path_, std::wstring filename_)  
    476     : path(path_) 
    477     , filename(filename_) 
    478     , ullCreationTime(0) 
    479     , ullLastAccessTime(0) 
    480     , ullLastWriteTime(0) 
    481     , ullSize(0) 
    482     , ullNow(now) 
    483     , cached_version(false, _T(""))  
    484     , cached_count(false, 0) 
    485   { 
    486     ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
    487     ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
    488     ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime); 
    489     ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
    490   }; 
    491   file_info(__int64 now, const WIN32_FIND_DATA info, std::wstring path_, std::wstring filename_)  
    492     : path(path_) 
    493     , filename(filename_) 
    494     , ullCreationTime(0) 
    495     , ullLastAccessTime(0) 
    496     , ullLastWriteTime(0) 
    497     , ullSize(0) 
    498     , ullNow(now) 
    499     , cached_version(false, _T(""))  
    500     , cached_count(false, 0) 
    501   { 
    502   bool has_error; 
    503  
    504   static file_info get(std::wstring path, std::wstring file) { 
    505     return get_2(path, file); 
    506   } 
    507   static file_info get(file_finder_data data) { 
    508     return file_info(data.wfd, data.path, data.wfd.cFileName); 
    509   } 
    510  
    511   static file_info get_2(std::wstring path, std::wstring file) { 
    512     WIN32_FILE_ATTRIBUTE_DATA data; 
    513     if (!GetFileAttributesEx((path + _T("\\") + file).c_str(), GetFileExInfoStandard, reinterpret_cast<LPVOID>(&data))) { 
    514       file_info ret; 
    515       ret.error = _T("Could not open file (2) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error(); 
    516       return ret; 
    517     } 
    518     return file_info(data, path, file); 
    519   } 
    520   static file_info get_1(std::wstring path, std::wstring file) { 
    521     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); 
    522     if (hFile == INVALID_HANDLE_VALUE) { 
    523       file_info ret; 
    524       ret.error = _T("Could not open file (1) ") + path + _T("\\") + file + _T(": ") + error::lookup::last_error(); 
    525       return ret; 
    526     } 
    527     BY_HANDLE_FILE_INFORMATION _info; 
    528     GetFileInformationByHandle(hFile, &_info); 
    529     CloseHandle(hFile); 
    530     return file_info(_info, path, file); 
    531   } 
    532  
    533   file_info()  
    534     : ullCreationTime(0) 
    535     , ullLastAccessTime(0) 
    536     , ullLastWriteTime(0) 
    537     , ullSize(0) 
    538     , cached_version(false, _T(""))  
    539     , cached_count(false, 0) 
    540   {} 
    541   file_info(const WIN32_FILE_ATTRIBUTE_DATA info, std::wstring path_, std::wstring filename_)  
    542     : path(path_) 
    543     , filename(filename_) 
    544     , ullCreationTime(0) 
    545     , ullLastAccessTime(0) 
    546     , ullLastWriteTime(0) 
    547     , ullSize(0) 
    548     , cached_version(false, _T(""))  
    549     , cached_count(false, 0) 
    550   { 
    551     ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
    552     ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
    553     ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime); 
    554     ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
    555   }; 
    556   file_info(const BY_HANDLE_FILE_INFORMATION info, std::wstring path_, std::wstring filename_)  
    557     : path(path_) 
    558     , filename(filename_) 
    559     , ullCreationTime(0) 
    560     , ullLastAccessTime(0) 
    561     , ullLastWriteTime(0) 
    562     , ullSize(0) 
    563     , cached_version(false, _T(""))  
    564     , cached_count(false, 0) 
    565   { 
    566     ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
    567     ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
    568     ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime); 
    569     ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
    570   }; 
    571   file_info(const WIN32_FIND_DATA info, std::wstring path_, std::wstring filename_)  
    572     : path(path_) 
    573     , filename(filename_) 
    574     , ullCreationTime(0) 
    575     , ullLastAccessTime(0) 
    576     , ullLastWriteTime(0) 
    577     , ullSize(0) 
    578     , cached_version(false, _T(""))  
    579     , cached_count(false, 0) 
    580   { 
    581     ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow); 
    582     ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime); 
    583     ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime); 
    584     ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime); 
    585   }; 
    586   file_info(__int64 now, std::wstring path_, std::wstring filename_)  
    587     : path(path_) 
    588     , filename(filename_) 
    589     , ullCreationTime(0) 
    590     , ullLastAccessTime(0) 
    591     , ullLastWriteTime(0) 
    592     , ullSize(0) 
    593     , ullNow(now) 
    594     , cached_version(false, _T(""))  
    595     , cached_count(false, 0) 
    596   { 
    597   }; 
    598   file_info(std::wstring path_, std::wstring filename_)  
    599     : path(path_) 
    600     , filename(filename_) 
    601     , ullCreationTime(0) 
    602     , ullLastAccessTime(0) 
    603     , ullLastWriteTime(0) 
    604     , ullSize(0) 
    605     , cached_version(false, _T(""))  
    606     , cached_count(false, 0) 
    607   { 
    608   }; 
    609  
    610   unsigned long long ullSize; 
    611   __int64 ullCreationTime; 
    612   __int64 ullLastAccessTime; 
    613   __int64 ullLastWriteTime; 
    614   __int64 ullNow; 
    615   std::wstring filename; 
    616   std::wstring path; 
    617   std::pair<bool,std::wstring> cached_version; 
    618   std::pair<bool,unsigned long> cached_count; 
    619  
    620   static const __int64 MSECS_TO_100NS = 10000; 
    621  
    622   __int64 get_creation() { 
    623     return (ullNow-ullCreationTime)/MSECS_TO_100NS; 
    624   } 
    625   __int64 get_access() { 
    626     return (ullNow-ullLastAccessTime)/MSECS_TO_100NS; 
    627   } 
    628   __int64 get_write() { 
    629     return (ullNow-ullLastWriteTime)/MSECS_TO_100NS; 
    630   } 
    631   std::wstring render(std::wstring syntax) { 
    632     strEx::replace(syntax, _T("%path%"), path); 
    633     strEx::replace(syntax, _T("%filename%"), filename); 
    634     strEx::replace(syntax, _T("%creation%"), strEx::format_filetime(ullCreationTime, DATE_FORMAT)); 
    635     strEx::replace(syntax, _T("%access%"), strEx::format_filetime(ullLastAccessTime, DATE_FORMAT)); 
    636     strEx::replace(syntax, _T("%write%"), strEx::format_filetime(ullLastWriteTime, DATE_FORMAT)); 
    637     strEx::replace(syntax, _T("%creation-raw%"), strEx::itos(ullCreationTime)); 
    638     strEx::replace(syntax, _T("%access-raw%"), strEx::itos(ullLastAccessTime)); 
    639     strEx::replace(syntax, _T("%write-raw%"), strEx::itos(ullLastWriteTime)); 
    640     strEx::replace(syntax, _T("%now-raw%"), strEx::itos(ullNow)); 
    641140/* 
    642     strEx::replace(syntax, _T("%creation-d%"), strEx::format_filetime(ullCreationTime, DATE_FORMAT)); 
    643     strEx::replace(syntax, _T("%access-d%"), strEx::format_filetime(ullLastAccessTime, DATE_FORMAT)); 
    644     strEx::replace(syntax, _T("%write-d%"), strEx::format_filetime(ullLastWriteTime, DATE_FORMAT)); 
    645 */ 
    646     strEx::replace(syntax, _T("%size%"), strEx::itos_as_BKMG(ullSize)); 
    647     if (cached_version.first) 
    648       strEx::replace(syntax, _T("%version%"), cached_version.second); 
    649     if (cached_count.first) 
    650       strEx::replace(syntax, _T("%line-count%"), strEx::itos(cached_count.second)); 
    651     return syntax; 
    652   } 
    653  
    654   std::wstring get_version() { 
    655     if (cached_version.first) 
    656       return cached_version.second; 
    657     std::wstring fullpath = path+_T("\\")+filename; 
    658  
    659     DWORD dwDummy; 
    660     DWORD dwFVISize = GetFileVersionInfoSize(fullpath.c_str(),&dwDummy); 
    661     LPBYTE lpVersionInfo = new BYTE[dwFVISize+1]; 
    662     GetFileVersionInfo(fullpath.c_str(),0,dwFVISize,lpVersionInfo); 
    663     UINT uLen; 
    664     VS_FIXEDFILEINFO *lpFfi; 
    665     VerQueryValue( lpVersionInfo , _T("\\") , (LPVOID *)&lpFfi , &uLen ); 
    666     DWORD dwFileVersionMS = lpFfi->dwFileVersionMS; 
    667     DWORD dwFileVersionLS = lpFfi->dwFileVersionLS; 
    668     delete [] lpVersionInfo; 
    669     DWORD dwLeftMost = HIWORD(dwFileVersionMS); 
    670     DWORD dwSecondLeft = LOWORD(dwFileVersionMS); 
    671     DWORD dwSecondRight = HIWORD(dwFileVersionLS); 
    672     DWORD dwRightMost = LOWORD(dwFileVersionLS); 
    673     cached_version.second = strEx::itos(dwLeftMost) + _T(".") + 
    674       strEx::itos(dwSecondLeft) + _T(".") + 
    675       strEx::itos(dwSecondRight) + _T(".") + 
    676       strEx::itos(dwRightMost); 
    677     cached_version.first = true; 
    678     return cached_version.second; 
    679   } 
    680  
    681   unsigned long get_line_count() { 
    682     if (cached_count.first) 
    683       return cached_count.second; 
    684  
    685     unsigned long count = 0; 
    686     std::wstring fullpath = path+_T("\\")+filename; 
    687     FILE * pFile = fopen(strEx::wstring_to_string(fullpath).c_str(),"r");; 
    688     if (pFile==NULL)  
    689       return 0; 
    690     char c; 
    691     do { 
    692       c = fgetc (pFile); 
    693       if (c == '\r') { 
    694         c = fgetc (pFile); 
    695         count++; 
    696       } else if (c == '\n') { 
    697         c = fgetc (pFile); 
    698         count++; 
    699       } 
    700     } while (c != EOF); 
    701     fclose (pFile); 
    702     cached_count.second = count; 
    703     cached_count.first = true; 
    704     return cached_count.second; 
    705   } 
    706 }; 
    707  
    708 struct file_container : public file_info { 
    709   std::wstring error_; 
    710  
    711  
    712   static file_container get(std::wstring file) { 
    713     FILETIME now; 
    714     GetSystemTimeAsFileTime(&now); 
    715     unsigned __int64 nowi64 = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
    716     return get(file, nowi64); 
    717   } 
    718  
    719   static file_container get(std::wstring file, unsigned long long now) { 
    720  
    721     BY_HANDLE_FILE_INFORMATION _info; 
    722  
    723     HANDLE hFile = CreateFile(file.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    724       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    725     if (hFile == INVALID_HANDLE_VALUE) { 
    726       return file_container(now, file, _T("Could not open file: ") + file); 
    727     } 
    728     GetFileInformationByHandle(hFile, &_info); 
    729     CloseHandle(hFile); 
    730     file_container info(now, _info, file); 
    731     //info.ullNow = now; 
    732     return info; 
    733   } 
    734  
    735  
    736   file_container(__int64 now, const BY_HANDLE_FILE_INFORMATION info, std::wstring file) : file_info(now, info, file_helpers::meta::get_path(file), file_helpers::meta::get_filename(file)) {} 
    737   file_container(__int64 now, std::wstring file, std::wstring error) : error_(error), file_info(now, file_helpers::meta::get_path(file), file_helpers::meta::get_filename(file)) {} 
    738  
    739   bool has_errors() { 
    740     return !error_.empty(); 
    741   } 
    742   std::wstring get_error() { 
    743     return error_; 
    744   } 
    745  
    746 }; 
    747 struct file_filter { 
    748   filters::filter_all_numeric<unsigned long long, checkHolders::disk_size_handler<checkHolders::disk_size_type> > size; 
    749   filters::filter_all_times creation; 
    750   filters::filter_all_times accessed; 
    751   filters::filter_all_times written; 
    752   filters::filter_all_strings version; 
    753   filters::filter_all_num_ul line_count; 
    754  
    755   inline bool hasFilter() { 
    756     return size.hasFilter() || creation.hasFilter() ||  
    757       accessed.hasFilter() || written.hasFilter(); 
    758   } 
    759   bool matchFilter(file_info &value) const { 
    760     if ((size.hasFilter())&&(size.matchFilter(value.ullSize))) 
    761       return true; 
    762     else if (creation.hasFilter()&&creation.matchFilter(value.get_creation())) 
    763       return true; 
    764     else if (accessed.hasFilter()&&accessed.matchFilter(value.get_access())) 
    765       return true; 
    766     else if (written.hasFilter()&&written.matchFilter(value.get_write())) 
    767       return true; 
    768     else if ((version.hasFilter())&&(version.matchFilter(value.get_version()))) 
    769       return true; 
    770     else if ((line_count.hasFilter())&&(line_count.matchFilter(value.get_line_count()))) 
    771       return true; 
    772     return false; 
    773   } 
    774  
    775   std::wstring getValue() const { 
    776     if (size.hasFilter()) 
    777       return _T("size: ") + size.getValue(); 
    778     if (creation.hasFilter()) 
    779       return _T("creation: ") + creation.getValue(); 
    780     if (accessed.hasFilter()) 
    781       return _T("accessed: ") + accessed.getValue(); 
    782     if (written.hasFilter()) 
    783       return _T("written: ") + written.getValue(); 
    784     if (version.hasFilter()) 
    785       return _T("written: ") + version.getValue(); 
    786     if (line_count.hasFilter()) 
    787       return _T("written: ") + line_count.getValue(); 
    788     return _T("UNknown..."); 
    789   } 
    790  
    791 }; 
    792  
    793  
    794 struct find_first_file_info : public baseFinderFunction 
    795 { 
    796   file_info info; 
    797   __int64 now_; 
    798 //  std::wstring message; 
    799   find_first_file_info() : now_(0) { 
    800     FILETIME now; 
    801     GetSystemTimeAsFileTime(&now); 
    802     now_ = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
    803   } 
    804   result_type operator()(argument_type ffd) { 
    805     if (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes)) 
    806       return true; 
    807  
    808     file_info info = file_info::get(now_, ffd); 
    809     file_info info = file_info::get(ffd); 
    810     if (!info.error.empty()) { 
    811       setError(ffd.errors, info.error); 
    812       return false; 
    813     } 
    814     return false; 
    815     /* 
    816     BY_HANDLE_FILE_INFORMATION _info; 
    817  
    818     HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    819       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    820     if (hFile == INVALID_HANDLE_VALUE) { 
    821       setError(ffd.errors, _T("Could not open file: ") + ffd.path + _T("\\") + ffd.wfd.cFileName + _T(": ") + error::lookup::last_error()); 
    822       return false; 
    823     } 
    824     GetFileInformationByHandle(hFile, &_info); 
    825     CloseHandle(hFile); 
    826     info = file_info(_info, ffd.path, ffd.wfd.cFileName); 
    827     return false; 
    828     */ 
    829   } 
    830   inline void setError(error_reporter *errors, std::wstring msg) { 
    831     if (errors != NULL) 
    832       errors->report_error(msg); 
    833   } 
    834 }; 
    835  
    836 struct file_filter_function : public baseFinderFunction 
    837 { 
    838   std::list<file_filter> filter_chain; 
    839   bool bFilterAll; 
    840   bool bFilterIn; 
    841   std::wstring message; 
    842   std::wstring syntax; 
    843   std::wstring alias; 
    844   unsigned long long now; 
    845   unsigned int hit_count; 
    846   __int64 now_; 
    847  
    848   file_filter_function() : now_(0), hit_count(0), bFilterIn(true), bFilterAll(true) { 
    849     FILETIME now; 
    850     GetSystemTimeAsFileTime(&now); 
    851     now_ = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
    852   } 
    853   result_type operator()(argument_type ffd) { 
    854     if (file_helpers::checks::is_directory(ffd.wfd.dwFileAttributes)) 
    855       return true; 
    856  
    857     file_info info = file_info::get(ffd); 
    858     if (!info.error.empty()) { 
    859       setError(ffd.errors, info.error); 
    860       return true; 
    861     } 
    862     /* 
    863     BY_HANDLE_FILE_INFORMATION _info; 
    864  
    865     HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    866       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    867     if (hFile == INVALID_HANDLE_VALUE) { 
    868       setError(ffd.errors, _T("Could not open file: ") + ffd.path + _T("\\") + ffd.wfd.cFileName + _T(": ") + error::lookup::last_error()); 
    869       return true; 
    870     } 
    871     GetFileInformationByHandle(hFile, &_info); 
    872     CloseHandle(hFile); 
    873     file_info info(_info, ffd.path, ffd.wfd.cFileName); 
    874     info.ullNow = now; 
    875     */ 
    876  
    877     for (std::list<file_filter>::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) { 
    878       bool bMatch = bFilterAll; 
    879       bool bTmpMatched = (*cit3).matchFilter(info); 
    880       if (bFilterAll) { 
    881         if (!bTmpMatched) { 
    882           bMatch = false; 
    883           break; 
    884         } 
    885       } else { 
    886         if (bTmpMatched) { 
    887           bMatch = true; 
    888           break; 
    889         } 
    890       } 
    891       if ((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch)) { 
    892         strEx::append_list(message, info.render(syntax)); 
    893         if (alias.length() < 16) 
    894           strEx::append_list(alias, info.filename); 
    895         else 
    896           strEx::append_list(alias, std::wstring(_T("..."))); 
    897         hit_count++; 
    898       } 
    899     } 
    900     return true; 
    901   } 
    902   } 
    903   inline void setError(error_reporter *errors, std::wstring msg) { 
    904     if (errors != NULL) 
    905       errors->report_error(msg); 
    906     error = true; 
    907   } 
    908 }; 
    909  
    910  
    911  
    912 struct file_filter_function_ex : public baseFinderFunction 
    913 { 
    914   static const int filter_plus = 1; 
    915   static const int filter_minus = 2; 
    916   static const int filter_normal = 3; 
    917  
    918   typedef std::pair<int,file_filter> filteritem_type; 
    919   typedef std::list<filteritem_type > filterlist_type; 
    920   filterlist_type filter_chain; 
    921   bool bFilterAll; 
    922   bool bFilterIn; 
    923   bool error; 
    924   bool debug_; 
    925   std::wstring message; 
    926   std::wstring syntax; 
    927   //std::wstring alias; 
    928   unsigned long long now; 
    929   unsigned int hit_count; 
    930   unsigned int file_count; 
    931   std::wstring last_error; 
    932   unsigned int error_count; 
    933  
    934   file_filter_function_ex() : hit_count(0), file_count(0), error(false), debug_(false), bFilterIn(true), bFilterAll(true), error_count(0) {} 
    935   result_type operator()(argument_type ffd) { 
    936     if (is_directory(ffd.wfd.dwFileAttributes)) 
    937       return true; 
    938  
    939     file_info info = file_info::get(ffd); 
    940     if (!info.error.empty()) { 
    941       setError(ffd.errors, info.error); 
    942       return true; 
    943     } 
    944     /* 
    945     BY_HANDLE_FILE_INFORMATION _info; 
    946  
    947     HANDLE hFile = CreateFile((ffd.path + _T("\\") + ffd.wfd.cFileName).c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    948       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    949     if (hFile == INVALID_HANDLE_VALUE) { 
    950       setError(ffd.errors, _T("Could not open file: ") + ffd.path + _T("\\") + ffd.wfd.cFileName + _T(": ") + error::lookup::last_error()); 
    951       return true; 
    952     } 
    953     GetFileInformationByHandle(hFile, &_info); 
    954     CloseHandle(hFile); 
    955     file_info info(_info, ffd.path, ffd.wfd.cFileName); 
    956     info.ullNow = now; 
    957     */ 
    958  
    959     bool bMatch = !bFilterIn; 
    960     for (filterlist_type::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) { 
    961       bool bTmpMatched = (*cit3).second.matchFilter(info); 
    962       int mode = (*cit3).first; 
    963  
    964       if ((mode == filter_minus)&&(bTmpMatched)) { 
    965         // a -<filter> hit so thrash item and bail out! 
    966         if (debug_) 
    967           NSC_DEBUG_MSG_STD(_T("Matched: - ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax)); 
    968         bMatch = false; 
    969         break; 
    970       } else if ((mode == filter_plus)&&(!bTmpMatched)) { 
    971         // a +<filter> missed hit so thrash item and bail out! 
    972         if (debug_) 
    973           NSC_DEBUG_MSG_STD(_T("Matched (missed): + ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax)); 
    974         bMatch = false; 
    975         break; 
    976       } else if (bTmpMatched) { 
    977         if (debug_) 
    978           NSC_DEBUG_MSG_STD(_T("Matched: . (contiunue): ") + (*cit3).second.getValue() + _T(" for: ") + info.render(syntax)); 
    979         bMatch = true; 
    980       } 
    981     } 
    982  
    983     //NSC_DEBUG_MSG_STD(_T("result: ") + strEx::itos(bFilterIn) + _T(" -- ") + strEx::itos(bMatch)); 
    984     if ((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch)) { 
    985       strEx::append_list(message, info.render(syntax)); 
    986       /* 
    987       if (alias.length() < 16) 
    988         strEx::append_list(alias, info.filename); 
    989       else 
    990         strEx::append_list(alias, std::wstring(_T("..."))); 
    991         */ 
    992       hit_count++; 
    993     } 
    994     file_count++; 
    995     return true; 
    996   } 
    997   inline const bool hasError() const { 
    998     return error; 
    999   } 
    1000   inline void setError(error_reporter *errors, std::wstring msg) { 
    1001     if (errors != NULL) 
    1002       errors->report_error(msg); 
    1003     last_error = msg; 
    1004     error_count++; 
    1005   } 
    1006  
    1007   std::wstring render(std::wstring syntax) { 
    1008     strEx::replace(syntax, _T("%list%"), message); 
    1009     strEx::replace(syntax, _T("%matches%"), strEx::itos(hit_count)); 
    1010     strEx::replace(syntax, _T("%files%"), strEx::itos(file_count)); 
    1011     return syntax; 
    1012   } 
    1013  
    1014   bool has_filter() { 
    1015     return !filter_chain.empty(); 
    1016   } 
    1017  
    1018 }; 
    1019  
    1020  
    1021 NSCAPI::nagiosReturn CheckDisk::getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    1022   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    1023   std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    1024   typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsUInteger> CheckFileContainer; 
    1025   if (stl_args.empty()) { 
    1026     message = _T("Missing argument(s)."); 
    1027     return NSCAPI::returnUNKNOWN; 
    1028   } 
    1029   std::wstring format = _T("%Y years %m mon %d days %H hours %M min %S sec"); 
    1030   std::wstring path; 
    1031   bool debug = false; 
    1032   MAP_OPTIONS_BEGIN(stl_args) 
    1033     MAP_OPTIONS_STR(_T("path"), path) 
    1034     MAP_OPTIONS_STR(_T("date"), format) 
    1035     MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    1036     MAP_OPTIONS_FALLBACK(format) 
    1037   MAP_OPTIONS_END() 
    1038  
    1039   if (path.empty()) { 
    1040     message = _T("ERROR: no file specified."); 
    1041     return NSCAPI::returnUNKNOWN; 
    1042   } 
    1043  
    1044   NSC_error errors; 
    1045   pattern_type splitpath = split_pattern(path); 
    1046   recursive_scan<find_first_file_info>(splitpath.first, splitpath.second, -1, -1, finder, &errors, debug); 
    1047   if (finder.hasError()) { 
    1048     message = _T("File not found (check log for details)"); 
    1049     return NSCAPI::returnUNKNOWN; 
    1050   } 
    1051   FILETIME now_; 
    1052   GetSystemTimeAsFileTime(&now_); 
    1053   unsigned long long now = ((now_.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now_.dwLowDateTime); 
    1054   time_t value = (now-finder.info.ullLastWriteTime)/10000000; 
    1055   message = to_wstring(value/60) + _T("&") + strEx::format_time_delta(gmtime(&value), format); 
    1056   return NSCAPI::returnOK; 
    1057 } 
    1058  
    1059  
    1060 NSCAPI::nagiosReturn CheckDisk::CheckFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    1061   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    1062   std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    1063   typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsUInteger> CheckFileContainer; 
    1064   if (stl_args.empty()) { 
    1065     message = _T("Missing argument(s)."); 
    1066     return NSCAPI::returnUNKNOWN; 
    1067   } 
    1068   file_filter_function finder; 
    1069   PathContainer tmpObject; 
    1070   std::list<std::wstring> paths; 
    1071   unsigned int truncate = 0; 
    1072   CheckFileContainer query; 
    1073   std::wstring syntax = _T("%filename%"); 
    1074   std::wstring alias; 
    1075   bool bPerfData = true; 
    1076   unsigned int max_dir_depth = -1; 
    1077   bool debug = false; 
    1078  
    1079   try { 
    1080     MAP_OPTIONS_BEGIN(stl_args) 
    1081       MAP_OPTIONS_NUMERIC_ALL(query, _T("")) 
    1082       MAP_OPTIONS_STR2INT(_T("truncate"), truncate) 
    1083       MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    1084       MAP_OPTIONS_STR(_T("syntax"), syntax) 
    1085       MAP_OPTIONS_PUSH(_T("path"), paths) 
    1086       MAP_OPTIONS_STR(_T("alias"), alias) 
    1087       MAP_OPTIONS_STR2INT(_T("max-dir-depth"), max_dir_depth) 
    1088       MAP_OPTIONS_PUSH(_T("file"), paths) 
    1089       MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    1090       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out")) 
    1091       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterAll, _T("all"), _T("any")) 
    1092       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-size"), size, finder.filter_chain) 
    1093       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-creation"), creation, finder.filter_chain) 
    1094       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-written"), written, finder.filter_chain) 
    1095       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-accessed"), accessed, finder.filter_chain) 
    1096       MAP_OPTIONS_MISSING(message, _T("Unknown argument: ")) 
    1097       MAP_OPTIONS_END() 
    1098   } catch (filters::parse_exception e) { 
    1099     message = e.getMessage(); 
    1100     return NSCAPI::returnUNKNOWN; 
    1101   } catch (filters::filter_exception e) { 
    1102     message = e.getMessage(); 
    1103     return NSCAPI::returnUNKNOWN; 
    1104   } 
    1105   finder.syntax = syntax; 
    1106   NSC_error errors; 
    1107   for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) { 
    1108     pattern_type path = split_pattern(*pit); 
    1109     recursive_scan<file_filter_function>(path.first, path.second, 0, max_dir_depth, finder, &errors, debug); 
    1110     if (errors.has_error()) { 
    1111       if (show_errors_) 
    1112         message = errors.get_error(); 
    1113       else 
    1114         message = _T("Check contains error. Check log for details (or enable show_errors in nsc.ini)"); 
    1115       return NSCAPI::returnUNKNOWN; 
    1116     } 
    1117   } 
    1118   message = finder.message; 
    1119   if (!alias.empty()) 
    1120     query.alias = alias; 
    1121   else 
    1122     query.alias = finder.alias; 
    1123   if (query.alias.empty()) 
    1124     query.alias = _T("no files found"); 
    1125   query.runCheck(finder.hit_count, returnCode, message, perf); 
    1126   if ((truncate > 0) && (message.length() > (truncate-4))) 
    1127     message = message.substr(0, truncate-4) + _T("..."); 
    1128   if (message.empty()) 
    1129     message = _T("CheckFile ok"); 
    1130   return returnCode; 
    1131 } 
    1132  
    1133 #define MAP_FILTER(value, obj) \ 
    1134     else if (p__.first == _T("filter+"##value)) { file_filter filter; filter.obj = p__.second; \ 
    1135       finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_plus, filter)); } \ 
    1136     else if (p__.first == _T("filter-"##value)) { file_filter filter; filter.obj = p__.second; \ 
    1137       finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_minus, filter)); } \ 
    1138     else if (p__.first == _T("filter."##value)) { file_filter filter; filter.obj = p__.second; \ 
    1139       finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_normal, filter)); } 
    1140  
    1141 NSCAPI::nagiosReturn CheckDisk::CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    1142   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    1143   std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    1144   typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsUInteger> CheckFileContainer; 
    1145   typedef std::pair<int,file_filter> filteritem_type; 
    1146   typedef std::list<filteritem_type > filterlist_type; 
    1147   if (stl_args.empty()) { 
    1148     message = _T("Missing argument(s)."); 
    1149     return NSCAPI::returnUNKNOWN; 
    1150   } 
    1151   file_filter_function_ex finder; 
    1152   PathContainer tmpObject; 
    1153   std::list<std::wstring> paths; 
    1154   unsigned int truncate = 0; 
    1155   CheckFileContainer query; 
    1156   std::wstring syntax = _T("%filename%"); 
    1157   std::wstring masterSyntax = _T("%list%"); 
    1158   std::wstring alias; 
    1159   std::wstring pattern = _T("*.*"); 
    1160   bool bPerfData = true; 
    1161   int max_dir_depth = -1; 
    1162   bool debug = false; 
    1163   bool ignoreError = false; 
    1164  
    1165   try { 
    1166     MAP_OPTIONS_BEGIN(stl_args) 
    1167       MAP_OPTIONS_NUMERIC_ALL(query, _T("")) 
    1168       MAP_OPTIONS_STR2INT(_T("truncate"), truncate) 
    1169       MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    1170       MAP_OPTIONS_STR(_T("syntax"), syntax) 
    1171       MAP_OPTIONS_STR(_T("master-syntax"), masterSyntax) 
    1172       MAP_OPTIONS_PUSH(_T("path"), paths) 
    1173       MAP_OPTIONS_STR(_T("pattern"), pattern) 
    1174       MAP_OPTIONS_STR(_T("alias"), alias) 
    1175       MAP_OPTIONS_PUSH(_T("file"), paths) 
    1176       MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    1177       MAP_OPTIONS_BOOL_TRUE(_T("ignore-errors"), ignoreError) 
    1178       MAP_OPTIONS_STR2INT(_T("max-dir-depth"), max_dir_depth) 
    1179       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out")) 
    1180       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterAll, _T("all"), _T("any")) 
    1181       /* 
    1182       MAP_OPTIONS_MISSING(message, _T("Unknown argument: ")) 
    1183       MAP_OPTIONS_END() 
    1184   } catch (filters::parse_exception e) { 
    1185     message = e.getMessage(); 
    1186     return NSCAPI::returnUNKNOWN; 
    1187   } catch (filters::filter_exception e) { 
    1188     message = e.getMessage(); 
    1189     return NSCAPI::returnUNKNOWN; 
    1190   } 
    1191   FILETIME now; 
    1192   GetSystemTimeAsFileTime(&now); 
    1193   finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
    1194   finder.syntax = syntax; 
    1195   NSC_error errors; 
    1196   for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) { 
    1197     pattern_type path = split_pattern(*pit); 
    1198     recursive_scan<file_filter_function>(path.first, path.second, 0, max_dir_depth, finder, &errors, debug); 
    1199     if (finder.hasError()) { 
    1200       message = _T("File not found: ") + (*pit) + _T(" check log for details."); 
    1201       return NSCAPI::returnUNKNOWN; 
    1202     } 
    1203   } 
    1204   message = finder.message; 
    1205   if (finder.error) 
    1206     return NSCAPI::returnUNKNOWN; 
    1207   if (!alias.empty()) 
    1208     query.alias = alias; 
    1209   else 
    1210     query.alias = finder.alias; 
    1211   if (query.alias.empty()) 
    1212     query.alias = _T("no files found"); 
    1213   query.runCheck(finder.hit_count, returnCode, message, perf); 
    1214   if ((truncate > 0) && (message.length() > (truncate-4))) 
    1215     message = message.substr(0, truncate-4) + _T("..."); 
    1216   if (message.empty()) 
    1217     message = _T("CheckFile ok"); 
    1218   return returnCode; 
    1219 } 
    1220  
    1221 #define MAP_FILTER(value, obj) \ 
    1222     else if (p__.first == _T("filter+"##value)) { file_filter filter; filter.obj = p__.second; \ 
    1223       finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_plus, filter)); } \ 
    1224     else if (p__.first == _T("filter-"##value)) { file_filter filter; filter.obj = p__.second; \ 
    1225       finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_minus, filter)); } \ 
    1226     else if (p__.first == _T("filter."##value)) { file_filter filter; filter.obj = p__.second; \ 
    1227       finder.filter_chain.push_back(filteritem_type(file_filter_function_ex::filter_normal, filter)); } 
    1228  
    1229 NSCAPI::nagiosReturn CheckDisk::CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    1230   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    1231   std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    1232   typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsUInteger> CheckFileContainer; 
    1233   typedef std::pair<int,file_filter> filteritem_type; 
    1234   typedef std::list<filteritem_type > filterlist_type; 
    1235   if (stl_args.empty()) { 
    1236     message = _T("Missing argument(s)."); 
    1237     return NSCAPI::returnUNKNOWN; 
    1238   } 
    1239   file_filter_function_ex finder; 
    1240   PathContainer tmpObject; 
    1241   std::list<std::wstring> paths; 
    1242   unsigned int truncate = 0; 
    1243   CheckFileContainer query; 
    1244   std::wstring syntax = _T("%filename%"); 
    1245   std::wstring masterSyntax = _T("%list%"); 
    1246   std::wstring alias; 
    1247   std::wstring pattern = _T("*.*"); 
    1248   bool bPerfData = true; 
    1249   int max_dir_depth = -1; 
    1250   bool debug = false; 
    1251   bool ignoreError = false; 
    1252  
    1253   try { 
    1254     MAP_OPTIONS_BEGIN(stl_args) 
    1255       MAP_OPTIONS_NUMERIC_ALL(query, _T("")) 
    1256       MAP_OPTIONS_STR2INT(_T("truncate"), truncate) 
    1257       MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    1258       MAP_OPTIONS_STR(_T("syntax"), syntax) 
    1259       MAP_OPTIONS_STR(_T("master-syntax"), masterSyntax) 
    1260       MAP_OPTIONS_PUSH(_T("path"), paths) 
    1261       MAP_OPTIONS_STR(_T("pattern"), pattern) 
    1262       MAP_OPTIONS_STR(_T("alias"), alias) 
    1263       MAP_OPTIONS_PUSH(_T("file"), paths) 
    1264       MAP_OPTIONS_BOOL_TRUE(_T("debug"), debug) 
    1265       MAP_OPTIONS_BOOL_TRUE(_T("ignore-errors"), ignoreError) 
    1266       MAP_OPTIONS_STR2INT(_T("max-dir-depth"), max_dir_depth) 
    1267       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterIn, _T("in"), _T("out")) 
    1268       MAP_OPTIONS_BOOL_EX(_T("filter"), finder.bFilterAll, _T("all"), _T("any")) 
    1269       /* 
    1270       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-size"), fileSize, finder.filter_chain) 
    1271       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-creation"), fileCreation, finder.filter_chain) 
    1272       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-written"), fileWritten, finder.filter_chain) 
    1273       MAP_OPTIONS_PUSH_WTYPE(file_filter, _T("filter-accessed"), fileAccessed, finder.filter_chain) 
    1274       */ 
    1275  
    1276       MAP_FILTER(_T("size"), size) 
    1277       MAP_FILTER(_T("creation"), creation) 
    1278       MAP_FILTER(_T("written"), written) 
    1279       MAP_FILTER(_T("accessed"), accessed) 
    1280       MAP_FILTER(_T("version"), version) 
    1281       MAP_FILTER(_T("line-count"), line_count) 
    1282 /* 
    1283       MAP_FILTER(_T("filter.size"), size, filter_normal) 
    1284       MAP_FILTER(_T("filter.creation"), creation, filter_normal) 
    1285       MAP_FILTER(_T("filter.written"), written, filter_normal) 
    1286       MAP_FILTER(_T("filter.accessed"), accessed, filter_normal) 
    1287       MAP_FILTER(_T("filter.version"), version, filter_normal) 
    1288  
    1289       MAP_FILTER(_T("filter-size"), size, filter_minus) 
    1290       MAP_FILTER(_T("filter-creation"), creation, filter_minus) 
    1291       MAP_FILTER(_T("filter-written"), written, filter_minus) 
    1292       MAP_FILTER(_T("filter-accessed"), accessed, filter_minus) 
    1293       MAP_FILTER(_T("filter-version"), version, filter_minus) 
    1294 */ 
    1295       MAP_OPTIONS_MISSING(message, _T("Unknown argument: ")) 
    1296       MAP_OPTIONS_END() 
    1297   } catch (filters::parse_exception e) { 
    1298     message = e.getMessage(); 
    1299     return NSCAPI::returnUNKNOWN; 
    1300   } catch (filters::filter_exception e) { 
    1301     message = e.getMessage(); 
    1302     return NSCAPI::returnUNKNOWN; 
    1303   } 
    1304   if (paths.empty()) { 
    1305     message = _T("Missing path argument"); 
    1306     return NSCAPI::returnUNKNOWN; 
    1307   } 
    1308   if (!finder.has_filter()) { 
    1309     message = _T("Missing filter argument"); 
    1310     return NSCAPI::returnUNKNOWN; 
    1311   } 
    1312   FILETIME now; 
    1313   GetSystemTimeAsFileTime(&now); 
    1314   finder.debug_ = debug; 
    1315   finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
    1316   if (debug) 
    1317     NSC_DEBUG_MSG_STD(_T("NOW: ") + strEx::format_filetime(finder.now)); 
    1318   finder.syntax = syntax; 
    1319   NSC_error errors; 
    1320   for (std::list<std::wstring>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) { 
    1321     recursive_scan<file_filter_function_ex>(*pit, pattern, 0, max_dir_depth, finder, &errors, debug); 
    1322     if (!ignoreError && finder.hasError()) { 
    1323       message = _T("Error when scanning: ") + (*pit) + _T(" check log for details (") + strEx::itos(finder.error_count) + _T(": ") + finder.last_error + _T(")"); 
    1324       return NSCAPI::returnUNKNOWN; 
    1325     } 
    1326   } 
    1327   message  = finder.render(masterSyntax); 
    1328   if (!alias.empty()) 
    1329     query.alias = alias; 
    1330   else 
    1331     query.alias = _T("found files"); 
    1332   query.runCheck(finder.hit_count, returnCode, message, perf); 
    1333   if ((truncate > 0) && (message.length() > (truncate-4))) { 
    1334     message = message.substr(0, truncate-4) + _T("..."); 
    1335     //perf = _T(""); 
    1336   } 
    1337   if (message.empty()) 
    1338     message = _T("CheckFile ok"); 
    1339   return returnCode; 
    1340 } 
    1341 struct file_container : public file_info { 
    1342   std::wstring error_; 
    1343  
    1344   static file_container get(std::wstring file, unsigned long long now) { 
    1345  
    1346     BY_HANDLE_FILE_INFORMATION _info; 
    1347  
    1348     HANDLE hFile = CreateFile(file.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 
    1349       0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); 
    1350     if (hFile == INVALID_HANDLE_VALUE) { 
    1351       return file_container(file, _T("Could not open file: ") + file); 
    1352     } 
    1353     GetFileInformationByHandle(hFile, &_info); 
    1354     CloseHandle(hFile); 
    1355     file_container info(_info, file); 
    1356     info.ullNow = now; 
    1357     return info; 
    1358   } 
    1359  
    1360  
    1361   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)) {} 
    1362   file_container(std::wstring file, std::wstring error) : error_(error), file_info(file_helpers::meta::get_path(file), file_helpers::meta::get_filename(file)) {} 
    1363  
    1364   bool has_errors() { 
    1365     return !error_.empty(); 
    1366   } 
    1367   std::wstring get_error() { 
    1368     return error_; 
    1369   } 
    1370  
    1371 }; 
    1372  
    1373 typedef checkHolders::ExactBounds<checkHolders::NumericBounds<checkHolders::disk_size_type, checkHolders::disk_size_handler<checkHolders::disk_size_type> > > ExactBoundsDiscSize; 
    1374  
    1375  
    1376 typedef checkHolders::CheckContainer<checkHolders::ExactBoundsULong> ExactULongContainer; 
    1377 typedef checkHolders::CheckContainer<ExactBoundsDiscSize> DiscSizeContainer; 
    1378 typedef checkHolders::CheckContainer<checkHolders::ExactBoundsTime> DateTimeContainer; 
    1379  
    1380 struct check_file_size : public checkHolders::check_proxy_container<file_container, DiscSizeContainer> { 
    1381   check_file_size() { set_alias(_T("size")); } 
    1382   checkHolders::disk_size_type get_value(file_container &value) { 
    1383     return value.ullSize; 
    1384   } 
    1385 }; 
    1386 struct check_file_line_count : public checkHolders::check_proxy_container<file_container, ExactULongContainer> { 
    1387   check_file_line_count() { set_alias(_T("line-count")); } 
    1388   unsigned long get_value(file_container &value) { 
    1389     return value.get_line_count(); 
    1390   } 
    1391 }; 
    1392 struct check_file_dates : public checkHolders::check_proxy_container<file_container, DateTimeContainer> { 
    1393   enum type_type { 
    1394     date_access, date_creation, date_written 
    1395   } ; 
    1396   type_type type_; 
    1397   check_file_dates(type_type type) : type_(type)  
    1398   {  
    1399     if (type_ == date_creation) 
    1400       set_alias(_T("creation"));  
    1401     else if (type_ == date_access) 
    1402       set_alias(_T("access"));  
    1403     else if (type_ == date_written) 
    1404       set_alias(_T("written"));  
    1405     else 
    1406       set_alias(_T("unknown date type"));  
    1407   } 
    1408   unsigned long long get_value(file_container &value) { 
    1409     if (type_ == date_creation) 
    1410       return value.ullCreationTime; 
    1411     if (type_ == date_access) 
    1412       return value.ullLastAccessTime; 
    1413     if (type_ == date_written) 
    1414       return value.ullLastWriteTime; 
    1415     return -1; 
    1416   } 
    1417 }; 
    1418  
    1419 typedef checkHolders::check_multi_container<file_container> check_file_multi; 
    1420 struct check_file_factories { 
    1421   static checkHolders::check_proxy_interface<file_container>* size() { 
    1422     return new check_file_size(); 
    1423   } 
    1424   static checkHolders::check_proxy_interface<file_container>* line_count() { 
    1425     return new check_file_line_count(); 
    1426   } 
    1427   static checkHolders::check_proxy_interface<file_container>* access() { 
    1428     return new check_file_dates(check_file_dates::date_access); 
    1429   } 
    1430   static checkHolders::check_proxy_interface<file_container>* creation() { 
    1431     return new check_file_dates(check_file_dates::date_creation); 
    1432   } 
    1433   static checkHolders::check_proxy_interface<file_container>* written() { 
    1434     return new check_file_dates(check_file_dates::date_written); 
    1435   } 
    1436 }; 
    1437  
    1438 #define MAP_FACTORY_PB(value, obj) \ 
    1439     else if ((p__.first == _T("check")) && (p__.second == ##value)) { checker.add_check(check_file_factories::obj()); } 
    1440  
    1441  
    1442 NSCAPI::nagiosReturn CheckDisk::CheckSingleFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
    1443   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    1444   std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    1445   check_file_multi checker; 
    1446   typedef std::pair<int,file_filter> filteritem_type; 
    1447   typedef std::list<filteritem_type > filterlist_type; 
    1448   if (stl_args.empty()) { 
    1449     message = _T("Missing argument(s)."); 
    1450     return NSCAPI::returnUNKNOWN; 
    1451   } 
    1452   std::list<std::wstring> files; 
    1453   unsigned int truncate = 0; 
    1454   std::wstring syntax = _T("%filename%"); 
    1455   std::wstring alias; 
    1456   bool bPerfData = true; 
    1457  
    1458   try { 
    1459     MAP_OPTIONS_BEGIN(stl_args) 
    1460       //MAP_OPTIONS_NUMERIC_ALL(query, _T("")) 
    1461       MAP_OPTIONS_STR2INT(_T("truncate"), truncate) 
    1462       MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData) 
    1463       MAP_OPTIONS_STR(_T("syntax"), syntax) 
    1464       MAP_OPTIONS_STR(_T("alias"), alias) 
    1465       MAP_OPTIONS_PUSH(_T("file"), files) 
    1466       MAP_OPTIONS_EXACT_NUMERIC_ALL_MULTI(checker, _T("")) 
    1467       MAP_FACTORY_PB(_T("size"), size) 
    1468       MAP_FACTORY_PB(_T("line-count"), line_count) 
    1469       MAP_FACTORY_PB(_T("creation"), creation) 
    1470       MAP_FACTORY_PB(_T("access"), access) 
    1471       MAP_FACTORY_PB(_T("written"), written) 
    1472       /* 
    1473       MAP_FILTER(_T("creation"), creation) 
    1474       MAP_FILTER(_T("written"), written) 
    1475       MAP_FILTER(_T("accessed"), accessed) 
    1476       MAP_FILTER(_T("version"), version) 
    1477       MAP_FILTER(_T("line-count"), line_count) 
    1478       */ 
    1479       MAP_OPTIONS_MISSING(message, _T("Unknown argument: ")) 
    1480       MAP_OPTIONS_END() 
    1481   } catch (filters::parse_exception e) { 
    1482     message = e.getMessage(); 
    1483     return NSCAPI::returnUNKNOWN; 
    1484   } catch (filters::filter_exception e) { 
    1485     message = e.getMessage(); 
    1486     return NSCAPI::returnUNKNOWN; 
    1487   } 
    1488   FILETIME now; 
    1489   GetSystemTimeAsFileTime(&now); 
    1490   unsigned __int64 nowi64 = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime); 
    1491   //finder.syntax = syntax; 
    1492   for (std::list<std::wstring>::const_iterator pit = files.begin(); pit != files.end(); ++pit) { 
    1493     file_container info = file_container::get(*pit, nowi64); 
    1494     checker.alias = info.render(syntax); 
    1495     checker.runCheck(info, returnCode, message, perf); 
    1496   } 
    1497   if ((truncate > 0) && (message.length() > (truncate-4))) { 
    1498     message = message.substr(0, truncate-4) + _T("..."); 
    1499     perf = _T(""); 
    1500   } 
    1501   if (message.empty()) 
    1502     message = _T("CheckSingleFile ok"); 
    1503   return returnCode; 
    1504 } 
    1505 NSCAPI::nagiosReturn CheckDisk::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) { 
    1506   if (command == _T("CheckFileSize")) { 
    1507     return CheckFileSize(argLen, char_args, msg, perf); 
    1508   } else if (command == _T("CheckDriveSize")) { 
    1509     return CheckDriveSize(argLen, char_args, msg, perf); 
    1510   } else if (command == _T("CheckFile")) { 
    1511     return CheckFile(argLen, char_args, msg, perf); 
    1512   } else if (command == _T("CheckFile2")) { 
    1513     return CheckFile2(argLen, char_args, msg, perf); 
    1514   } else if (command == _T("CheckSingleFile")) { 
    1515     return CheckSingleFile(argLen, char_args, msg, perf); 
    1516   } else if (command == _T("getFileAge")) { 
    1517     return getFileAge(argLen, char_args, msg, perf); 
     141NSCAPI::nagiosReturn CheckDisk::handleCommand(const std::wstring command, std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf) { 
     142  if (command == _T("check_drive")) { 
     143    //return CheckFileSize(argLen, char_args, msg, perf); 
    1518144  }  
    1519145  return NSCAPI::returnIgnored; 
    1520146} 
     147*/ 
    1521148 
    1522  
     149NSC_WRAP_DLL(); 
    1523150NSC_WRAPPERS_MAIN_DEF(gCheckDisk); 
    1524151NSC_WRAPPERS_IGNORE_MSG_DEF(); 

  • trunk/modules/CheckDisk/CheckDisk.h

    r273 r275  
    2525#include <checkHelpers.hpp> 
    2626 
    27 class CheckDisk { 
     27class CheckDisk  : public nscapi::impl::CommandImpl { 
    2828private: 
    2929  bool show_errors_; 
    … …  
    4242    return _T("CheckDisk can check various file and disk related things.\nThe current version has commands to check Size of hard drives and directories."); 
    4343  } 
    44   NSCModuleWrapper::module_version getModuleVersion() { 
    45     NSCModuleWrapper::module_version version = {0, 0, 1 }; 
     44  nscapi::plugin_wrapper::module_version getModuleVersion() { 
     45    nscapi::plugin_wrapper::module_version version = {0, 3, 0 }; 
    4646    return version; 
    4747  } 
    … …  
    5050  bool hasMessageHandler(); 
    5151  std::wstring get_filter(unsigned int drvType); 
    52   NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     52  void handleCommand(PluginCommand::Request *request, PluginCommand::Response *response); 
    5353 
    5454  // Check commands 
    55   NSCAPI::nagiosReturn CheckFileSize(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    56   NSCAPI::nagiosReturn CheckDriveSize(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    57   NSCAPI::nagiosReturn CheckFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    58   NSCAPI::nagiosReturn CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    59   NSCAPI::nagiosReturn getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    60   NSCAPI::nagiosReturn CheckSingleFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     55// NSCAPI::nagiosReturn CheckFileSize(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     56// NSCAPI::nagiosReturn CheckDriveSize(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     57// NSCAPI::nagiosReturn CheckFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     58// NSCAPI::nagiosReturn CheckFile2(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     59// NSCAPI::nagiosReturn getFileAge(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     60// NSCAPI::nagiosReturn CheckSingleFile(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    6161 
    6262private: 

  • trunk/modules/CheckDisk/stdafx.h

    r207 r275  
    2929 
    3030#include <NSCAPI.h> 
    31 #include <NSCHelper.h> 
    32 #include <nsc_module_wrapper.hpp> 
     31#include <NSCAPI.h> 
     32#include <nscapi/plugin.hpp> 
     33//#include <NSCHelper.h> 
     34//#include <nsc_module_wrapper.hpp> 
    3335 
    3436#ifdef MEMCHECK 

  • trunk/modules/CheckHelpers/CheckHelpers.cpp

    r273 r275  
    8686    GET_CORE()->InjectSimpleCommand(new_command, arguments, message, perf); 
    8787    return NSCAPI::returnOK; 
    88   } else if (command == _T("CheckOK")) { 
    89     return checkSimpleStatus(NSCAPI::returnOK, argLen, char_args, msg, perf); 
    90   } else if (command == _T("CheckWARNING")) { 
    91     return checkSimpleStatus(NSCAPI::returnWARN, argLen, char_args, msg, perf); 
    92   } else if (command == _T("CheckCRITICAL")) { 
    93     return checkSimpleStatus(NSCAPI::returnCRIT, argLen, char_args, msg, perf); 
    94   } else if (command == _T("CheckAlwaysCRITICAL")) { 
    95     if (arguments.size() < 2) { 
     88  } else if (command == _T("checkalwayscritical")) { 
     89    if (arguments.size() < 1) { 
    9690      message = _T("ERROR: Missing arguments."); 
    9791      return NSCAPI::returnUNKNOWN; 
Note: See TracChangeset for help on using the changeset viewer.