Changeset 6817602 in nscp

Timestamp:

02/22/06 21:47:57 (7 years ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2, stable

Children:

1b7ae3d

Parents:

89f1a84

Message:

Lots of update (I really should checkin more often :)

Files:

• NSC.dist (modified) (1 diff)
• NSCPlugin.cpp (modified) (4 diffs)
• NSCPlugin.h (modified) (3 diffs)
• NSClient++.cpp (modified) (5 diffs)
• NSClient++.h (modified) (1 diff)
• NSClient++.sln (modified) (2 diffs)
• changelog (modified) (2 diffs)
• docs/CheckDisk/index.html (modified) (1 diff)
• docs/CheckEventLog/index.html (modified) (3 diffs)
• docs/CheckSystem/index.html (modified) (7 diffs)
• docs/welcome.html (modified) (2 diffs)
• include/EnumNtSrv.cpp (modified) (2 diffs)
• include/NSCHelper.cpp (modified) (2 diffs)
• include/NSCHelper.h (modified) (3 diffs)
• include/PDHCounter.h (modified) (1 diff)
• include/ServiceCmd.cpp (modified) (6 diffs)
• include/ServiceCmd.h (modified) (2 diffs)
• include/Settings.h (modified) (7 diffs)
• include/Socket.h (modified) (2 diffs)
• include/checkHelpers.hpp (modified) (13 diffs)
• include/config.h (modified) (1 diff)
• include/filter_framework.hpp (modified) (12 diffs)
• include/strEx.h (modified) (2 diffs)
• include/utils.h (modified) (4 diffs)
• modules/CheckDisk/CheckDisk.cpp (modified) (8 diffs)
• modules/CheckDisk/CheckDisk.h (modified) (1 diff)
• modules/CheckDisk/stdafx.h (modified) (1 diff)
• modules/CheckEventLog/CheckEventLog.cpp (modified) (8 diffs)
• modules/CheckSystem/CheckSystem.cpp (modified) (8 diffs)
• modules/CheckSystem/CheckSystem.h (modified) (2 diffs)
• modules/CheckSystem/PDHCollector.cpp (modified) (2 diffs)
• modules/CheckSystem/PDHCollector.h (modified) (2 diffs)
• modules/FileLogger/FileLogger.cpp (modified) (1 diff)
• modules/NSClientListener/NSClientListener.cpp (modified) (4 diffs)
• modules/SysTray/SysTray.cpp (modified) (4 diffs)
• modules/SysTray/SysTray.def (modified) (1 diff)
• modules/SysTray/SysTray.h (modified) (3 diffs)
• modules/SysTray/SysTray.vcproj (modified) (2 diffs)

NSC.dist

@@ -16 +16 @@
 ;CheckEventLog.dll
 ;CheckHelpers.dll
+;
+; CheckWMI IS AN EXTREM EARLY IDEA SO DONT USE FOR PRODUCTION ENVIROMNEMTS!
+;CheckWMI.dll
 
 [Settings]

NSCPlugin.cpp

@@ -20 +20 @@
   ,fGetConfigurationMeta(NULL)
   ,fGetVersion(NULL)
+  ,fCommandLineExec(NULL)
   ,bLoaded_(false)
 {
@@ -35 +36 @@
   ,fGetConfigurationMeta(NULL)
   ,fGetVersion(NULL)
+  ,fCommandLineExec(NULL)
   ,bLoaded_(false)
 {
@@ -256 +258 @@
 
   fGetConfigurationMeta = (lpGetConfigurationMeta)GetProcAddress(hModule_, "NSGetConfigurationMeta");
+  fCommandLineExec = (lpCommandLineExec)GetProcAddress(hModule_, "NSCommandLineExec");
 }
 
@@ -274 +277 @@
   return fGetConfigurationMeta(buflen, buf)?true:false;
 }
+
+int NSCPlugin::commandLineExec(const char* command, const unsigned int argLen, char **arguments) {
+  if (fCommandLineExec== NULL)
+    throw NSPluginException(file_, "Module does not support CommandLineExec");
+  return fCommandLineExec(command, argLen, arguments);
+}

NSCPlugin.h

@@ -97 +97 @@
   typedef INT (*lpHasMessageHandler)();
   typedef NSCAPI::nagiosReturn (*lpHandleCommand)(const char*,const unsigned int, char**,char*,unsigned int,char *,unsigned int);
+  typedef INT (*lpCommandLineExec)(const char*,const unsigned int,char**);
   typedef INT (*lpHandleMessage)(int,const char*,const int,const char*);
   typedef INT (*lpUnLoadModule)();
@@ -113 +114 @@
   lpUnLoadModule fUnLoadModule;
   lpGetConfigurationMeta fGetConfigurationMeta;
+  lpCommandLineExec fCommandLineExec;
 
 public:
@@ -130 +132 @@
   void unload(void);
   std::string getCongifurationMeta();
+  int commandLineExec(const char* command, const unsigned int argLen, char **arguments);
 
 private:

NSClient++.cpp

@@ -21 +21 @@
 #include <b64/b64.h>
 #include <PDHCounter.h>
+#include <PDHCollectors.h>
+
 
 NSClient mainClient;  // Global core instance.
@@ -44 +46 @@
       try {
         serviceControll::Install(SZSERVICENAME, SZSERVICEDISPLAYNAME, SZDEPENDENCIES);
-        serviceControll::SetDescription(SZSERVICENAME, SZSERVICEDESCRIPTION);
       } catch (const serviceControll::SCException& e) {
         LOG_MESSAGE_STD("Service installation failed: " + e.error_);
         return -1;
+      }
+      try {
+        serviceControll::SetDescription(SZSERVICENAME, SZSERVICEDESCRIPTION);
+      } catch (const serviceControll::SCException& e) {
+        LOG_MESSAGE_STD("Couldn't set service description: " + e.error_);
       }
       LOG_MESSAGE("Service installed!");
@@ -100 +106 @@
         }
       }
+    } else if ( _stricmp( "debugpdh", argv[1]+1 ) == 0 ) {
+      PDH::Enumerations::Objects lst = PDH::Enumerations::EnumObjects();
+      for (PDH::Enumerations::Objects::iterator it = lst.begin();it!=lst.end();++it) {
+        if ((*it).instances.size() > 0) {
+          for (PDH::Enumerations::Instances::const_iterator it2 = (*it).instances.begin();it2!=(*it).instances.end();++it2) {
+            for (PDH::Enumerations::Counters::const_iterator it3 = (*it).counters.begin();it3!=(*it).counters.end();++it3) {
+              std::string counter = "\\" + (*it).name + "(" + (*it2).name + ")\\" + (*it3).name;
+              std::cout << "testing: " << counter << ": ";
+              std::string error;
+              if (PDH::Enumerations::validate(counter, error)) {
+                std::cout << " found ";
+              } else {
+                std::cout << " *NOT* found (" << error << ") " << std::endl;
+                break;
+              }
+              bool bOpend = false;
+              try {
+                PDH::PDHQuery pdh;
+                PDHCollectors::StaticPDHCounterListener<double, PDH_FMT_DOUBLE> cDouble;
+                pdh.addCounter(counter, &cDouble);
+                pdh.open();
+                pdh.gatherData();
+                pdh.close();
+                bOpend = true;
+              } catch (const PDH::PDHException e) {
+                std::cout << " could *not* be open (" << e.getError() << ") " << std::endl;
+                break;
+              }
+              std::cout << " open ";
+              std::cout << std::endl;
+            }
+          }
+        } else {
+          for (PDH::Enumerations::Counters::const_iterator it2 = (*it).counters.begin();it2!=(*it).counters.end();++it2) {
+            std::string counter = "\\" + (*it).name + "\\" + (*it2).name;
+            std::cout << "testing: " << counter << ": ";
+            std::string error;
+            if (PDH::Enumerations::validate(counter, error)) {
+              std::cout << " found ";
+            } else {
+              std::cout << " *NOT* found (" << error << ") " << std::endl;
+              break;
+            }
+            bool bOpend = false;
+            try {
+              PDH::PDHQuery pdh;
+              PDHCollectors::StaticPDHCounterListener<double, PDH_FMT_DOUBLE> cDouble;
+              pdh.addCounter(counter, &cDouble);
+              pdh.open();
+              pdh.gatherData();
+              pdh.close();
+              bOpend = true;
+            } catch (const PDH::PDHException e) {
+              std::cout << " could *not* be open (" << e.getError() << ") " << std::endl;
+              break;
+            }
+            std::cout << " open ";
+            std::cout << std::endl;;
+          }
+        }
+      }
     } else if ( _stricmp( "test", argv[1]+1 ) == 0 ) {
 #ifdef _DEBUG
@@ -135 +202 @@
       return 0;
     } else {
-      LOG_MESSAGE("Usage: -version, -about, -install, -uninstall, -start, -stop");
-    }
+      LOG_MESSAGE("Usage: -version, -about, -install, -uninstall, -start, -stop, -encrypt");
+      LOG_MESSAGE("Usage: <ModuleName> <commnd> [arguments]");
+    }
+    return nRetCode;
+  } else if (argc > 2) {
+    g_bConsoleLog = true;
+    mainClient.InitiateService();
+    if (argc>=3)
+      mainClient.commandLineExec(argv[1], argv[2], argc-3, &argv[3]);
+    else
+      mainClient.commandLineExec(argv[1], argv[2], 0, NULL);
+    mainClient.TerminateService();
     return nRetCode;
   }
@@ -206 +283 @@
 // Member functions
 
