source: nscp/modules/CheckEventLog/CheckEventLog.cpp @ d05c3f0

0.4.00.4.10.4.2
Last change on this file since d05c3f0 was 7f9c823, checked in by Michael Medin <michael@…>, 4 years ago

First attempt at serious boostification.
NOTICE! This is NOT a complete edition, it build and runs but many features are disabled and/or broken.
But we have working, sockets and mutexes and conversion functions from boost inside now and more to come...
Also started to build with CMake since it works better then boost.build
  • Property mode set to 100644
File size: 28.3 KB
Line 
1/**************************************************************************
2*   Copyright (C) 2004-2007 by Michael Medin <michael@medin.name>         *
3*                                                                         *
4*   This code is part of NSClient++ - http://trac.nakednuns.org/nscp      *
5*                                                                         *
6*   This program is free software; you can redistribute it and/or modify  *
7*   it under the terms of the GNU General Public License as published by  *
8*   the Free Software Foundation; either version 2 of the License, or     *
9*   (at your option) any later version.                                   *
10*                                                                         *
11*   This program is distributed in the hope that it will be useful,       *
12*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
13*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
14*   GNU General Public License for more details.                          *
15*                                                                         *
16*   You should have received a copy of the GNU General Public License     *
17*   along with this program; if not, write to the                         *
18*   Free Software Foundation, Inc.,                                       *
19*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
20***************************************************************************/
21
22#include "stdafx.h"
23#include "CheckEventLog.h"
24#include <filter_framework.hpp>
25
26#include <strEx.h>
27#include <time.h>
28#include <utils.h>
29#include <error.hpp>
30#include <map>
31#include <vector>
32#include <config.h>
33
34CheckEventLog gCheckEventLog;
35
36BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
37{
38        NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
39        return TRUE;
40}
41
42CheckEventLog::CheckEventLog() {
43}
44CheckEventLog::~CheckEventLog() {
45}
46
47
48bool CheckEventLog::loadModule(NSCAPI::moduleLoadMode mode) {
49        try {
50                SETTINGS_REG_PATH(event_log::SECTION);
51                SETTINGS_REG_KEY_B(event_log::DEBUG_KEY);
52                SETTINGS_REG_KEY_S(event_log::SYNTAX);
53
54                NSCModuleHelper::registerCommand(_T("CheckEventLog"), _T("Check for errors in the event logger!"));
55                debug_ = SETTINGS_GET_BOOL(event_log::DEBUG_KEY);
56                lookup_names_ = SETTINGS_GET_BOOL(event_log::LOOKUP_NAMES);
57                syntax_ = SETTINGS_GET_STRING(event_log::SYNTAX);
58                buffer_length_ = SETTINGS_GET_INT(event_log::BUFFER_SIZE);
59        } catch (NSCModuleHelper::NSCMHExcpetion &e) {
60                NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_);
61        } catch (...) {
62                NSC_LOG_ERROR_STD(_T("Failed to register command."));
63        }
64        return true;
65}
66bool CheckEventLog::unloadModule() {
67        return true;
68}
69
70bool CheckEventLog::hasCommandHandler() {
71        return true;
72}
73bool CheckEventLog::hasMessageHandler() {
74        return false;
75}
76
77namespace simple_registry {
78        class registry_exception {
79                std::wstring what_;
80        public:
81                registry_exception(std::wstring what) : what_(what) {}
82                registry_exception(std::wstring path, std::wstring what) : what_(path + _T(" -- ") + what) {}
83                registry_exception(std::wstring path, std::wstring key, std::wstring what) : what_(path + _T(".") + key + _T(" -- ") + what) {}
84                std::wstring what() {
85                        return what_;
86                }
87        };
88        class registry_key {
89                HKEY hKey_;
90                std::wstring path_;
91                BYTE *bData_;
92                TCHAR *buffer_;
93        public:
94                registry_key(HKEY hRootKey, std::wstring path) : path_(path), hKey_(NULL), bData_(NULL), buffer_(NULL) {
95                        LONG lRet = ERROR_SUCCESS;
96                        if (lRet = RegOpenKeyEx(hRootKey, path.c_str(), 0, KEY_QUERY_VALUE|KEY_READ, &hKey_) != ERROR_SUCCESS)
97                                throw registry_exception(path, _T("Failed to open key: ") + error::format::from_system(lRet));
98                }
99                ~registry_key() {
100                        if (hKey_ != NULL)
101                                RegCloseKey(hKey_);
102                        delete [] bData_;
103                        delete [] buffer_;
104                }
105                std::wstring get_string(std::wstring key, DWORD buffer_length = 2048) {
106                        DWORD type;
107                        std::wstring ret;
108                        DWORD cbData = buffer_length;
109                        delete [] bData_;
110                        bData_ = new BYTE[cbData+2];
111                        // TODO: add get size here !
112                        LONG lRet = RegQueryValueEx(hKey_, key.c_str(), NULL, &type, bData_, &cbData);
113                        if (lRet != ERROR_SUCCESS)
114                                throw registry_exception(path_, key, _T("Failed to get value: ") + error::format::from_system(lRet));
115                        if (cbData >= buffer_length || cbData < 0)
116                                throw registry_exception(path_, key, _T("Failed to get value: buffer to small"));
117                        bData_[cbData] = 0;
118                        if (type == REG_SZ) {
119                                ret = reinterpret_cast<LPCTSTR>(bData_);
120                        } else if (type == REG_EXPAND_SZ) {
121                                std::wstring s = reinterpret_cast<LPCTSTR>(bData_);
122                                delete [] buffer_;
123                                buffer_ = new TCHAR[buffer_length+1];
124                                DWORD expRet = ExpandEnvironmentStrings(s.c_str(), buffer_, buffer_length);
125                                if (expRet >= buffer_length)
126                                        throw registry_exception(path_, key, _T("Buffer to small (expand)"));
127                                else
128                                        ret = buffer_;
129                        } else {
130                                throw registry_exception(path_, key, _T("Unknown type (not a string)"));
131                        }
132                        return ret;
133                }
134                DWORD get_int(std::wstring key) {
135                        DWORD type;
136                        DWORD cbData = sizeof(DWORD);
137                        DWORD ret = 0;
138                        LONG lRet = RegQueryValueEx(hKey_, key.c_str(), NULL, &type, reinterpret_cast<LPBYTE>(&ret), &cbData);
139                        if (lRet != ERROR_SUCCESS)
140                                throw registry_exception(path_, key, _T("Failed to get value: ") + error::format::from_system(lRet));
141                        if (type != REG_DWORD)
142                                throw registry_exception(path_, key, _T("Unknown type (not a DWORD)"));
143                        return ret;
144                }
145
146                std::list<std::wstring> get_keys(DWORD buffer_length = 2048) {
147                        std::list<std::wstring> ret;
148                        DWORD cSubKeys=0;
149                        DWORD cMaxKeyLen;
150                        // Get the class name and the value count.
151                        LONG lRet = RegQueryInfoKey(hKey_,NULL,NULL,NULL,&cSubKeys,&cMaxKeyLen,NULL,NULL,NULL,NULL,NULL,NULL);
152                        if (lRet != ERROR_SUCCESS)
153                                throw registry_exception(path_, _T("Failed to query key info: ") + error::format::from_system(lRet));
154                        if (cSubKeys == 0)
155                                return ret;
156                        delete [] buffer_;
157                        buffer_ = new TCHAR[cMaxKeyLen+20];
158                        for (unsigned int i=0; i<cSubKeys; i++) {
159                                lRet = RegEnumKey(hKey_, i, buffer_, cMaxKeyLen+10);
160                                if (lRet != ERROR_SUCCESS) {
161                                        throw registry_exception(path_, _T("Failed to enumerate: ") + error::lookup::last_error(lRet));
162                                }
163                                std::wstring str = buffer_;
164                                ret.push_back(str);
165                        }
166                        return ret;
167                }
168
169        };
170       
171        std::wstring get_string(HKEY hKey, std::wstring path, std::wstring key) {
172                registry_key reg(hKey, path);
173                return reg.get_string(key);
174        }
175}
176
177std::wstring find_eventlog_name(std::wstring name) {
178        try {
179                simple_registry::registry_key key(HKEY_LOCAL_MACHINE, _T("SYSTEM\\CurrentControlSet\\Services\\EventLog"));
180                std::list<std::wstring> list = key.get_keys();
181                for (std::list<std::wstring>::const_iterator cit = list.begin(); cit != list.end(); ++cit) {
182                        try {
183                                simple_registry::registry_key sub_key(HKEY_LOCAL_MACHINE, _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\") + *cit);
184                                std::wstring file = sub_key.get_string(_T("DisplayNameFile"));
185                                int id = sub_key.get_int(_T("DisplayNameID"));
186                                std::wstring real_name = error::format::message::from_module(file, id);
187                                strEx::replace(real_name, _T("\n"), _T(""));
188                                strEx::replace(real_name, _T("\r"), _T(""));
189                                NSC_DEBUG_MSG(_T("Attempting to match: ") + real_name + _T(" with ") + name);
190                                if (real_name == name)
191                                        return *cit;
192                        } catch (simple_registry::registry_exception &e) {}
193                }
194                return name;
195        } catch (simple_registry::registry_exception &e) {
196                NSC_DEBUG_MSG(_T("Failed to get eventlog name (assuming shorthand): ") + e.what());
197                return name;
198        } catch (...) {
199                NSC_DEBUG_MSG(_T("Failed to get eventlog name (assuming shorthand)"));
200                return name;
201        }
202}
203
204class EventLogRecord {
205        EVENTLOGRECORD *pevlr_;
206        __int64 currentTime_;
207        std::wstring file_;
208public:
209        EventLogRecord(std::wstring file, EVENTLOGRECORD *pevlr, __int64 currentTime) : file_(file), pevlr_(pevlr), currentTime_(currentTime) {
210        }
211        inline __int64 timeGenerated() const {
212                return (currentTime_-pevlr_->TimeGenerated)*1000;
213        }
214        inline __int64 timeWritten() const {
215                return (currentTime_-pevlr_->TimeWritten)*1000;
216        }
217        inline std::wstring eventSource() const {
218                return reinterpret_cast<WCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + sizeof(EVENTLOGRECORD));
219        }
220        inline DWORD eventID() const {
221                return (pevlr_->EventID&0xffff);
222        }
223        inline DWORD severity() const {
224                return (pevlr_->EventID>>30);
225        }
226
227        inline DWORD eventType() const {
228                return pevlr_->EventType;
229        }
230/*
231        std::wstring userSID() const {
232                if (pevlr_->UserSidOffset == 0)
233                        return "";
234                PSID p = reinterpret_cast<PSID>(reinterpret_cast<LPBYTE>(pevlr_) + + pevlr_->UserSidOffset);
235                LPSTR user = new CHAR[1025];
236                LPSTR domain = new CHAR[1025];
237                DWORD userLen = 1024;
238                DWORD domainLen = 1024;
239                SID_NAME_USE sidName;
240                LookupAccountSid(NULL, p, user, &userLen, domain, &domainLen, &sidName);
241                user[userLen] = 0;
242                domain[domainLen] = 0;
243                return std::wstring(domain) + "\\" + std::wstring(user);
244        }
245        */
246
247        std::wstring enumStrings() const {
248                std::wstring ret;
249                TCHAR* p = reinterpret_cast<TCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + pevlr_->StringOffset);
250                for (unsigned int i =0;i<pevlr_->NumStrings;i++) {
251                        std::wstring s = p;
252                        if (!s.empty())
253                                s += _T(", ");
254                        ret += s;
255                        p+= wcslen(p)+1;
256                }
257                return ret;
258        }
259
260        static DWORD appendType(DWORD dwType, std::wstring sType) {
261                return dwType | translateType(sType);
262        }
263        static DWORD subtractType(DWORD dwType, std::wstring sType) {
264                return dwType & (!translateType(sType));
265        }
266        static DWORD translateType(std::wstring sType) {
267                if (sType == _T("error"))
268                        return EVENTLOG_ERROR_TYPE;
269                if (sType == _T("warning"))
270                        return EVENTLOG_WARNING_TYPE;
271                if (sType == _T("info"))
272                        return EVENTLOG_INFORMATION_TYPE;
273                if (sType == _T("auditSuccess"))
274                        return EVENTLOG_AUDIT_SUCCESS;
275                if (sType == _T("auditFailure"))
276                        return EVENTLOG_AUDIT_FAILURE;
277                return strEx::stoi(sType);
278        }
279        static std::wstring translateType(DWORD dwType) {
280                if (dwType == EVENTLOG_ERROR_TYPE)
281                        return _T("error");
282                if (dwType == EVENTLOG_WARNING_TYPE)
283                        return _T("warning");
284                if (dwType == EVENTLOG_INFORMATION_TYPE)
285                        return _T("info");
286                if (dwType == EVENTLOG_AUDIT_SUCCESS)
287                        return _T("auditSuccess");
288                if (dwType == EVENTLOG_AUDIT_FAILURE)
289                        return _T("auditFailure");
290                return strEx::itos(dwType);
291        }
292        static DWORD translateSeverity(std::wstring sType) {
293                if (sType == _T("success"))
294                        return 0;
295                if (sType == _T("informational"))
296                        return 1;
297                if (sType == _T("warning"))
298                        return 2;
299                if (sType == _T("error"))
300                        return 3;
301                return strEx::stoi(sType);
302        }
303        static std::wstring translateSeverity(DWORD dwType) {
304                if (dwType == 0)
305                        return _T("success");
306                if (dwType == 1)
307                        return _T("informational");
308                if (dwType == 2)
309                        return _T("warning");
310                if (dwType == 3)
311                        return _T("error");
312                return strEx::itos(dwType);
313        }
314        std::wstring get_dll() {
315                try {
316                        return simple_registry::get_string(HKEY_LOCAL_MACHINE, _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\") + file_ + (std::wstring)_T("\\") + eventSource(), _T("EventMessageFile"));
317                } catch (simple_registry::registry_exception &e) {
318                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource() + _T(": ") + e.what());
319                        return _T("");
320                }
321        }
322
323        std::wstring render_message() {
324                std::vector<std::wstring> args;
325                TCHAR* *pArgs = new TCHAR*[pevlr_->NumStrings+1];
326                TCHAR* p = reinterpret_cast<TCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + pevlr_->StringOffset);
327                for (unsigned int i =0;i<pevlr_->NumStrings;i++) {
328                        args.push_back(p);
329                        pArgs[i] = p;
330                        DWORD len = wcslen(p);
331                        p = &(p[len+1]);
332                        //p += len+1;
333                }
334
335                std::wstring ret;
336                strEx::splitList dlls = strEx::splitEx(get_dll(), _T(";"));
337                for (strEx::splitList::const_iterator cit = dlls.begin(); cit != dlls.end(); ++cit) {
338                        //std::wstring msg = error::format::message::from_module((*cit), eventID(), _sz);
339                        std::wstring msg;
340                        try {
341                                msg = error::format::message::from_module_x64((*cit), eventID(), pArgs, pevlr_->NumStrings);
342                                if (msg.empty()) {
343                                        msg = error::format::message::from_module_x64((*cit), pevlr_->EventID, pArgs, pevlr_->NumStrings);
344                                }
345                        } catch (...) {
346                                msg = _T("Unknown exception getting message");
347                        }
348                        strEx::replace(msg, _T("\n"), _T(" "));
349                        strEx::replace(msg, _T("\t"), _T(" "));
350                        std::string::size_type pos = msg.find_last_not_of(_T("\n\t "));
351                        if (pos != std::string::npos) {
352                                msg = msg.substr(0,pos);
353                        }
354                        if (!msg.empty()) {
355                                if (!ret.empty())
356                                        ret += _T(", ");
357                                ret += msg;
358                        }
359                }
360                delete [] pArgs;
361                return ret;
362        }
363        // SYSTEMTIME
364        boost::posix_time::ptime get_time(DWORD time) {
365                FILETIME FileTime, LocalFileTime;
366                SYSTEMTIME SysTime;
367                __int64 lgTemp;
368                __int64 SecsTo1970 = 116444736000000000;
369
370                lgTemp = Int32x32To64(time,10000000) + SecsTo1970;
371
372                FileTime.dwLowDateTime = (DWORD) lgTemp;
373                FileTime.dwHighDateTime = (DWORD)(lgTemp >> 32);
374
375                return boost::date_time::time_from_ftime<boost::posix_time::ptime>(FileTime);
376
377
378/*
379                FileTimeToLocalFileTime(&FileTime, &LocalFileTime);
380                FileTimeToSystemTime(&LocalFileTime, &SysTime);
381                return SysTime;
382                */
383        }
384
385        boost::posix_time::ptime get_time_generated() {
386                return get_time(pevlr_->TimeGenerated);
387        }
388        boost::posix_time::ptime get_time_written() {
389                return get_time(pevlr_->TimeWritten);
390        }
391
392        std::wstring render(bool propper, std::wstring syntax, std::wstring date_format = DATE_FORMAT) {
393                if (propper) {
394                        // To obtain the appropriate message string from the message file, load the message file with the LoadLibrary function and use the FormatMessage function
395                        strEx::replace(syntax, _T("%message%"), render_message());
396                } else {
397                        strEx::replace(syntax, _T("%message%"), _T("%message% needs the descriptions flag set!"));
398                }
399
400                strEx::replace(syntax, _T("%source%"), eventSource());
401                strEx::replace(syntax, _T("%generated%"), strEx::format_date(get_time_generated(), date_format));
402                strEx::replace(syntax, _T("%written%"), strEx::format_date(get_time_written(), date_format));
403                strEx::replace(syntax, _T("%type%"), translateType(eventType()));
404                strEx::replace(syntax, _T("%severity%"), translateSeverity(severity()));
405                strEx::replace(syntax, _T("%strings%"), enumStrings());
406                strEx::replace(syntax, _T("%id%"), strEx::itos(eventID()));
407                return syntax;
408        }
409};
410/*
411return (pevlr_->EventID&0xffff);
412}
413inline DWORD severity() const {
414return (pevlr_->EventID>>30);
415*/
416class uniq_eventlog_record {
417        DWORD ID;
418        WORD type;
419        WORD category;
420public:
421        std::wstring message;
422        uniq_eventlog_record(EVENTLOGRECORD *pevlr) : ID(pevlr->EventID&0xffff), type(pevlr->EventType), category(pevlr->EventCategory) {}
423        bool operator< (const uniq_eventlog_record &other) const {
424                return (ID < other.ID) || ((ID==other.ID)&&(type < other.type)) || (ID==other.ID&&type==other.type)&&(category < other.category);
425        }
426        std::wstring to_string() const {
427                return _T("id=") + strEx::itos(ID) + _T("type=") + strEx::itos(type) + _T("category=") + strEx::itos(category);
428        }
429};
430typedef std::map<uniq_eventlog_record,unsigned int> uniq_eventlog_map;
431
432
433struct eventlog_filter {
434        filters::filter_all_strings eventSource;
435        filters::filter_all_numeric<unsigned int, filters::handlers::eventtype_handler> eventType;
436        filters::filter_all_numeric<unsigned int, filters::handlers::eventseverity_handler> eventSeverity;
437        filters::filter_all_strings message;
438        filters::filter_all_times timeWritten;
439        filters::filter_all_times timeGenerated;
440        filters::filter_all_numeric<DWORD, filters::handlers::eventtype_handler> eventID;
441        std::wstring value_;
442
443        inline bool hasFilter() {
444                return eventSource.hasFilter() || eventType.hasFilter() || eventID.hasFilter() || eventSeverity.hasFilter() || message.hasFilter() ||
445                        timeWritten.hasFilter() || timeGenerated.hasFilter();
446        }
447        std::wstring getValue() const {
448                if (eventSource.hasFilter())
449                        return _T("event-source: ") + eventSource.getValue();
450                if (eventType.hasFilter())
451                        return _T("event-type: ") + eventType.getValue();
452                if (eventSeverity.hasFilter())
453                        return _T("severity: ") + eventSeverity.getValue();
454                if (eventID.hasFilter())
455                        return _T("event-id: ") + eventID.getValue();
456                if (message.hasFilter())
457                        return _T("message: ") + message.getValue();
458                if (timeWritten.hasFilter())
459                        return _T("time-written: ") + timeWritten.getValue();
460                if (timeGenerated.hasFilter())
461                        return _T("time-generated: ") + timeGenerated.getValue();
462                return _T("UNknown...");
463        }
464        bool matchFilter(const EventLogRecord &value) const {
465                if ((eventSource.hasFilter())&&(eventSource.matchFilter(value.eventSource())))
466                        return true;
467                else if ((eventType.hasFilter())&&(eventType.matchFilter(value.eventType())))
468                        return true;
469                else if ((eventSeverity.hasFilter())&&(eventSeverity.matchFilter(value.severity())))
470                        return true;
471                else if ((eventID.hasFilter())&&(eventID.matchFilter(value.eventID())))
472                        return true;
473                else if ((message.hasFilter())&&(message.matchFilter(value.enumStrings())))
474                        return true;
475                else if ((timeWritten.hasFilter())&&(timeWritten.matchFilter(value.timeWritten())))
476                        return true;
477                else if ((timeGenerated.hasFilter())&&(timeGenerated.matchFilter(value.timeGenerated())))
478                        return true;
479                return false;
480        }
481};
482
483
484#define MAP_FILTER(value, obj, filtermode) \
485                        else if (p__.first == value) { eventlog_filter filter; filter.obj = p__.second; filter_chain.push_back(filteritem_type(filtermode, filter)); }
486
487struct event_log_buffer {
488        BYTE *bBuffer;
489        DWORD bufferSize_;
490        event_log_buffer(DWORD bufferSize) : bufferSize_(bufferSize) {
491                bBuffer = new BYTE[bufferSize+10];
492        }
493        ~event_log_buffer() {
494                delete [] bBuffer;
495        }
496        EVENTLOGRECORD* getBufferUnsafe() {
497                return reinterpret_cast<EVENTLOGRECORD*>(bBuffer);
498        }
499        DWORD getBufferSize() {
500                return bufferSize_;
501        }
502};
503
504NSCAPI::nagiosReturn CheckEventLog::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) {
505        if (command != _T("CheckEventLog"))
506                return NSCAPI::returnIgnored;
507        typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsULongInteger> EventLogQuery1Container;
508        typedef checkHolders::CheckContainer<checkHolders::ExactBoundsULongInteger> EventLogQuery2Container;
509       
510        typedef std::pair<int,eventlog_filter> filteritem_type;
511        typedef std::list<filteritem_type > filterlist_type;
512        NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
513        std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
514
515        std::list<std::wstring> files;
516        filterlist_type filter_chain;
517        EventLogQuery1Container query1;
518        EventLogQuery2Container query2;
519
520        bool bPerfData = true;
521        bool bFilterIn = true;
522        bool bFilterAll = false;
523        bool bFilterNew = true;
524        bool bShowDescriptions = false;
525        bool unique = false;
526        unsigned int truncate = 0;
527        std::wstring syntax = syntax_;
528        const int filter_plus = 1;
529        const int filter_minus = 2;
530        const int filter_normal = 3;
531        const int filter_compat = 3;
532        event_log_buffer buffer(buffer_length_);
533        /*
534        try {
535                event_log_buffer buffer(buffer_length_);
536        } catch (std::exception e) {
537                message = std::wstring(_T("Failed to allocate memory: ")) + strEx::string_to_wstring(e.what());
538                return NSCAPI::returnUNKNOWN;
539        }
540        */
541
542        try {
543                MAP_OPTIONS_BEGIN(stl_args)
544                        MAP_OPTIONS_NUMERIC_ALL(query1, _T(""))
545                        MAP_OPTIONS_EXACT_NUMERIC_ALL(query2, _T(""))
546                        MAP_OPTIONS_STR2INT(_T("truncate"), truncate)
547                        MAP_OPTIONS_BOOL_TRUE(_T("unique"), unique)
548                        MAP_OPTIONS_BOOL_TRUE(_T("descriptions"), bShowDescriptions)
549                        MAP_OPTIONS_PUSH(_T("file"), files)
550                        MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
551                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterNew, _T("new"), _T("old"))
552                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterIn, _T("in"), _T("out"))
553                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterAll, _T("all"), _T("any"))
554                        MAP_OPTIONS_STR(_T("syntax"), syntax)
555                        /*
556                        MAP_FILTER_OLD("filter-eventType", eventType)
557                        MAP_FILTER_OLD("filter-severity", eventSeverity)
558                        MAP_FILTER_OLD("filter-eventID", eventID)
559                        MAP_FILTER_OLD("filter-eventSource", eventSource)
560                        MAP_FILTER_OLD("filter-generated", timeGenerated)
561                        MAP_FILTER_OLD("filter-written", timeWritten)
562                        MAP_FILTER_OLD("filter-message", message)
563*/
564                        MAP_FILTER(_T("filter+eventType"), eventType, filter_plus)
565                        MAP_FILTER(_T("filter+severity"), eventSeverity, filter_plus)
566                        MAP_FILTER(_T("filter+eventID"), eventID, filter_plus)
567                        MAP_FILTER(_T("filter+eventSource"), eventSource, filter_plus)
568                        MAP_FILTER(_T("filter+generated"), timeGenerated, filter_plus)
569                        MAP_FILTER(_T("filter+written"), timeWritten, filter_plus)
570                        MAP_FILTER(_T("filter+message"), message, filter_plus)
571
572                        MAP_FILTER(_T("filter.eventType"), eventType, filter_normal)
573                        MAP_FILTER(_T("filter.severity"), eventSeverity, filter_normal)
574                        MAP_FILTER(_T("filter.eventID"), eventID, filter_normal)
575                        MAP_FILTER(_T("filter.eventSource"), eventSource, filter_normal)
576                        MAP_FILTER(_T("filter.generated"), timeGenerated, filter_normal)
577                        MAP_FILTER(_T("filter.written"), timeWritten, filter_normal)
578                        MAP_FILTER(_T("filter.message"), message, filter_normal)
579
580                        MAP_FILTER(_T("filter-eventType"), eventType, filter_minus)
581                        MAP_FILTER(_T("filter-severity"), eventSeverity, filter_minus)
582                        MAP_FILTER(_T("filter-eventID"), eventID, filter_minus)
583                        MAP_FILTER(_T("filter-eventSource"), eventSource, filter_minus)
584                        MAP_FILTER(_T("filter-generated"), timeGenerated, filter_minus)
585                        MAP_FILTER(_T("filter-written"), timeWritten, filter_minus)
586                        MAP_FILTER(_T("filter-message"), message, filter_minus)
587
588                        MAP_OPTIONS_MISSING(message, _T("Unknown argument: "))
589                        MAP_OPTIONS_END()
590        } catch (filters::parse_exception e) {
591                message = e.getMessage();
592                return NSCAPI::returnUNKNOWN;
593        } catch (filters::filter_exception e) {
594                message = e.getMessage();
595                return NSCAPI::returnUNKNOWN;
596                } catch (checkHolders::parse_exception e) {
597                message = e.getMessage();
598                return NSCAPI::returnUNKNOWN;
599        } catch (...) {
600                message = _T("Invalid command line!");
601                return NSCAPI::returnUNKNOWN;
602        }
603
604        unsigned long int hit_count = 0;
605        if (files.empty()) {
606                message = _T("No file specified try adding: file=Application");
607                return NSCAPI::returnUNKNOWN;
608        }
609        bool buffer_error_reported = false;
610
611        for (std::list<std::wstring>::const_iterator cit2 = files.begin(); cit2 != files.end(); ++cit2) {
612                std::wstring name = *cit2;
613                if (lookup_names_) {
614                        name = find_eventlog_name(*cit2);
615                        if ((*cit2) != name) {
616                                NSC_DEBUG_MSG_STD(_T("Opening alternative log: ") + name);
617                        }
618                }
619                HANDLE hLog = OpenEventLog(NULL, name.c_str());
620                if (hLog == NULL) {
621                        message = _T("Could not open the '") + (*cit2) + _T("' event log: ") + error::lookup::last_error();
622                        return NSCAPI::returnUNKNOWN;
623                }
624                uniq_eventlog_map uniq_records;
625
626                //DWORD dwThisRecord;
627                DWORD dwRead, dwNeeded;
628
629
630                __time64_t ltime;
631                _time64(&ltime);
632
633                //GetOldestEventLogRecord(hLog, &dwThisRecord);
634
635                while (true) {
636                        BOOL bStatus = ReadEventLog(hLog, EVENTLOG_FORWARDS_READ|EVENTLOG_SEQUENTIAL_READ,
637                                0, buffer.getBufferUnsafe(), buffer.getBufferSize(), &dwRead, &dwNeeded);
638                        if (bStatus == FALSE) {
639                                DWORD err = GetLastError();
640                                if (err == ERROR_INSUFFICIENT_BUFFER) {
641                                        if (!buffer_error_reported) {
642                                                NSC_LOG_ERROR_STD(_T("EvenlogBuffer is too small change the value of ") + setting_keys::event_log::BUFFER_SIZE + _T("=") + strEx::itos(dwNeeded+1) + _T(" under [EventLog] in nsc.ini : ") + error::lookup::last_error(err));
643                                                buffer_error_reported = true;
644                                        }
645                                } else if (err == ERROR_HANDLE_EOF) {
646                                        break;
647                                } else {
648                                        NSC_LOG_ERROR_STD(_T("Failed to read from eventlog: ") + error::lookup::last_error(err));
649                                        message = _T("Failed to read from eventlog: ") + error::lookup::last_error(err);
650                                        CloseEventLog(hLog);
651                                        return NSCAPI::returnUNKNOWN;
652                                }
653                        }
654                        EVENTLOGRECORD *pevlr = buffer.getBufferUnsafe();
655                        while (dwRead > 0) {
656                                //bool bMatch = bFilterAll;
657                                bool bMatch = !bFilterIn;
658                                EventLogRecord record((*cit2), pevlr, ltime);
659
660                                if (filter_chain.empty()) {
661                                        message = _T("No filters specified try adding: filter+generated=>2d");
662                                        return NSCAPI::returnUNKNOWN;
663                                }
664
665
666                                for (filterlist_type::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) {
667                                        std::wstring reason;
668                                        int mode = (*cit3).first;
669                                        bool bTmpMatched = (*cit3).second.matchFilter(record);
670                                        if (!bFilterNew) {
671                                                if (bFilterAll) {
672                                                        if (!bTmpMatched) {
673                                                                bMatch = false;
674                                                                break;
675                                                        }
676                                                } else {
677                                                        if (bTmpMatched) {
678                                                                bMatch = true;
679                                                                break;
680                                                        }
681                                                }
682                                        } else {
683                                                if ((mode == filter_minus)&&(bTmpMatched)) {
684                                                        // a -<filter> hit so thrash item and bail out!
685                                                        if (debug_)
686                                                                NSC_DEBUG_MSG_STD(_T("Matched: - ") + (*cit3).second.getValue() + _T(" for: ") + record.render(bShowDescriptions, syntax));
687                                                        bMatch = false;
688                                                        break;
689                                                } else if ((mode == filter_plus)&&(!bTmpMatched)) {
690                                                        // a +<filter> missed hit so thrash item and bail out!
691                                                        if (debug_)
692                                                                NSC_DEBUG_MSG_STD(_T("Matched: + ") + (*cit3).second.getValue() + _T(" for: ") + record.render(bShowDescriptions, syntax));
693                                                        bMatch = false;
694                                                        break;
695                                                } else if (bTmpMatched) {
696                                                        if (debug_)
697                                                                NSC_DEBUG_MSG_STD(_T("Matched: . (contiunue): ") + (*cit3).second.getValue() + _T(" for: ") + record.render(bShowDescriptions, syntax));
698                                                        bMatch = true;
699                                                }
700                                        }
701                                }
702                                bool match = false;
703                                if ((!bFilterNew)&&((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch))) {
704                                        match = true;
705                                } else if (bFilterNew&&bMatch) {
706                                        match = true;
707                                }
708                                if (match&&unique) {
709                                        match = false;
710                                        uniq_eventlog_record uniq_record = pevlr;
711                                        uniq_eventlog_map::iterator it = uniq_records.find(uniq_record);
712                                        if (it != uniq_records.end()) {
713                                                (*it).second ++;
714                                                //match = false;
715                                        }
716                                        else {
717                                                if (!syntax.empty()) {
718                                                        uniq_record.message = record.render(bShowDescriptions, syntax);
719                                                } else if (!bShowDescriptions) {
720                                                        uniq_record.message = record.eventSource();
721                                                } else {
722                                                        uniq_record.message = record.eventSource();
723                                                        uniq_record.message += _T("(") + EventLogRecord::translateType(record.eventType()) + _T(", ") +
724                                                                strEx::itos(record.eventID()) + _T(", ") + EventLogRecord::translateSeverity(record.severity()) + _T(")");
725                                                        uniq_record.message += _T("[") + record.enumStrings() + _T("]");
726                                                        uniq_record.message += _T("{%count%}");
727                                                }
728                                                uniq_records[uniq_record] = 1;
729                                        }
730                                        hit_count++;
731                                } else if (match) {
732                                        if (!syntax.empty()) {
733                                                strEx::append_list(message, record.render(bShowDescriptions, syntax));
734                                        } else if (!bShowDescriptions) {
735                                                strEx::append_list(message, record.eventSource());
736                                        } else {
737                                                strEx::append_list(message, record.eventSource());
738                                                message += _T("(") + EventLogRecord::translateType(record.eventType()) + _T(", ") +
739                                                        strEx::itos(record.eventID()) + _T(", ") + EventLogRecord::translateSeverity(record.severity()) + _T(")");
740                                                message += _T("[") + record.enumStrings() + _T("]");
741                                        }
742                                        hit_count++;
743                                }
744                                dwRead -= pevlr->Length;
745                                pevlr = reinterpret_cast<EVENTLOGRECORD*>((LPBYTE)pevlr + pevlr->Length);
746                        }
747                }
748                DWORD err = GetLastError();
749                if (err == ERROR_INSUFFICIENT_BUFFER) {
750                        NSC_LOG_ERROR_STD(_T("EvenlogBuffer is too small (set the value of ") + setting_keys::event_log::BUFFER_SIZE_TITLE + _T("): ") + error::lookup::last_error(err));
751                        message = std::wstring(_T("EvenlogBuffer is too small (set the value of ")) + setting_keys::event_log::BUFFER_SIZE_TITLE + _T("): ") + error::lookup::last_error(err);
752                        return NSCAPI::returnUNKNOWN;
753                } else if (err != ERROR_HANDLE_EOF) {
754                        NSC_LOG_ERROR_STD(_T("Failed to read from eventlog: ") + error::lookup::last_error(err));
755                        message = _T("Failed to read from eventlog: ") + error::lookup::last_error(err);
756                        return NSCAPI::returnUNKNOWN;
757                }
758                CloseEventLog(hLog);
759                for (uniq_eventlog_map::const_iterator cit = uniq_records.begin(); cit != uniq_records.end(); ++cit) {
760                        std::wstring msg = (*cit).first.message;
761                        strEx::replace(msg, _T("%count%"), strEx::itos((*cit).second));
762                        strEx::append_list(message, msg);
763                }
764        }
765
766        if (!bPerfData) {
767                query1.perfData = false;
768                query2.perfData = false;
769        }
770        if (query1.alias.empty())
771                query1.alias = _T("eventlog");
772        if (query2.alias.empty())
773                query2.alias = _T("eventlog");
774        if (query1.hasBounds())
775                query1.runCheck(hit_count, returnCode, message, perf);
776        else if (query2.hasBounds())
777                query2.runCheck(hit_count, returnCode, message, perf);
778        else {
779                message = _T("No bounds specified!");
780                return NSCAPI::returnUNKNOWN;
781        }
782        if ((truncate > 0) && (message.length() > (truncate-4)))
783                message = message.substr(0, truncate-4) + _T("...");
784        if (message.empty())
785                message = _T("Eventlog check ok");
786        return returnCode;
787}
788
789
790NSC_WRAPPERS_MAIN_DEF(gCheckEventLog);
791NSC_WRAPPERS_IGNORE_MSG_DEF();
792NSC_WRAPPERS_HANDLE_CMD_DEF(gCheckEventLog);
Note: See TracBrowser for help on using the repository browser.