+int NSClientT::commandLineExec(const char* module, const char* command, const unsigned int argLen, char** args) {
+  std::string sModule = module;
+  ReadLock readLock(&m_mutexRW, true, 10000);
+  if (!readLock.IsLocked()) {
+    LOG_ERROR("FATAL ERROR: Could not get read-mutex.");
+    return -1;
+  }
+  for (pluginList::size_type i=0;i<plugins_.size();++i) {
+    NSCPlugin *p = plugins_[i];
+    if (p->getName() == sModule) {
+      LOG_DEBUG_STD("Found module: " + p->getName() + "...");
+      try {
+        return p->commandLineExec(command, argLen, args);
+      } catch (NSPluginException e) {
+        LOG_ERROR_STD("Could not execute command: " + e.error_ + " in " + e.file_);
+      }
+    }
+  }
+  LOG_ERROR("Module not found.");
+  return 0;
+}
 
 /**

NSClient++.h

@@ -65 +65 @@
   std::string execute(std::string password, std::string cmd, std::list<std::string> args);
   void reportMessage(int msgType, const char* file, const int line, std::string message);
+  int commandLineExec(const char* module, const char* command, const unsigned int argLen, char** args);
 
   void addPlugins(const std::list<std::string> plugins);

NSClient++.sln

@@ -43 +43 @@
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ConfWiz", "ConfWiz\ConfWiz.vcproj", "{BD93F0C3-E342-4D68-9717-FCAC2E7189AA}"
+  ProjectSection(ProjectDependencies) = postProject
+  EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CheckWMI", "modules\CheckWMI\CheckWMI.vcproj", "{E6E588AB-EFEF-481C-9AF7-DCDCB95CFF45}"
   ProjectSection(ProjectDependencies) = postProject
   EndProjectSection
@@ -116 +120 @@
     {BD93F0C3-E342-4D68-9717-FCAC2E7189AA}.Release.ActiveCfg = Release|Win32
     {BD93F0C3-E342-4D68-9717-FCAC2E7189AA}.Release.Build.0 = Release|Win32
+    {E6E588AB-EFEF-481C-9AF7-DCDCB95CFF45}.Debug.ActiveCfg = Debug|Win32
+    {E6E588AB-EFEF-481C-9AF7-DCDCB95CFF45}.Debug.Build.0 = Debug|Win32
+    {E6E588AB-EFEF-481C-9AF7-DCDCB95CFF45}.Distribution.ActiveCfg = Distribution|Win32
+    {E6E588AB-EFEF-481C-9AF7-DCDCB95CFF45}.Distribution.Build.0 = Distribution|Win32
+    {E6E588AB-EFEF-481C-9AF7-DCDCB95CFF45}.Release.ActiveCfg = Release|Win32
+    {E6E588AB-EFEF-481C-9AF7-DCDCB95CFF45}.Release.Build.0 = Release|Win32
   EndGlobalSection
   GlobalSection(ExtensibilityGlobals) = postSolution

changelog

@@ +1 @@
+TODO: 
+ * Process times and similar ?
+ * Add bind_to_address in the socket
+ * Fix configuration GUI (low priority)
+ * Fix installer (low priority)
+ * Service check to use Auto (filter by started setting etc.)
+ * Add module for relaying events
+ * Check multitasking problems on the sockets.
+
+2006-02-12 MickeM
+ + Added new Interface for MOdules (NSCommandLineExec that allows modules to execute things give from command line.
+   Syntax is NSClient++ <module name> <command> [arguments] and if a mpodule doesn't support this it is simply ignored.
+ + Added new install/uninstall command to SystemTray module:
+   NSClient++.exe SystemTray install 
+   NSClient++.exe SystemTray uninstall 
+   That will install/uninstall the system tray module this sets the "Allow Service to Interact with Desktop" flag for the service.
+ * Removed the "Allow Service to Interact with Desktop" flag from the /install option so that it no longer defaults to on (see commands to set this above).
+ * Fixed so checkProcess isn't case sensetive.
+
+2006-02-12 MickeM
+ + Added support for host name resolve to allowed_hosts
+
+2006-02-08 MickeM
+ ! Fixed filter-eventID in EventLog module (now works for all IDs regardless of severity state)
+ + Added new filters to EventLog (filter-severity that can filter based on event severity success, error, warning, informational)
+
+2006-02-07 MickeM
+ + Added new filter option to eventlog filter-eventID
+ + Added new operator to all numeric filters in:number,number,... etc. (for instance filter-eventID=in:123,456,789 to check for lists.
+
+2006-02-05 MickeM
+ + Added CheckFile check command
+   This new command (in development) will allow various file checks such as age, size, date, etc on single or multiple files.
+ + Added FILEAGE support to NSClient
+ + Started to convert the webpage to WIKI
+ 
+2006-01-21 MickeM
+ + Added WMI Check module (early alpha)
+   This is an extremely early alpha more to see if there is an interest and how to progress with it.
+   To use the WMI module enable the WMICheck.dll (nsc.ini) and then run the following check:
+   CheckWMI MaxWarn=10 MaxCrit=15 "Query:load=Select LoadPercentage from win32_Processor"
+   The Max* are as every other check and sets limits. 
+   The Query works similarly to other check commands ie. Query:<name>=<WMI query>
+   So any other WMI query should work (notice this is experimental and not stable and has virtually 
+   no error handling so it is likely to crash nsclient if you ask anything "non working".)
+   I would *really* *really* like to get feedback on how to expand this concept to work better so feel free to come with feedback.
+  * Fixed NT4 /install (should work now!)
+
+2006-01-02 MickeM
+ * Fixed ChangeServiceConfig2 on NT4
+ + Added support for more then 4GB memory (8GB?)
+   Since I don't have this much memory this needs to be verified...
+ * Fixed syntax of performance data
+
+2005-09-24 MickeM
+ * Fixed memory size bug (free and used were swapped)
+
+2005-09-20 MickeM
+ + Added option to debug all PDH counters /debugpdh
+
+2005-09-17 MickeM
+ + Added support for checking service by display name
+
+2005-09-03 MickeM
+ * First off, sorry for lack of updates, but was on vacation :)
+ + Added ShowAll=long to CPULoad
+ + Added several new types to checkMem (type=paged, type=physical, type=page, type=virtual)
+
 2005-07-31 MickeM
- + /install now sets the serive to autostart
- * Did some cleanup of minor code sctions
- * (done before but not repported i think) /listpdh option added to list all pdh counters (nsclient++ /listpdh)
+ + /install now sets the service to autostart
+ * Did some cleanup of minor code sections
+ * (done before but not reported i think) /listpdh option added to list all PDH counters (nsclient++ /listpdh)
  + Added service description
- * Eventlog reworked (again) this time I hope it is better (and even usefull, but syntax has changed)
+ * Event log reworked (again) this time I hope it is better (and even useful, but syntax has changed)
 
 2005-07-26 MickeM
- + Added support for ShowAll=long (to show long and short info, only applies to some areas, but avalible everywhere)
+ + Added support for ShowAll=long (to show long and short info, only applies to some areas, but available everywhere)
  + Extended Drive and memory check syntax to facilitate both Free and Used space checks: MaxWarnFree / MaxWarnUsed etc)
 
@@ -15 +83 @@
 
 2005-07-16 MickeM
- * Fixed drivechecks from NSClient
+ * Fixed drive checks from NSClient
 
 2005-07-11 MickeM
- * *ALOT* of bugfixes and enhancements all checking code has been centralzed and rewritten also my nternal check scripts 
-   have been extenden to check alot more things.
+ * *ALOT* of bug fixes and enhancements all checking code has been centralized and rewritten also my internal check scripts 
+   have been extended to check a lot more things.
    *NOTICE* that EventLog has not been upgraded yet neither has the documentation.
- + Added MaxWarnCount / MinWarnCount to checkProcState to checknumber of processes running
+ + Added MaxWarnCount / MinWarnCount to checkProcState to check number of processes running
 
 2005-06-09 MickeM

docs/CheckDisk/index.html

@@ -35 +35 @@
   A request has one or more options described in the table below. The order 
   only matter in that the size has to be specified before the File option 
-  this becous you can change the size for each drive by specifying multiple 
+  this becaous you can change the size for each drive by specifying multiple 
   Size options.</p>
   <table class="MsoNormalTable" border="0" cellspacing="0" cellpadding="0" id="table5">

docs/CheckEventLog/index.html

@@ -83 +83 @@
       error, warning, etc</td>
       <td valign="top">
-      An eventtype to filter out: error, warning, info, auditSuccess or 
+      An event type to filter out: error, warning, info, auditSuccess or 
       auditFailure.</td>
     </tr>
@@ -122 +122 @@
   </table>
   <p>&nbsp;</p>
-  <p>A time expression is a date/time intervall as a number prefixed by a 
+  <p>A time expression is a date/time interval as a number prefixed by a 
   filter prefix (&lt;, &gt;, =, !=) and followed by a unit postfix (m, s, h, d, w). 
   A few examples of time expression are: filter-generated=&gt;2d means filter 
@@ -135 +135 @@
     <ul>
       <li>
-      <p><b>Check the Application and System event log for errors in the 
-      last 24 hours. Filter out any Cdrom and NSClient errors as well as 
+      <p><b>Check the Application event log for errors in the 
+      last 48 hours. Filter out any Cdrom and NSClient errors as well as 
       all warnings. Allow 3 errors before a warning is issued and 7 before 
       a critical state.</b></p>

docs/CheckSystem/index.html

@@ -105 +105 @@
       <td valign="top">Option</td>
       <td valign="top">Values</td>
-      <td valign="top">Description</td>
+      <td valign="top" width="743">Description</td>
     </tr>
     <tr>
       <td valign="top">warn</td>
       <td valign="top">load in %</td>
-      <td valign="top">Load to go above to generate a warning.</td>
+      <td valign="top" width="743">Load to go above to generate a warning.</td>
     </tr>
     <tr>
       <td valign="top">crit</td>
       <td valign="top">load in %</td>
-      <td valign="top">Load to go above to generate a critical state.</td>
-    </tr>
-    <tr>
-      <td valign="top">time</td>
-      <td valign="top">time</td>
-      <td valign="top">The time to calculate average over.</td>
+      <td valign="top" width="743">Load to go above to generate a critical state.</td>
+    </tr>
+    <tr>
+      <td valign="top">Time</td>
+      <td valign="top">time with optional prefix</td>
+      <td valign="top" width="743">The time to calculate average over.</td>
     </tr>
     <tr>
       <td valign="top">nsclient</td>
       <td valign="top">&nbsp;</td>
-      <td valign="top">Flag to make the plug in run in NSClient compatibility 
+      <td valign="top" width="743">Flag to make the plug in run in NSClient compatibility 
       mode</td>
+    </tr>
+    <tr>
+      <td valign="top">ShowAll</td>
+      <td valign="top">none, long</td>
+      <td valign="top" width="743">Add this option to show info even if no 
+      errors are detected. Set it to long to show detailed information.</td>
     </tr>
   </table>
@@ -176 +182 @@
       <td valign="top">Flag to make the plug in run in NSClient compatibility 
       mode</td>
+    </tr>
+    <tr>
+      <td valign="top">ShowAll</td>
+      <td valign="top">&nbsp;</td>
+      <td valign="top">Add this option to show details even if an error is 
+      not encountered.</td>
+    </tr>
+    <tr>
+      <td valign="top">Alias</td>
+      <td valign="top">string</td>
+      <td valign="top">A string to use as alias for the values (default is 
+      uptime)</td>
     </tr>
   </table>
@@ -212 +230 @@
       <td valign="top">service=state</td>
       <td valign="top">&nbsp;</td>
-      <td valign="top">A service name and a state the service should have. 
+      <td valign="top">A service name or service display name and a state the service should have. 
       The state can be either started or stopped. If no state is given started 
       is assumed.</td>
@@ -311 +329 @@
       (?).</td>
     </tr>
+    <tr>
+      <td valign="top">type</td>
+      <td valign="top">page, paged, virtual, physical</td>
+      <td valign="top">What kind of memory to check (does not yet support 
+      stacking to check multiple kinds)</td>
+    </tr>
   </table>
   <h3>Examples</h3>
@@ -319 +343 @@
       <p><code>checkMem MaxWarn=80% MaxCrit=90% ShowAll</code></p>
       <p><code>OK: page: 758M (795205632B)|page=30% 80%;90%;</code></p>
+      </li>
+      <li>
+      <p>Check that the physical is below 80%:</p>
+      <p><code>checkMem type=physical MaxWarn=80% MaxCrit=90% ShowAll</code></p>
+      <p><code>OK: physical: 758M (795205632B)|page=30% 80%;90%;</code></p>
       </li>
     </ul>
@@ -353 +382 @@
       <td valign="top">MinCrit</td>
       <td valign="top">Number</td>
-      <td valign="top">Minimumallowed number</td>
+      <td valign="top">Minimum allowed number</td>
     </tr>
     <tr>
@@ -370 +399 @@
       <td valign="top">Add a named performance counter. The &lt;name&gt; will be 
       used as an alias.</td>
+    </tr>
+    <tr>
+      <td valign="top">Averages</td>
+      <td valign="top">true, false</td>
+      <td valign="top">Set this to false to make performance checking 
+      faster of counters that doesn't represent average values.</td>
     </tr>
   </table>

docs/welcome.html

@@ -33 +33 @@
   <table id="table17" border="0" cellspacing="0" cellpadding="0" class="MsoNormalTable">
     <tr>
-      <td valign="top">2005-07-31</td>
-      <td>Mainly fixes some minor issues, also adds support for FreeSpace 
-      checks (in addition to UsedSpace check) as well as &quot;long description 
-      support&quot; and a reworked EventLog checker.<br>
-      <br>
-      No updated documentation yet but hopefully all outstanding issues 
-      has been fixed.<br>
-      <br>
-      Extract from change log:<br>
-      + /install now sets the serivice to autostart<br>
-      + Added service description<br>
-      * added /listpdh option added to list all pdh counters<br>
-      * Eventlog reworked (again) this time I hope it is better <br>
-      + Added support for ShowAll=long (to show more information)<br>
-      + Extended Drive and memory check syntax to facilitate both Free and 
-      Used space checks: MaxWarnFree / MaxWarnUsed etc)<br>
-      * Changed thread API to use _creatthreadex as opposed to _creatthread 
-      (works better now!)<br>
-      * Fixed UNKNOWN return code (was 4 should have been 3)<br>
-      * Fixed drivechecks from NSClient<br>
-&nbsp;</td>
-    </tr>
-    <tr>
-      <td valign="top">2005-07-12</td>
-      <td>Update with a lot bugfixes
+      <td valign="top">2006-01-21</td>
+      <td><p><b>Added</b> WMI Check module (early alpha)</p>
+      This is an extremely early alpha more to see if there is an interest 
+      and how to progress with it.<br>
+      To use the WMI module enable the WMICheck.dll (nsc.ini) and then run 
+      the following check:<br>
+      CheckWMI MaxWarn=10 MaxCrit=15 &quot;Query:load=Select LoadPercentage 
+      from win32_Processor&quot;<br>
+      The Max* are as every other check and sets limits. <br>
+      The Query works similarly to other check commands ie. Query:&lt;name&gt;=&lt;WMI 
+      query&gt;<br>
+      So any other WMI query should work (notice this is experimental and 
+      not stable and has virtually <br>
+      no error handling so it is likely to crash nsclient if you ask 
+      anything &quot;non working&quot;.)<br>
+      I would *really* *really* like to get feedback on how to expand this 
+      concept to work better so feel free to come with feedback.<br>
+      <p><b>Fixed</b> NT4 /install (should work now!)</p></td>
+    </tr>
+    <tr>
+      <td valign="top">2006-01-02</td>
+      <td><p>Minor fixes (but Im starting to be a tad more active now, or so 
+      I hope :)</p><p>Changes in this version:</p>
+      <p><b>Fixed</b> ChangeServiceConfig2 on NT4<br>
+      <b>Added </b>support for more then 4GB memory (8GB?)<br>
+      Since I dont have this much memory this needs to be verified...<br>
+      <b>Fixed </b>syntax of performance data</td>
+    </tr>
+    <tr>
+      <td valign="top">2005-09-26</td>
+      <td><p>Minor additions and a bugfixrequests as well as updates to the documentation</p>
+      <p>Changes in this version:</p>
+      <p><b>Fixed </b>memory size bug (free and used were swapped)<br>
+      <b>Added </b>option to debug all PDH counters /debugpdh<br>
+      <b>Added </b>support for checking service by display name<br>
       </td>
     </tr>
@@ -65 +75 @@
   <a href="http://nscplus.sf.net" target="_top">http://nscplus.sf.net</a></p>
   <p>Latest version is
-  <a href="http://prdownloads.sourceforge.net/nscplus/NSClient++-0.2.4d.zip?download">
-  NSClient++ 0.2.4.zip</a></p>
+  <a href="http://prdownloads.sourceforge.net/nscplus/NSClient++-0.2.5a.zip?download">
+  NSClient++ 0.2.5a.zip</a></p>
   <h1>Modules</h1>
   <p>NSClient++ comes with a few modules out of the box that does various checks. 

include/EnumNtSrv.cpp

@@ -177 +177 @@
 }
 
+#define SC_BUF_LEN 1024
 TNtServiceInfo TNtServiceInfo::GetService(std::string name)
 {
@@ -187 +188 @@
   SC_HANDLE sh = ::OpenService(scman,name.c_str(),SERVICE_QUERY_STATUS);
   if (!sh) {
-    throw NTServiceException(name, "Could not open Service", GetLastError());
-    ::CloseServiceHandle(scman);
+    DWORD bufLen = SC_BUF_LEN;
+    TCHAR *buf = new TCHAR[bufLen];
+    if (!GetServiceKeyName(scman, name.c_str(), buf, &bufLen)) {
+      throw NTServiceException(name, "Could not open Service", GetLastError());
+      ::CloseServiceHandle(scman);
+    }
+    if (bufLen >= SC_BUF_LEN) {
+      throw NTServiceException(name, "Could not open Service", GetLastError());
+      ::CloseServiceHandle(scman);
+    }
+    buf[bufLen] = 0;
+    SC_HANDLE sh = ::OpenService(scman,buf,SERVICE_QUERY_STATUS);
+    if (!sh) {
+      throw NTServiceException(name, "Could not open Service", GetLastError());
+      ::CloseServiceHandle(scman);
+    }
   }
   SERVICE_STATUS state;

include/NSCHelper.cpp

@@ -381 +381 @@
     throw NSCMHExcpetion("NSCore has not been initiated...");
   unsigned int len = 0;
-  fNSAPIEncrypt(algorithm, str.c_str(), str.size(), NULL, &len);
+  // @todo investigate potential problems with static_cast<unsigned int>
+  fNSAPIEncrypt(algorithm, str.c_str(), static_cast<unsigned int>(str.size()), NULL, &len);
   len+=2;
   char *buf = new char[len+1];
-  NSCAPI::errorReturn ret = fNSAPIEncrypt(algorithm, str.c_str(), str.size(), buf, &len);
+  NSCAPI::errorReturn ret = fNSAPIEncrypt(algorithm, str.c_str(), static_cast<unsigned int>(str.size()), buf, &len);
   if (ret == NSCAPI::isSuccess) {
     std::string ret = buf;
@@ -396 +397 @@
     throw NSCMHExcpetion("NSCore has not been initiated...");
   unsigned int len = 0;
-  fNSAPIDecrypt(algorithm, str.c_str(), str.size(), NULL, &len);
+  // @todo investigate potential problems with: static_cast<unsigned int>(str.size())
+  fNSAPIDecrypt(algorithm, str.c_str(), static_cast<unsigned int>(str.size()), NULL, &len);
   len+=2;
   char *buf = new char[len+1];
-  NSCAPI::errorReturn ret = fNSAPIDecrypt(algorithm, str.c_str(), str.size(), buf, &len);
+  NSCAPI::errorReturn ret = fNSAPIDecrypt(algorithm, str.c_str(), static_cast<unsigned int>(str.size()), buf, &len);
   if (ret == NSCAPI::isSuccess) {
     std::string ret = buf;

include/NSCHelper.h

@@ -83 +83 @@
   typedef NSCAPI::errorReturn (*lpNSAPIStopServer)(void);
   typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const char*, const unsigned int, char **, char *, unsigned int, char *, unsigned int);
-  typedef LPVOID (*lpNSAPILoader)(char*);
+  typedef void* (*lpNSAPILoader)(char*);
   typedef NSCAPI::boolReturn (*lpNSAPICheckLogMessages)(int);
   typedef NSCAPI::errorReturn (*lpNSAPIEncrypt)(unsigned int, const char*, unsigned int, char*, unsigned int *);
@@ -144 +144 @@
   extern int NSGetConfigurationMeta(int IN_retBufLen, char *OUT_retBuf)
 
+#define NSC_WRAPPERS_CLI() \
+  extern int NSCommandLineExec(const char*,const unsigned int,char**)
 
 
@@ -224 +226 @@
   }
 
+#define NSC_WRAPPERS_CLI_DEF(toObject) \
+  extern int NSCommandLineExec(const char* command,const unsigned int argLen,char** args) { \
+    return toObject.commandLineExec(command, argLen, args); \
+  } \
+
 //////////////////////////////////////////////////////////////////////////
 #define MODULE_SETTINGS_START(class, name, description) \

include/PDHCounter.h

@@ -201 +201 @@
     }
 
-    static DWORD lookupCounterByName(std::string count, std::string machine = "") {
-    }
-
     PDHCounter* addCounter(std::string name, PDHCounterListener *listener) {
       PDHCounter *counter = new PDHCounter(name, listener);

include/ServiceCmd.cpp

@@ -16 +16 @@
 #include "stdafx.h"
 #include "ServiceCmd.h"
+#include <strEx.h>
 
 namespace serviceControll {
@@ -30 +31 @@
    *
    */
-  void Install(LPCTSTR szName, LPCTSTR szDisplayName, LPCTSTR szDependencies) {
+  void Install(LPCTSTR szName, LPCTSTR szDisplayName, LPCTSTR szDependencies, DWORD dwServiceType) {
     SC_HANDLE   schService;
     SC_HANDLE   schSCManager;
@@ -46 +47 @@
       TEXT(szDisplayName),     // name to display
       SERVICE_ALL_ACCESS,         // desired access
-      SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS ,  // service type
+      dwServiceType,        // service type
       SERVICE_AUTO_START,       // start type
       SERVICE_ERROR_NORMAL,       // error control type
@@ -57 +58 @@
 
     if (!schService) {
-      CloseServiceHandle(schSCManager);
-      throw SCException("Unable to install service.");
-    }
-    CloseServiceHandle(schService);
-    CloseServiceHandle(schSCManager);
+      DWORD err = GetLastError();
+      CloseServiceHandle(schSCManager);
+      if (err==ERROR_SERVICE_EXISTS) {
+        throw SCException("Service already installed!");
+      }
+      throw SCException("Unable to install service.", err);
+    }
+    CloseServiceHandle(schService);
+    CloseServiceHandle(schSCManager);
+  }
+
+  void ModifyServiceType(LPCTSTR szName, DWORD dwServiceType) {
+    SC_HANDLE   schService;
+    SC_HANDLE   schSCManager;
+    TCHAR szPath[512];
+
+    if ( GetModuleFileName( NULL, szPath, 512 ) == 0 )
+      throw SCException("Could not get module");
+
+    schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
+    if (!schSCManager)
+      throw SCException("OpenSCManager failed.");
+    schService = OpenService(schSCManager, TEXT(szName), SERVICE_ALL_ACCESS);
+    if (!schService) {
+      DWORD err = GetLastError();
+      CloseServiceHandle(schSCManager);
+      throw SCException("Unable to open service.", err);
+    }
+    BOOL result = ChangeServiceConfig(schService, dwServiceType, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE , NULL, NULL, NULL, 
+      NULL, NULL, NULL, NULL);
+    CloseServiceHandle(schService);
+    CloseServiceHandle(schSCManager);
+    if (result != TRUE)
+      throw SCException("Could not query service information");
+  }
+
+  DWORD GetServiceType(LPCTSTR szName) {
+    LPQUERY_SERVICE_CONFIG lpqscBuf = (LPQUERY_SERVICE_CONFIG) LocalAlloc(LPTR, 4096); 
+    if (lpqscBuf == NULL) {
+      throw SCException("Could not allocate memory");
+    }
+    SC_HANDLE schService;
+    SC_HANDLE schSCManager;
+    TCHAR szPath[512];
+
+    if ( GetModuleFileName( NULL, szPath, 512 ) == 0 )
+      throw SCException("Could not get module");
+
+    schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
+    if (!schSCManager)
+      throw SCException("OpenSCManager failed.");
+    schService = OpenService(schSCManager, TEXT(szName), SERVICE_ALL_ACCESS);
+    if (!schService) {
+      DWORD err = GetLastError();
+      CloseServiceHandle(schSCManager);
+      throw SCException("Unable to open service.", err);
+    }
+
+
+    DWORD dwBytesNeeded = 0;
+    BOOL success = QueryServiceConfig(schService, lpqscBuf,  4096, &dwBytesNeeded);
+    CloseServiceHandle(schService);
+    CloseServiceHandle(schSCManager);
+    if (success != TRUE)
+      throw SCException("Could not query service information");
+    DWORD ret = lpqscBuf->dwServiceType;
+    LocalFree(lpqscBuf);
+    return ret;
   }
 
@@ -188 +252 @@
   }
 
+
+  typedef BOOL (WINAPI*PFChangeServiceConfig2)(SC_HANDLE hService,DWORD dwInfoLevel,LPVOID lpInfo);
+
   void SetDescription(std::string name, std::string desc) {
+    PFChangeServiceConfig2 FChangeServiceConfig2;
+    HMODULE ADVAPI= ::LoadLibrary(_TEXT("Advapi32"));
+    if (!ADVAPI) {
+      throw SCException("Couldn't set extended service info (ignore this on NT4).");
+    }
+#ifdef UNICODE
+    FChangeServiceConfig2 = (PFChangeServiceConfig2)::GetProcAddress(ADVAPI, _TEXT("ChangeServiceConfig2W"));
+#else
+    FChangeServiceConfig2 = (PFChangeServiceConfig2)::GetProcAddress(ADVAPI, _TEXT("ChangeServiceConfig2A"));
+#endif
+    if (!FChangeServiceConfig2) {
+      FreeLibrary(ADVAPI);
+      throw SCException("Couldn't set extended service info (ignore this on NT4).");
+    }
     SERVICE_DESCRIPTION descr;
     SC_HANDLE schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
@@ -195 +276 @@
     SC_HANDLE schService = OpenService(schSCManager, TEXT(name.c_str()), SERVICE_ALL_ACCESS);
     if (!schService) {
-      CloseServiceHandle(schSCManager);
-      throw SCException("OpenService failed.");
-    }
-
-    LPSTR d = new char[desc.length()+1];
+      FreeLibrary(ADVAPI);
+      CloseServiceHandle(schSCManager);
+      throw SCException("OpenService failed.");
+    }
+
+    LPSTR d = new char[desc.length()+2];
     strncpy(d, desc.c_str(), desc.length());
     descr.lpDescription = d;
-    BOOL bResult = ChangeServiceConfig2(schService, SERVICE_CONFIG_DESCRIPTION, &descr);
+    BOOL bResult = FChangeServiceConfig2(schService, SERVICE_CONFIG_DESCRIPTION, &descr);
     delete [] d;
+    FreeLibrary(ADVAPI);
     CloseServiceHandle(schService);
     CloseServiceHandle(schSCManager);

include/ServiceCmd.h

@@ -1 +1 @@
 #pragma once
+
+#include <sstream>
 
 namespace serviceControll {
@@ -7 +9 @@
     SCException(std::string error) : error_(error) {
     }
+    SCException(std::string error, int code) : error_(error) {
+      std::stringstream ss;
+      ss << ": ";
+      ss << code;
+      error += ss.str();
+    }
   };
-  void Install(LPCTSTR,LPCTSTR,LPCTSTR);
+  void Install(LPCTSTR,LPCTSTR,LPCTSTR,DWORD=SERVICE_WIN32_OWN_PROCESS);
+  void ModifyServiceType(LPCTSTR szName, DWORD dwServiceType);
   void Uninstall(std::string);
   void Start(std::string);
   void Stop(std::string);
   void SetDescription(std::string,std::string);
+  DWORD GetServiceType(LPCTSTR szName);
 }

include/Settings.h

@@ -2 +2 @@
 
 #include <Singleton.h>
+#include <string>
+#include <map>
+#include <windows.h>
 #define BUFF_LEN 4096
 
@@ -10 +13 @@
 {
 private:
+  typedef std::map<std::string,std::string> saveKeyList;
+  typedef std::map<std::string,saveKeyList> saveSectionList;
   std::string file_;
+  saveSectionList data_;
+  bool bHasInternalData;
 public:
   typedef std::list<std::string> sectionList;
-
-  SettingsT(void)
+  SettingsT(void) : bHasInternalData(false)
   {
   }
@@ -29 +35 @@
     file_ = file;
   }
+
+  sectionList getSections() {
+    sectionList ret;
+    char* buffer = new char[BUFF_LEN+1];
+    unsigned int count = ::GetPrivateProfileSectionNames(buffer, BUFF_LEN, file_.c_str());
+    if (count == BUFF_LEN-2)
+      throw "Fuck...";
+    unsigned int last = 0;
+    for (unsigned int i=0;i<count;i++) {
+      if (buffer[i] == '\0') {
+        std::string s = &buffer[last];
+        ret.push_back(s);
+        last = i+1;
+      }
+    }
+    delete [] buffer;
+    if (bHasInternalData) {
+      for (saveSectionList::const_iterator it = data_.begin(); it != data_.end(); ++it) {
+      }
+    }
+    ret.sort();
+    ret.unique();
+    return ret;
+  }
+
   /**
    * Get all keys from a section as a list<string>
@@ -34 +65 @@
    * @return A list with all keys from the section
    */
-  std::list<std::string> getSection(std::string section) {
-    std::list<std::string> ret;
+  sectionList getSection(std::string section) {
+    sectionList ret;
     char* buffer = new char[BUFF_LEN+1];
     unsigned int count = GetPrivateProfileSection(section.c_str(), buffer, BUFF_LEN, file_.c_str());
@@ -49 +80 @@
     }
     delete [] buffer;
+    if (bHasInternalData) {
+      saveSectionList::const_iterator it = data_.find(section);
+      if (it != data_.end()) {
+        for (saveKeyList::const_iterator kit = it->second.begin(); kit != it->second.end(); ++kit) {
+          ret.push_back(kit->first);
+        }
+      }
+    }
+    ret.sort();
+    ret.unique();
     return ret;
   }
@@ -59 +100 @@
    */
   std::string getString(std::string section, std::string key, std::string defaultValue = "") const {
+    if (bHasInternalData) {
+      saveSectionList::const_iterator it = data_.find(section);
+      if (it != data_.end()) {
+        saveKeyList::const_iterator kit = it->second.find(key);
+        if (kit != it->second.end()) {
+          return kit->second;
+        }
+      }
+    }
     char* buffer = new char[1024];
     GetPrivateProfileString(section.c_str(), key.c_str(), defaultValue.c_str(), buffer, 1023, file_.c_str());
@@ -65 +115 @@
     return ret;
   }
+
+  void setString(std::string section, std::string key, std::string value) {
+    bHasInternalData = true;
+    (data_[section])[key] = value;
+  }
+
   /**
    * Get an integer from the settings file

include/Socket.h

@@ -100 +100 @@
       unsigned long NoBlock = 1;
       this->ioctlsocket(FIONBIO, &NoBlock);
+    }
+    static std::string getHostByName(std::string ip) {
+      hostent* remoteHost;
+      remoteHost = gethostbyname(ip.c_str());
+      if (remoteHost == NULL)
+        throw SocketException("gethostbyname failed for " + ip + ": ", ::WSAGetLastError());
+      // @todo investigate it this is "correct" and dont use before!
+      return inet_ntoa(*reinterpret_cast<in_addr*>(remoteHost->h_addr));
+    }
+    static std::string getHostByAddr(std::string ip) {
+      hostent* remoteHost;
+      remoteHost = gethostbyaddr(ip.c_str(), static_cast<int>(ip.length()), AF_INET);
+      if (remoteHost == NULL)
+        throw SocketException("gethostbyaddr failed for " + ip + ": ", ::WSAGetLastError());
+      return remoteHost->h_name;
     }
     virtual void readAll(DataBuffer &buffer, unsigned int tmpBufferLength = 1024);
@@ -397 +412 @@
   return 0;
 }
+
+
+
+namespace socketHelpers {
+  class allowedHosts {
+  public:
+    typedef std::list<std::string> host_list; 
+  private:
+    host_list allowedHosts_;
+  public:
+    void setAllowedHosts(host_list allowedHosts) {
+      if ((!allowedHosts.empty()) && (allowedHosts.front() == "") )
+        allowedHosts.pop_front();
+      allowedHosts_ = allowedHosts;
+      for (host_list::iterator it = allowedHosts_.begin();it!=allowedHosts_.end();++it) {
+        if (((*it).length() > 0) && (std::isalpha((*it)[0]))) {
+          std::string s = (*it);
+          try {
+            *it = simpleSocket::Socket::getHostByName(s);
+          } catch (simpleSocket::SocketException e) {
+            e;
+          }
+        }
+      }
+    }
+    bool inAllowedHosts(std::string s) {
+      if (allowedHosts_.empty())
+        return true;
+      host_list::const_iterator cit;
+      for (cit = allowedHosts_.begin();cit!=allowedHosts_.end();++cit) {
+        if ( (*cit) == s)
+          return true;
+      }
+      return false;
+    }
+  };
+}

include/checkHelpers.hpp

@@ -4 +4 @@
 #include <strEx.h>
 
+#define MAKE_PERFDATA(alias, value, unit, warn, crit) "'" + alias + "'=" + value + unit + ";" + warn + ";" + crit + "; "
 
 namespace checkHolders {
@@ -133 +134 @@
       return "Free: ";
     }
+    static std::string key_prefix() {
+      return "";
+    }
+    static std::string key_postfix() {
+      return "";
+    }
+
   };
 
@@ -154 +162 @@
       return strEx::itos(value);
     }
+    static std::string key_prefix() {
+      return "";
+    }
+    static std::string key_postfix() {
+      return "";
+    }
+
   };
 
@@ -174 +189 @@
       return strEx::itos(value) + "%";
     }
+    static std::string key_prefix() {
+      return "";
+    }
+    static std::string key_postfix() {
+      return "";
+    }
   };
   class int64_handler {
@@ -209 +230 @@
     static std::string print_percent(double value) {
       return strEx::itos(value) + "%";
+    }
+    static std::string key_prefix() {
+      return "";
+    }
+    static std::string key_postfix() {
+      return "";
     }
   };
@@ -268 +295 @@
 
     static std::string toStringLong(TType value) {
-      return THandler::print(value);
+      return THandler::key_prefix() + THandler::print(value) + THandler::key_postfix();
     }
     static std::string toStringShort(TType value) {
@@ -286 +313 @@
     }
     static std::string gatherPerfData(std::string alias, TType &value, TType warn, TType crit) {
-      return alias + ";"
-        + THandler::print_unformated(value) + ";"
-        + THandler::print_unformated(warn) + ";"
-        + THandler::print_unformated(crit) + "; ";
+      return MAKE_PERFDATA(alias, THandler::print_unformated(value), "", THandler::print_unformated(warn), THandler::print_unformated(crit));
     }
 
@@ -335 +359 @@
       }
       const InternalValue & operator=(std::string value) {
-        std::cout << "Setting value: " << value << std::endl;
         std::string::size_type p = value.find_first_of('%');
         if (p != std::string::npos) {
@@ -372 +395 @@
     checkResultType check(TType value) const {
       if (type_ == percentage_lower) {
-        std::cout << "Checking: percentage_lower " << value.getLowerPercentage() << " < " << value_ << std::endl;
         if (value.getLowerPercentage() == value_)
           return same;
@@ -378 +400 @@
           return above;
       } else if (type_ == percentage_upper) {
-        std::cout << "Checking: percentage_upper " << value.getUpperPercentage() << " < " << value_ << std::endl;
         if (value.getUpperPercentage() == value_)
           return same;
@@ -384 +405 @@
           return above;
       } else if (type_ == value_lower) {
-        std::cout << "Checking: value_lower " << value.total << " < " << value_ << std::endl;
         if (value.value == value_)
           return same;
@@ -390 +410 @@
           return above;
       } else if (type_ == value_upper) {
-        std::cout << "Checking: value_upper " << (value.total-value.value) << " < " << value_ << std::endl;
         if ((value.total-value.value) == value_)
           return same;
@@ -421 +440 @@
     std::string gatherPerfData(std::string alias, TType &value, typename TType::TValueType warn, typename TType::TValueType crit) {
       if (type_ == percentage_upper) {
-        return alias + ";"
-          + THandler::print_unformated(value.getUpperPercentage()) + "%;"
-          + THandler::print_unformated(warn) + ";"
-          + THandler::print_unformated(crit) + "; ";
+        return 
+          MAKE_PERFDATA(alias, THandler::print_unformated(value.getUpperPercentage()), "%", 
+          THandler::print_unformated(warn), THandler::print_unformated(crit));
       } else if (type_ == percentage_lower) {
-          return alias + ";"
-            + THandler::print_unformated(value.getLowerPercentage()) + "%;"
-            + THandler::print_unformated(warn) + ";"
-            + THandler::print_unformated(crit) + "; ";
+          return 
+            MAKE_PERFDATA(alias, THandler::print_unformated(value.getLowerPercentage()), "%", 
+            THandler::print_unformated(warn), THandler::print_unformated(crit));
       } else {
-        return alias + ";"
-          + THandler::print_unformated(value.value) + ";"
-          + THandler::print_unformated(warn) + ";"
-          + THandler::print_unformated(crit) + "; ";
+        return 
+          MAKE_PERFDATA(alias, THandler::print_unformated(value.value), "", 
+          THandler::print_unformated(warn), THandler::print_unformated(crit));
       }
     }
   private:
     void setUpper(std::string s) {
-      std::cout << "Setting value:U " << s << std::endl;
       value_ = THandler::parse(s);
       type_ = value_upper;
     }
     void setLower(std::string s) {
-      std::cout << "Setting value:L " << s << std::endl;
       value_ = THandler::parse(s);
       type_ = value_lower;

include/config.h

@@ -5 +5 @@
 
 // Version
-#define SZVERSION "0.2.0 2005-05-21"
+#define SZVERSION "0.2.5f 2006-02-14"
 
 // internal name of the service
-#define SZSERVICENAME        "NSClient++"
+#define SZSERVICENAME        "NSClientpp"
 
 // Description of service

include/filter_framework.hpp

@@ -1 +1 @@
 #pragma once
+
+#include <strEx.h>
 
 namespace filters {
@@ -40 +42 @@
     struct numeric_equals_filter {
       static bool filter(TType filter, TType value) {
-        return value = filter;
+        return value == filter;
       }
     };
@@ -47 +49 @@
       static bool filter(TType filter, TType value) {
         return value != filter;
+      }
+    };
+    template <typename TType>
+    struct always_true_filter {
+      static bool filter(TType filter, TType value) {
+        return true;
+      }
+    };
+    template <typename TListType, typename TType>
+    struct numeric_inlist_filter {
+      static bool filter(const TListType &filter, const TType value) {
+        for (TListType::const_iterator it = filter.begin(); it != filter.end(); ++it) {
+          if ((*it) == value)
+            return true;
+        }
+        return false;
       }
     };
@@ -57 +75 @@
       static std::string parse(std::string str) {
         return str;
+      }
+    };
+    template<class TType, class TSubHandler>
+    struct numeric_list_handler {
+      static std::list<TType> parse(std::string str) {
+        std::list<TType> ret;
+        std::list<std::string> tmp = strEx::splitEx(str, ",");
+        for (std::list<std::string>::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
+          ret.push_back(TSubHandler::parse(*it));
+        }
+        return ret;
       }
     };
@@ -69 +98 @@
     };
     struct eventtype_handler {
-
       static unsigned int parse(std::string str) {
         if (str == "error")
@@ -97 +125 @@
       }   
     };
-  }
+    struct eventseverity_handler {
+      static unsigned int parse(std::string str) {
+        if (str == "success")
+          return 0;
+        if (str == "informational")
+          return 1;
+        if (str == "warning")
+          return 2;
+        if (str == "error")
+          return 3;
+        return strEx::stoi(str);
+      }
+      static std::string toString(unsigned int dwType) {
+        if (dwType == 0)
+          return "success";
+        if (dwType == 1)
+          return "informational";
+        if (dwType == 2)
+          return "warning";
+        if (dwType == 3)
+          return "error";
+        return strEx::itos(dwType);
+      }   
+    };  }
 
   template <typename TFilterType, typename TValueType, class THandler, class TFilter>
@@ -104 +155 @@
     bool hasFilter_;
     filter_one() : hasFilter_(false) {}
+    filter_one(const filter_one &other) : hasFilter_(other.hasFilter_), filter(other.filter) {
+    }
 
     inline bool hasFilter() const {
       return hasFilter_;
     }
-    bool matchFilter(TValueType str) const {
-      return TFilter::filter(filter, str);
+    bool matchFilter(const TValueType value) const {
+      return TFilter::filter(filter, value);
     }
     const filter_one & operator=(std::string value) {
@@ -134 +187 @@
       return sub.hasFilter() || regexp.hasFilter();
     }
-    bool matchFilter(std::string str) const {
+    bool matchFilter(const std::string str) const {
       if ((regexp.hasFilter())&&(regexp.matchFilter(str)))
         return true;
@@ -161 +214 @@
     filter_one<TType, TType, THandler, filter::numeric_equals_filter<TType> > eq;
     filter_one<TType, TType, THandler, filter::numeric_nequals_filter<TType> > neq;
-
+    filter_one<std::list<TType>, TType, handlers::numeric_list_handler<TType, THandler>, filter::numeric_inlist_filter<std::list<TType>, TType> > inList;
+
+    filter_all_numeric() {}
+    filter_all_numeric(const filter_all_numeric &other) {
+      max = other.max;
+      min = other.min;
+      eq = other.eq;
+      neq = other.neq;
+      inList = other.inList;
+    }
     inline bool hasFilter() const {
-      return max.hasFilter() || min.hasFilter() || eq.hasFilter() || neq.hasFilter();
-    }
-    bool matchFilter(TType value) const {
+      return max.hasFilter() || min.hasFilter() || eq.hasFilter() || neq.hasFilter() || inList.hasFilter();
+    }
+    bool matchFilter(const TType value) const {
       if ((max.hasFilter())&&(max.matchFilter(value)))
         return true;
@@ -173 +235 @@
         return true;
       else if ((neq.hasFilter())&&(neq.matchFilter(value)))
+        return true;
+      else if ((inList.hasFilter())&&(inList.matchFilter(value)))
         return true;
       return false;
@@ -185 +249 @@
       } else if (value.substr(0,2) == "!=") {
         neq = value.substr(2);
+      } else if (value.substr(0,3) == "in:") {
+        inList = value.substr(3);
       } else {
         throw parse_exception("Unknown filter key: " + value);
@@ -191 +257 @@
     }
   };
-  typedef filter_all_numeric<unsigned int, checkHolders::time_handler<unsigned int> > filter_all_times;
+  typedef filter_all_numeric<unsigned long long, checkHolders::time_handler<unsigned long long> > filter_all_times;
 }

include/strEx.h

@@ -6 +6 @@
 #include <utility>
 #include <list>
+#include <functional>
 #ifdef _DEBUG
 #include <iostream>
@@ -260 +261 @@
   typedef std::basic_string<char, blind_traits<char>, std::allocator<char> >  blindstr;
 
+  struct case_blind_string_compare : public std::binary_function<std::string, std::string, bool>
+  {
+    bool operator() (const std::string& x, const std::string& y) const {
+      return stricmp( x.c_str(), y.c_str() ) < 0;
+    }
+  };
 #ifdef _DEBUG
   inline void test_getToken(std::string in1, char in2, std::string out1, std::string out2) {

include/utils.h

@@ -7 +7 @@
 unsigned long calculate_crc32(const char *buffer, int buffer_size);
 
-namespace socketHelpers {
-  class allowedHosts {
-  private:
-    strEx::splitList allowedHosts_;
-  public:
-    void setAllowedHosts(strEx::splitList allowedHosts) {
-      if ((!allowedHosts.empty()) && (allowedHosts.front() == "") )
-        allowedHosts.pop_front();
-      allowedHosts_ = allowedHosts;
-    }
-    bool inAllowedHosts(std::string s) {
-      if (allowedHosts_.empty())
-        return true;
-      strEx::splitList::const_iterator cit;
-      for (cit = allowedHosts_.begin();cit!=allowedHosts_.end();++cit) {
-        if ( (*cit) == s)
-          return true;
-      }
-      return false;
-    }
-  };
-}
 
 #define MAP_OPTIONS_BEGIN(args) \
@@ -58 +36 @@
       else if (p__.first == ("MinCrit" postfix)) { obj.crit.min = p__.second; }
 
+#define MAP_OPTIONS_PUSH_WTYPE(type, value, obj, list) \
+      else if (p__.first == value) { type o; o.obj = p__.second; list.push_back(o); }
 #define MAP_OPTIONS_PUSH(value, list) \
       else if (p__.first == value) { list.push_back(p__.second); }
@@ -74 +54 @@
 #define MAP_OPTIONS_BOOL_VALUE(value, obj, tStr) \
       else if ((p__.first == value)&&(p__.second == tStr)) { obj = true; } 
+#define MAP_OPTIONS_MODE(value, tStr, obj, oVal) \
+      else if ((p__.first == value)&&(p__.second == tStr)) { obj = oVal; } 
 #define MAP_OPTIONS_BOOL_EX(value, obj, tStr, fStr) \
       else if ((p__.first == value)&&(p__.second == tStr)) { obj = true; } \
@@ -79 +61 @@
 #define MAP_OPTIONS_MISSING(arg, str) \
       else { arg = str + p__.first; return NSCAPI::returnUNKNOWN; }
+#define MAP_OPTIONS_FALLBACK(obj) \
+      else { obj = p__.first;}
 #define MAP_OPTIONS_FALLBACK_AND(obj, extra) \
       else { obj = p__.first; extra;}

modules/CheckDisk/CheckDisk.cpp

@@ -6 +6 @@
 #include <strEx.h>
 #include <time.h>
-
-
+#include <filter_framework.hpp>
 
 
@@ -38 +37 @@
 }
 
-typedef std::unary_function<const WIN32_FIND_DATA&, bool> baseClass;
-struct GetSize : public baseClass
+struct file_finder_data {
+  file_finder_data(const WIN32_FIND_DATA wfd_, const std::string path_) : wfd(wfd_), path(path_) {}
+  const WIN32_FIND_DATA wfd;
+  const std::string path;
+};
+typedef std::unary_function<const file_finder_data&, bool> baseFinderFunction;
+struct get_size : public baseFinderFunction
 {
-  GetSize() : size(0) { }
-  result_type operator()(argument_type wfd) {
-    if (!(wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)) {
-      size += (wfd.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)wfd.nFileSizeLow;
+  get_size() : size(0) { }
+  result_type operator()(argument_type ffd) {
+    if (!(ffd.wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)) {
+      size += (ffd.wfd.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)ffd.wfd.nFileSizeLow;
     }
     return true;
@@ -55 +59 @@
 };
 
-void RecursiveScanDirectory(std::string dir, GetSize & f) {
+
+template <class finder_function>
+void recursive_scan(std::string dir, finder_function & f) {
   std::string baseDir;
   std::string::size_type pos = dir.find_last_of('\\');
@@ -66 +72 @@
   if (hFind != INVALID_HANDLE_VALUE) {
     do {
-      if (!f(wfd))
+      if (!f(file_finder_data(wfd, baseDir)))
         break;
       if ((wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
         if ( (strcmp(wfd.cFileName, ".") != 0) && (strcmp(wfd.cFileName, "..") != 0) )
-          RecursiveScanDirectory(baseDir + "\\" + wfd.cFileName + "\\*.*", f);
+          recursive_scan<finder_function>(baseDir + "\\" + wfd.cFileName + "\\*.*", f);
       }
     } while (FindNextFile(hFind, &wfd));
@@ -76 +82 @@
   FindClose(hFind);
 }
+
 
 
@@ -220 +227 @@
     std::string tstr;
     std::string sName = path.getAlias();
-    GetSize sizeFinder;
-    RecursiveScanDirectory(path.data, sizeFinder);
+    get_size sizeFinder;
+    recursive_scan<get_size>(path.data, sizeFinder);
     path.setDefault(tmpObject);
 
@@ -234 +241 @@
 }
 
+
+struct file_info {
+  file_info() {}
+  file_info(const BY_HANDLE_FILE_INFORMATION info, std::string filename_) : filename(filename_) {
+    ullSize = ((info.nFileSizeHigh * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.nFileSizeLow);
+    ullCreationTime = ((info.ftCreationTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftCreationTime.dwLowDateTime);
+    ullLastAccessTime = ((info.ftLastAccessTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastAccessTime.dwLowDateTime);
+    ullLastWriteTime = ((info.ftLastWriteTime.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)info.ftLastWriteTime.dwLowDateTime);
+  };
+
+  unsigned long long ullSize;
+  unsigned long long ullCreationTime;
+  unsigned long long ullLastAccessTime;
+  unsigned long long ullLastWriteTime;
+  unsigned long long ullNow;
+  std::string filename;
+
+};
+
+struct file_filter {
+  filters::filter_all_numeric<unsigned long long, checkHolders::disk_size_handler<checkHolders::disk_size_type> > fileSize;
+  filters::filter_all_times fileCreation;
+  filters::filter_all_times fileAccessed;
+  filters::filter_all_times fileWritten;
+
+  inline bool hasFilter() {
+    return fileSize.hasFilter() || fileCreation.hasFilter() || 
+      fileAccessed.hasFilter() || fileWritten.hasFilter();
+  }
+  bool matchFilter(const file_info &value) const {
+    if ((fileSize.hasFilter())&&(fileSize.matchFilter(value.ullSize)))
+      return true;
+    else if ((fileCreation.hasFilter())&&(fileCreation.matchFilter(value.ullNow-value.ullCreationTime)))
+      return true;
+    else if ((fileAccessed.hasFilter())&&(fileAccessed.matchFilter(value.ullNow-value.ullLastAccessTime)))
+      return true;
+    else if ((fileWritten.hasFilter())&&(fileWritten.matchFilter(value.ullNow-value.ullLastWriteTime)))
+      return true;
+    return false;
+  }
+};
+
+
+struct find_first_file_info : public baseFinderFunction
+{
+
+  file_info info;
+  bool bError;
+  std::string message;
+  find_first_file_info() : bError(false) {}
+  result_type operator()(argument_type ffd) {
+    if ((ffd.wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
+      return true;
+    BY_HANDLE_FILE_INFORMATION _info;
+
+    HANDLE hFile = CreateFile((ffd.path + "\\" + ffd.wfd.cFileName).c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+      0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+    if (hFile == INVALID_HANDLE_VALUE) {
+      message = "Could not open file: " + ffd.path + "\\" + ffd.wfd.cFileName + ": " + strEx::itos(GetLastError());
+      bError = true;
+      return false;
+    }
+    GetFileInformationByHandle(hFile, &_info);
+    CloseHandle(hFile);
+    info = file_info(_info, ffd.wfd.cFileName);
+    return false;
+  }
+};
+
+struct file_filter_function : public baseFinderFunction
+{
+  std::list<file_filter> filter_chain;
+  bool bFilterAll;
+  bool bFilterIn;
+  bool bError;
+  std::string message;
+  unsigned long long now;
+  unsigned int hit_count;
+
+  file_filter_function() : hit_count(0), bError(false), bFilterIn(true), bFilterAll(true) {}
+  result_type operator()(argument_type ffd) {
+    if ((ffd.wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
+      return true;
+    BY_HANDLE_FILE_INFORMATION _info;
+
+    HANDLE hFile = CreateFile((ffd.path + "\\" + ffd.wfd.cFileName).c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+      0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+    if (hFile == INVALID_HANDLE_VALUE) {
+      message = "Could not open file: " + ffd.path + "\\" + ffd.wfd.cFileName + ": " + strEx::itos(GetLastError());
+      bError = true;
+      return false;
+    }
+    GetFileInformationByHandle(hFile, &_info);
+    CloseHandle(hFile);
+    file_info info(_info, ffd.wfd.cFileName);
+    info.ullNow = now;
+
+    for (std::list<file_filter>::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) {
+      bool bMatch = bFilterAll;
+      bool bTmpMatched = (*cit3).matchFilter(info);
+      if (bFilterAll) {
+        if (!bTmpMatched) {
+          bMatch = false;
+          break;
+        }
+      } else {
+        if (bTmpMatched) {
+          bMatch = true;
+          break;
+        }
+      }
+      if ((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch)) {
+        strEx::append_list(message, info.filename);
+        hit_count++;
+      }
+    }
+    return true;
+  }
+};
+
+NSCAPI::nagiosReturn CheckDisk::getFileAge(const unsigned int argLen, char **char_args, std::string &message, std::string &perf) {
+  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
+  std::list<std::string> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
+  typedef checkHolders::CheckConatiner<checkHolders::MaxMinBoundsUInteger> CheckFileConatiner;
+  if (stl_args.empty()) {
+    message = "Missing argument(s).";
+    return NSCAPI::returnUNKNOWN;
+  }
+  std::string dstr, path;
+  find_first_file_info finder;
+  MAP_OPTIONS_BEGIN(stl_args)
+    MAP_OPTIONS_STR("path", path)
+    MAP_OPTIONS_FALLBACK(dstr)
+  MAP_OPTIONS_END()
+
+  recursive_scan<find_first_file_info>(path, finder);
+  if (finder.bError) {
+    message = "ERROR: could not find file.";
+    return NSCAPI::returnUNKNOWN;
+  }
+  FILETIME now_;
+  GetSystemTimeAsFileTime(&now_);
+  unsigned long long now = ((now_.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now_.dwLowDateTime);
+  time_t value = (now-finder.info.ullLastWriteTime)/10000000;
+
+  char buf[51];
+  int l = strftime(buf, 50, dstr.c_str(), gmtime(&value));
+  if (l <= 0 || l >= 50) {
+    message = "ERROR: could format time.";
+    return NSCAPI::returnUNKNOWN;
+  }
+  buf[l] = 0;
+  message = strEx::itos(value) + "&" + buf;
+  return NSCAPI::returnOK;
+}
+
+
+NSCAPI::nagiosReturn CheckDisk::CheckFile(const unsigned int argLen, char **char_args, std::string &message, std::string &perf) {
+  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
+  std::list<std::string> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
+  typedef checkHolders::CheckConatiner<checkHolders::MaxMinBoundsUInteger> CheckFileConatiner;
+  if (stl_args.empty()) {
+    message = "Missing argument(s).";
+    return NSCAPI::returnUNKNOWN;
+  }
+  file_filter_function finder;
+  PathConatiner tmpObject;
+  std::list<std::string> paths;
+  unsigned int truncate = 0;
+  CheckFileConatiner query;
+
+  try {
+    MAP_OPTIONS_BEGIN(stl_args)
+      MAP_OPTIONS_NUMERIC_ALL(query, "")
+      MAP_OPTIONS_STR2INT("truncate", truncate)
+      MAP_OPTIONS_PUSH("path", paths)
+      MAP_OPTIONS_PUSH("file", paths)
+      MAP_OPTIONS_BOOL_EX("filter", finder.bFilterIn, "in", "out")
+      MAP_OPTIONS_BOOL_EX("filter", finder.bFilterAll, "all", "any")
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, "filter-size", fileSize, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, "filter-creation", fileCreation, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, "filter-written", fileWritten, finder.filter_chain)
+      MAP_OPTIONS_PUSH_WTYPE(file_filter, "filter-accessed", fileAccessed, finder.filter_chain)
+      MAP_OPTIONS_MISSING(message, "Unknown argument: ")
+    MAP_OPTIONS_END()
+  } catch (filters::parse_exception e) {
+    message = e.getMessage();
+    return NSCAPI::returnUNKNOWN;
+  } catch (filters::filter_exception e) {
+    message = e.getMessage();
+    return NSCAPI::returnUNKNOWN;
+  }
+  FILETIME now;
+  GetSystemTimeAsFileTime(&now);
+  finder.now = ((now.dwHighDateTime * ((unsigned long long)MAXDWORD+1)) + (unsigned long long)now.dwLowDateTime);
+
+
+  for (std::list<std::string>::const_iterator pit = paths.begin(); pit != paths.end(); ++pit) {
+    recursive_scan<file_filter_function>((*pit), finder);
+  }
+  message = finder.message;
+  if (finder.bError)
+    return NSCAPI::returnUNKNOWN;
+  query.runCheck(finder.hit_count, returnCode, message, perf);
+  if ((truncate > 0) && (message.length() > (truncate-4)))
+    message = message.substr(0, truncate-4) + "...";
+  if (message.empty())
+    message = "CheckFile is ok";
+  return returnCode;
+}
+
+
 NSCAPI::nagiosReturn CheckDisk::handleCommand(const strEx::blindstr command, const unsigned int argLen, char **char_args, std::string &msg, std::string &perf) {
   if (command == "CheckFileSize") {
@@ -239 +458 @@
   } else if (command == "CheckDriveSize") {
     return CheckDriveSize(argLen, char_args, msg, perf);
+  } else if (command == "CheckFile") {
+    return CheckFile(argLen, char_args, msg, perf);
+  } else if (command == "getFileAge") {
+    return getFileAge(argLen, char_args, msg, perf);
   } 
   return NSCAPI::returnIgnored;

modules/CheckDisk/CheckDisk.h

@@ -33 +33 @@
   NSCAPI::nagiosReturn CheckFileSize(const unsigned int argLen, char **char_args, std::string &message, std::string &perf);
   NSCAPI::nagiosReturn CheckDriveSize(const unsigned int argLen, char **char_args, std::string &message, std::string &perf);
-
+  NSCAPI::nagiosReturn CheckFile(const unsigned int argLen, char **char_args, std::string &message, std::string &perf);
+  NSCAPI::nagiosReturn getFileAge(const unsigned int argLen, char **char_args, std::string &message, std::string &perf);
 
 private:

modules/CheckDisk/stdafx.h

@@ -13 +13 @@
 #include <string>
 #include <functional>
+#include <boost/regex.hpp> 
 
 #include <NSCAPI.h>

modules/CheckEventLog/CheckEventLog.cpp

@@ -40 +40 @@
 class EventLogRecord {
   EVENTLOGRECORD *pevlr_;
-  DWORD currentTime_;
+  __int64 currentTime_;
 public:
-  EventLogRecord(EVENTLOGRECORD *pevlr, DWORD currentTime) : pevlr_(pevlr), currentTime_(currentTime) {
-  }
-  inline DWORD timeGenerated() const {
+  EventLogRecord(EVENTLOGRECORD *pevlr, __int64 currentTime) : pevlr_(pevlr), currentTime_(currentTime) {
+  }
+  inline __int64 timeGenerated() const {
     return (currentTime_-pevlr_->TimeGenerated)*1000;
   }
-  inline DWORD timeWritten() const {
+  inline __int64 timeWritten() const {
     return (currentTime_-pevlr_->TimeWritten)*1000;
   }
   inline std::string eventSource() const {
     return reinterpret_cast<LPSTR>(reinterpret_cast<LPBYTE>(pevlr_) + sizeof(EVENTLOGRECORD));
+  }
+  inline DWORD eventID() const {
+    return (pevlr_->EventID&0xffff);
+  }
+  inline DWORD severity() const {
+    return (pevlr_->EventID>>30);
   }
 
@@ -119 +125 @@
     return strEx::itos(dwType);
   }
-
+  static DWORD translateSeverity(std::string sType) {
+    if (sType == "success")
+      return 0;
+    if (sType == "informational")
+      return 1;
+    if (sType == "warning")
+      return 2;
+    if (sType == "error")
+      return 3;
+    return strEx::stoi(sType);
+  }
+  static std::string translateSeverity(DWORD dwType) {
+    if (dwType == 0)
+      return "success";
+    if (dwType == 1)
+      return "informational";
+    if (dwType == 2)
+      return "warning";
+    if (dwType == 3)
+      return "error";
+    return strEx::itos(dwType);
+  }
 };
 
@@ -126 +153 @@
   filters::filter_all_strings eventSource;
   filters::filter_all_numeric<unsigned int, filters::handlers::eventtype_handler> eventType;
+  filters::filter_all_numeric<unsigned int, filters::handlers::eventseverity_handler> eventSeverity;
   filters::filter_all_strings message;
   filters::filter_all_times timeWritten;
   filters::filter_all_times timeGenerated;
+  filters::filter_all_numeric<DWORD, filters::handlers::eventtype_handler> eventID;
 
   inline bool hasFilter() {
-    return eventSource.hasFilter() || eventType.hasFilter() || message.hasFilter() || 
+    return eventSource.hasFilter() || eventType.hasFilter() || eventID.hasFilter() || eventSeverity.hasFilter() || message.hasFilter() || 
       timeWritten.hasFilter() || timeGenerated.hasFilter();
   }
@@ -138 +167 @@
       return true;
     else if ((eventType.hasFilter())&&(eventType.matchFilter(value.eventType())))
+      return true;
+    else if ((eventSeverity.hasFilter())&&(eventSeverity.matchFilter(value.severity())))
+      return true;
+    else if ((eventID.hasFilter())&&(eventID.matchFilter(value.eventID()))) 
       return true;
     else if ((message.hasFilter())&&(message.matchFilter(value.enumStrings())))
@@ -180 +213 @@
       MAP_OPTIONS_BOOL_EX("filter", bFilterAll, "all", "any")
       MAP_FILTER("filter-eventType", eventType)
+      MAP_FILTER("filter-severity", eventSeverity)
+      MAP_FILTER("filter-eventID", eventID)
       MAP_FILTER("filter-eventSource", eventSource)
       MAP_FILTER("filter-generated", timeGenerated)
@@ -211 +246 @@
     __time64_t ltime;
     _time64(&ltime);
-    DWORD currentTime = ltime;
 
     GetOldestEventLogRecord(hLog, &dwThisRecord);
@@ -221 +255 @@
       { 
         bool bMatch = bFilterAll;
-        EventLogRecord record(pevlr, currentTime);
+        EventLogRecord record(pevlr, ltime);
 
         for (std::list<eventlog_filter>::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) {
@@ -241 +275 @@
           strEx::append_list(message, record.eventSource());
           if (bShowDescriptions) {
-            message += "(" + EventLogRecord::translateType(record.eventType()) + ")";
+            message += "(" + EventLogRecord::translateType(record.eventType()) + ", " + strEx::itos(record.eventID()) + ", " + EventLogRecord::translateSeverity(record.severity()) + ")";
             message += "[" + record.enumStrings() + "]";
           }

modules/CheckSystem/CheckSystem.cpp

@@ -10 +10 @@
 #include <sysinfo.h>
 #include <checkHelpers.hpp>
+#include <map>
 
 CheckSystem gNSClientCompat;
@@ -137 +138 @@
 }
 
+
+class cpuload_handler {
+public:
+  static int parse(std::string s) {
+    return strEx::stoi(s);
+  }
+  static int parse_percent(std::string s) {
+    return strEx::stoi(s);
+  }
+  static std::string print(int value) {
+    return strEx::itos(value) + "%";
+  }
+  static std::string print_unformated(int value) {
+    return strEx::itos(value);
+  }
+  static std::string print_percent(int value) {
+    return strEx::itos(value) + "%";
+  }
+  static std::string key_prefix() {
+    return "average load ";
+  }
+  static std::string key_postfix() {
+    return "";
+  }
+};
 NSCAPI::nagiosReturn CheckSystem::checkCPU(const unsigned int argLen, char **char_args, std::string &msg, std::string &perf) 
 {
-  typedef checkHolders::CheckConatiner<checkHolders::MaxMinBoundsInteger> CPULoadConatiner;
+  typedef checkHolders::CheckConatiner<checkHolders::MaxMinBounds<checkHolders::NumericBounds<int, cpuload_handler> > > CPULoadConatiner;
 
   std::list<std::string> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
@@ -179 +205 @@
       return NSCAPI::returnUNKNOWN;
     }
+    int value = pObject->getCPUAvrage(load.data + "m");
+    if (value == -1) {
+      msg = "ERROR: We don't collect data this far back: " + load.getAlias();
+      return NSCAPI::returnUNKNOWN;
+    }
     if (bNSClient) {
-      int value = pObject->getCPUAvrage(load.data + "m");
-      if (value == -1) {
-        msg = "ERROR: We don't collect data this far back: " + load.getAlias();
-        return NSCAPI::returnUNKNOWN;
-      }
       if (!msg.empty()) msg += "&";
       msg += strEx::itos(value);
     } else {
-      int value = pObject->getCPUAvrage(load.data);
-      if (value == -1) {
-        msg = "ERROR: We don't collect data this far back: " + load.getAlias();
-        return NSCAPI::returnUNKNOWN;
-      } else {
-        load.setDefault(tmpObject);
-        load.runCheck(value, returnCode, msg, perf);
-      }
+      load.setDefault(tmpObject);
+      load.runCheck(value, returnCode, msg, perf);
     }
   }
@@ -380 +400 @@
 NSCAPI::nagiosReturn CheckSystem::checkMem(const unsigned int argLen, char **char_args, std::string &msg, std::string &perf)
 {
-  typedef checkHolders::CheckConatiner<checkHolders::MaxMinPercentageBoundsDiskSizei64 > MemoryConatiner;
+  typedef checkHolders::CheckConatiner<checkHolders::MaxMinBounds<checkHolders::NumericPercentageBounds<checkHolders::PercentageValueType<unsigned __int64, unsigned __int64>, checkHolders::disk_size_handler<unsigned __int64> > > > MemoryConatiner;
   std::list<std::string> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
   if (stl_args.empty()) {
@@ -390 +410 @@
   bool bNSClient = false;
   MemoryConatiner bounds;
-
-  bounds.data = "page";
+  typedef enum { tPaged, tPage, tVirtual, tPhysical } check_type;
+  check_type type = tPaged;
 
   MAP_OPTIONS_BEGIN(stl_args)
@@ -398 +418 @@
     MAP_OPTIONS_SHOWALL(bounds)
     MAP_OPTIONS_BOOL_TRUE(NSCLIENT, bNSClient)
+    MAP_OPTIONS_MODE("type", "paged", type, tPaged)
+    MAP_OPTIONS_MODE("type", "page", type, tPage)
+    MAP_OPTIONS_MODE("type", "virtual", type, tVirtual)
+    MAP_OPTIONS_MODE("type", "physical", type, tPhysical)
     MAP_OPTIONS_MISSING(msg, "Unknown argument: ")
   MAP_OPTIONS_END()
 
-  PDHCollector *pObject = pdhThread.getThread();
-  if (!pObject) {
-    msg = "ERROR: PDH Collection thread not running.";
-    return NSCAPI::returnUNKNOWN;
-  }
-  checkHolders::PercentageValueType<long long, long long> value;
-  value.value = pObject->getMemCommit();
-  value.total = pObject->getMemCommitLimit();
+
+  checkHolders::PercentageValueType<unsigned long long, unsigned long long> value;
+  if (type == tPaged) {
+    PDHCollector *pObject = pdhThread.getThread();
+    if (!pObject) {
+      msg = "ERROR: PDH Collection thread not running.";
+      return NSCAPI::returnUNKNOWN;
+    }
+    value.value = pObject->getMemCommit();
+    value.total = pObject->getMemCommitLimit();
+    if (bounds.data.empty())
+      bounds.data = "paged bytes";
+  } else {
+    CheckMemory::memData data;
+    try {
+      data = memoryChecker.getMemoryStatus();
+    } catch (CheckMemoryException e) {
+      msg = e.getError() + ":" + strEx::itos(e.getErrorCode());
+      return NSCAPI::returnCRIT;
+    }
+//    MEMORYSTATUS mem;
+//    GlobalMemoryStatus(&mem);
+    if (type == tPage) {
+      value.value = data.pageFile.total-data.pageFile.avail; // mem.dwTotalPageFile-mem.dwAvailPageFile;
+      value.total = data.pageFile.total; //mem.dwTotalPageFile;
+      if (bounds.data.empty())
+        bounds.data = "page file";
+    } else  if (type == tPhysical) {
+      value.value = data.phys.total-data.phys.avail; //mem.dwTotalPhys-mem.dwAvailPhys;
+      value.total = data.phys.total; //mem.dwTotalPhys;
+      if (bounds.data.empty())
+        bounds.data = "physical memory";
+    } else  if (type == tVirtual) {
+      value.value = data.virtualMem.total-data.virtualMem.avail;//mem.dwTotalVirtual-mem.dwAvailVirtual;
+      value.total = data.virtualMem.total;//mem.dwTotalVirtual;
+      if (bounds.data.empty())
+        bounds.data = "virtual memory";
+    }
+  }
+
   if (bNSClient) {
     msg = strEx::itos(value.total) + "&" + strEx::itos(value.value);
@@ -431 +487 @@
   CEnumProcess::CProcessEntry entry;
 } NSPROCDATA;
-typedef std::hash_map<std::string,NSPROCDATA> NSPROCLST;
+typedef std::map<std::string,NSPROCDATA,strEx::case_blind_string_compare> NSPROCLST;
 /**
 * Get a hash_map with all running processes.
@@ -613 +669 @@
       pdh.addCounter(counter.data, &cDouble);
       pdh.open();
-      pdh.collect();
-      Sleep(1000);
+      if (bCheckAverages) {
+        pdh.collect();
+        Sleep(1000);
+      }
       pdh.gatherData();
       pdh.close();

modules/CheckSystem/CheckSystem.h

@@ -1 +1 @@
 #pragma once
 #include "PDHCollector.h"
+#include <CheckMemory.h>
 
 NSC_WRAPPERS_MAIN();
@@ -6 +7 @@
 class CheckSystem {
 private:
+  CheckMemory memoryChecker;
   int processMethod_;
   PDHCollectorThread pdhThread;

modules/CheckSystem/PDHCollector.cpp

@@ -199 +199 @@
 * @return Some form of memory check
 */
-long long PDHCollector::getMemCommitLimit() {
+unsigned long long PDHCollector::getMemCommitLimit() {
   MutexLock mutex(mutexHandler);
   if (!mutex.hasMutex()) {
@@ -212 +212 @@
 * @return Some form of memory check
 */
-long long PDHCollector::getMemCommit() {
+unsigned long long PDHCollector::getMemCommit() {
   MutexLock mutex(mutexHandler);
   if (!mutex.hasMutex()) {

modules/CheckSystem/PDHCollector.h

@@ -30 +30 @@
   int checkIntervall_;
 
-  PDHCollectors::StaticPDHCounterListener<__int64, PDHCollectors::format_large> memCmtLim;
-  PDHCollectors::StaticPDHCounterListener<__int64, PDHCollectors::format_large> memCmt;
+  PDHCollectors::StaticPDHCounterListener<unsigned __int64, PDHCollectors::format_large> memCmtLim;
+  PDHCollectors::StaticPDHCounterListener<unsigned __int64, PDHCollectors::format_large> memCmt;
   PDHCollectors::StaticPDHCounterListener<__int64, PDHCollectors::format_large> upTime;
   PDHCollectors::RoundINTPDHBufferListener<__int64, PDHCollectors::format_large> cpu;
@@ -44 +44 @@
   int getCPUAvrage(std::string time);
   long long getUptime();
-  long long getMemCommitLimit();
-  long long getMemCommit();
+  unsigned long long getMemCommitLimit();
+  unsigned long long getMemCommit();
 
 

modules/FileLogger/FileLogger.cpp

@@ -53 +53 @@
   struct tm *today = _localtime64( &ltime );
   if (today) {
-    int len = strftime(buffer, 63, format_.c_str(), today);
+    size_t len = strftime(buffer, 63, format_.c_str(), today);
     if ((len < 1)||(len > 64))
       strncpy(buffer, "???", 63);

modules/NSClientListener/NSClientListener.cpp

@@ -18 +18 @@
 #define REQ_PROCSTATE   6 // Works fine!
 #define REQ_MEMUSE      7 // Works fine!
-#define REQ_COUNTER     8 // ... in the works ...
-//#define REQ_FILEAGE   9 // ! - not implemented Don't know how to use
+#define REQ_COUNTER     8 // Works fine!
+#define REQ_FILEAGE     9 // ... in the works ...
 //#define REQ_INSTANCES 10  // ! - not implemented Don't know how to use
 
@@ -152 +152 @@
       cmd.second += "&nsclient";
       break;
+    case REQ_FILEAGE:
+      cmd.first = "getFileAge";
+      cmd.second = "path=" + cmd.second;
+      break;
   }
 
@@ -168 +172 @@
     case REQ_USEDDISKSPACE:
     case REQ_COUNTER:
+    case REQ_FILEAGE:
       return message;
 
@@ -191 +196 @@
   }
   simpleSocket::DataBuffer db;
-
-
 
   for (int i=0;i<100;i++) {

modules/SysTray/SysTray.cpp

@@ -5 +5 @@
 #include "SysTray.h"
 #include "TrayIcon.h"
+#include <ServiceCmd.h>
+#include <config.h>
 
 SysTray gSysTray;
@@ -17 +19 @@
 SysTray::~SysTray() {}
 bool SysTray::loadModule() {
+  std::cout << "Systray: " << serviceControll::GetServiceType(SZSERVICENAME) << std::endl;
+  if ((serviceControll::GetServiceType(SZSERVICENAME)&SERVICE_INTERACTIVE_PROCESS)!=SERVICE_INTERACTIVE_PROCESS) {
+    NSC_LOG_ERROR("SysTray is not installed (or it cannot interact with the desktop) SysTray wont be loaded. Run " SZAPPNAME " SysTray install ti change this.");
+    return true;
+  }
   icon.createThread();
   return true;
@@ -29 +36 @@
 }
 
+int SysTray::commandLineExec(const char* command,const unsigned int argLen,char** args) {
+  if (stricmp(command, "install") == 0) {
+    try {
+      serviceControll::ModifyServiceType(SZSERVICENAME, SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS);
+      NSC_LOG_MESSAGE(MODULE_NAME " is now able to run as the SERVICE_INTERACTIVE_PROCESS flag has been set.");
+    } catch (const serviceControll::SCException& e) {
+      NSC_LOG_ERROR("Could not modify service: " + e.error_);
+      return -1;
+    }
+  } else if (stricmp(command, "uninstall") == 0) {
+    try {
+      serviceControll::ModifyServiceType(SZSERVICENAME, SERVICE_WIN32_OWN_PROCESS);
+      NSC_LOG_MESSAGE(MODULE_NAME " is now not able to run as the SERVICE_INTERACTIVE_PROCESS flag has been reset.");
+    } catch (const serviceControll::SCException& e) {
+      NSC_LOG_ERROR("Could not modify service: " + e.error_);
+      return -1;
+    }
+  }
+  return 0;
+}
 
 bool SysTray::hasCommandHandler() {
@@ -40 +67 @@
 NSC_WRAPPERS_IGNORE_MSG_DEF();
 NSC_WRAPPERS_IGNORE_CMD_DEF();
+NSC_WRAPPERS_CLI_DEF(gSysTray);
 

modules/SysTray/SysTray.def

@@ -12 +12 @@
   NSUnloadModule
   NSGetModuleDescription
+  NSCommandLineExec

modules/SysTray/SysTray.h

@@ -4 +4 @@
 
 NSC_WRAPPERS_MAIN();
+NSC_WRAPPERS_CLI();
 
+
+#define MODULE_NAME "SystemTray"
 class SysTray {
 private:
@@ -17 +20 @@
 
   std::string getModuleName() {
-    return "System Tray icon";
+    return MODULE_NAME;
   }
   NSCModuleWrapper::module_version getModuleVersion() {
@@ -30 +33 @@
   bool hasCommandHandler();
   bool hasMessageHandler();
+  int commandLineExec(const char* command,const unsigned int argLen,char** args);
+
 };

modules/SysTray/SysTray.vcproj

@@ -170 +170 @@
       <File
         RelativePath="..\..\include\NSCHelper.cpp">
+      </File>
+      <File
+        RelativePath="..\..\include\ServiceCmd.cpp">
       </File>
       <File
@@ -216 +219 @@
       </File>
       <File
+        RelativePath="..\..\include\ServiceCmd.h">
+      </File>
+      <File
         RelativePath=".\stdafx.h">
       </File>