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

0.4.00.4.10.4.2stable
Last change on this file since a34b229 was a34b229, checked in by Michael Medin <michael@…>, 5 years ago

2008-09-09 MickeM

  • Fixed issue with & and some commands via check_nt.
  • Fixed a crash on exit (which I added in Rc1).
  • Added 10 "bytes" the CPU buffer: (#174) + Added new option to [EventLog?] section buffer_size to change the size of the buffer used when scanning the evenlotg (defaults to 64k).
  • Fixed error handling in CHeckEventLog so errors are repoorted properly (#184)
  • Property mode set to 100644
File size: 23.1 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
32CheckEventLog gCheckEventLog;
33
34BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
35{
36        NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
37        return TRUE;
38}
39
40CheckEventLog::CheckEventLog() {
41}
42CheckEventLog::~CheckEventLog() {
43}
44
45
46bool CheckEventLog::loadModule() {
47        try {
48                NSCModuleHelper::registerCommand(_T("CheckEventLog"), _T("Check for errors in the event logger!"));
49                debug_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_DEBUG, EVENTLOG_DEBUG_DEFAULT)==1;
50                syntax_ = NSCModuleHelper::getSettingsString(EVENTLOG_SECTION_TITLE, EVENTLOG_SYNTAX, EVENTLOG_SYNTAX_DEFAULT);
51                buffer_ = NSCModuleHelper::getSettingsInt(EVENTLOG_SECTION_TITLE, EVENTLOG_BUFFER, EVENTLOG_BUFFER_DEFAULT);
52        } catch (NSCModuleHelper::NSCMHExcpetion &e) {
53                NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_);
54        } catch (...) {
55                NSC_LOG_ERROR_STD(_T("Failed to register command."));
56        }
57        return true;
58}
59bool CheckEventLog::unloadModule() {
60        return true;
61}
62
63bool CheckEventLog::hasCommandHandler() {
64        return true;
65}
66bool CheckEventLog::hasMessageHandler() {
67        return false;
68}
69
70
71class EventLogRecord {
72        EVENTLOGRECORD *pevlr_;
73        __int64 currentTime_;
74        std::wstring file_;
75public:
76        EventLogRecord(std::wstring file, EVENTLOGRECORD *pevlr, __int64 currentTime) : file_(file), pevlr_(pevlr), currentTime_(currentTime) {
77        }
78        inline __int64 timeGenerated() const {
79                return (currentTime_-pevlr_->TimeGenerated)*1000;
80        }
81        inline __int64 timeWritten() const {
82                return (currentTime_-pevlr_->TimeWritten)*1000;
83        }
84        inline std::wstring eventSource() const {
85                return reinterpret_cast<WCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + sizeof(EVENTLOGRECORD));
86        }
87        inline DWORD eventID() const {
88                return (pevlr_->EventID&0xffff);
89        }
90        inline DWORD severity() const {
91                return (pevlr_->EventID>>30);
92        }
93
94        inline DWORD eventType() const {
95                return pevlr_->EventType;
96        }
97/*
98        std::wstring userSID() const {
99                if (pevlr_->UserSidOffset == 0)
100                        return "";
101                PSID p = reinterpret_cast<PSID>(reinterpret_cast<LPBYTE>(pevlr_) + + pevlr_->UserSidOffset);
102                LPSTR user = new CHAR[1025];
103                LPSTR domain = new CHAR[1025];
104                DWORD userLen = 1024;
105                DWORD domainLen = 1024;
106                SID_NAME_USE sidName;
107                LookupAccountSid(NULL, p, user, &userLen, domain, &domainLen, &sidName);
108                user[userLen] = 0;
109                domain[domainLen] = 0;
110                return std::wstring(domain) + "\\" + std::wstring(user);
111        }
112        */
113
114        std::wstring enumStrings() const {
115                std::wstring ret;
116                TCHAR* p = reinterpret_cast<TCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + pevlr_->StringOffset);
117                for (unsigned int i =0;i<pevlr_->NumStrings;i++) {
118                        std::wstring s = p;
119                        if (!s.empty())
120                                s += _T(", ");
121                        ret += s;
122                        p+= wcslen(p)+1;
123                }
124                return ret;
125        }
126
127        static DWORD appendType(DWORD dwType, std::wstring sType) {
128                return dwType | translateType(sType);
129        }
130        static DWORD subtractType(DWORD dwType, std::wstring sType) {
131                return dwType & (!translateType(sType));
132        }
133        static DWORD translateType(std::wstring sType) {
134                if (sType == _T("error"))
135                        return EVENTLOG_ERROR_TYPE;
136                if (sType == _T("warning"))
137                        return EVENTLOG_WARNING_TYPE;
138                if (sType == _T("info"))
139                        return EVENTLOG_INFORMATION_TYPE;
140                if (sType == _T("auditSuccess"))
141                        return EVENTLOG_AUDIT_SUCCESS;
142                if (sType == _T("auditFailure"))
143                        return EVENTLOG_AUDIT_FAILURE;
144                return strEx::stoi(sType);
145        }
146        static std::wstring translateType(DWORD dwType) {
147                if (dwType == EVENTLOG_ERROR_TYPE)
148                        return _T("error");
149                if (dwType == EVENTLOG_WARNING_TYPE)
150                        return _T("warning");
151                if (dwType == EVENTLOG_INFORMATION_TYPE)
152                        return _T("info");
153                if (dwType == EVENTLOG_AUDIT_SUCCESS)
154                        return _T("auditSuccess");
155                if (dwType == EVENTLOG_AUDIT_FAILURE)
156                        return _T("auditFailure");
157                return strEx::itos(dwType);
158        }
159        static DWORD translateSeverity(std::wstring sType) {
160                if (sType == _T("success"))
161                        return 0;
162                if (sType == _T("informational"))
163                        return 1;
164                if (sType == _T("warning"))
165                        return 2;
166                if (sType == _T("error"))
167                        return 3;
168                return strEx::stoi(sType);
169        }
170        static std::wstring translateSeverity(DWORD dwType) {
171                if (dwType == 0)
172                        return _T("success");
173                if (dwType == 1)
174                        return _T("informational");
175                if (dwType == 2)
176                        return _T("warning");
177                if (dwType == 3)
178                        return _T("error");
179                return strEx::itos(dwType);
180        }
181        std::wstring get_dll() {
182                HKEY hKey = HKEY_LOCAL_MACHINE;
183                std::wstring path = ((std::wstring)_T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\") + file_ + (std::wstring)_T("\\") + eventSource()).c_str();
184                std::wstring ret;
185                HKEY hTemp;
186                LONG lRet = ERROR_SUCCESS;
187                if (lRet = RegOpenKeyEx(hKey, path.c_str(), 0, KEY_QUERY_VALUE, &hTemp) != ERROR_SUCCESS) {
188                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource() + error::format::from_system(lRet));
189                        return ret;
190                }
191                DWORD type;
192                const DWORD data_length = 2048;
193                DWORD cbData = data_length;
194                BYTE *bData = new BYTE[cbData];
195                lRet = RegQueryValueEx(hTemp, _T("EventMessageFile"), NULL, &type, bData, &cbData);
196                if (lRet == ERROR_SUCCESS) {
197                        if (type == REG_SZ) {
198                                if (cbData < data_length-1) {
199                                        bData[cbData] = 0;
200                                        ret = reinterpret_cast<LPCTSTR>(bData);
201                                } else {
202                                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
203                                }
204                        } else if (type == REG_EXPAND_SZ) {
205#define EXPAND_BUFFER_SIZE 2048
206                                if (cbData < data_length-1) {
207                                        bData[cbData] = 0;
208                                        std::wstring s = reinterpret_cast<LPCTSTR>(bData);
209                                        TCHAR *buffer = new TCHAR[EXPAND_BUFFER_SIZE+1];
210                                        DWORD expRet = ExpandEnvironmentStrings(s.c_str(), buffer, EXPAND_BUFFER_SIZE);
211                                        if (expRet >= EXPAND_BUFFER_SIZE)
212                                                NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
213                                        else
214                                                ret = buffer;
215                                } else {
216                                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
217                                }
218                        } else {
219                                NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
220                        }
221                } else {
222                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource() + error::format::from_system(lRet));
223                }
224                RegCloseKey(hTemp);
225                delete [] bData;
226                return ret;
227        }
228
229        std::wstring render_message() {
230                DWORD *dwArgs = new DWORD[pevlr_->NumStrings+1];
231                TCHAR* p = reinterpret_cast<TCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + pevlr_->StringOffset);
232                for (unsigned int i =0;i<pevlr_->NumStrings;i++) {
233                        dwArgs[i] = reinterpret_cast<DWORD>(p);
234                        DWORD len = wcslen(p);
235                        p += len+1;
236                }
237
238/*
239                TCHAR **_sz = (TCHAR**)GlobalAlloc(GPTR, (pevlr_->NumStrings)*sizeof(TCHAR *));
240                register UINT z;
241                TCHAR* p = reinterpret_cast<TCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + pevlr_->StringOffset);
242                for(unsigned int z = 0; z < pevlr_->NumStrings; z++) {
243                        DWORD len = wcslen(p);
244                        _sz[z] = (TCHAR *)GlobalAlloc(GPTR, (len+1) * sizeof(TCHAR));
245                        wcscpy_s(_sz[z], len, p);
246                        p += len+1;
247                }
248*/
249                std::wstring ret;
250                strEx::splitList dlls = strEx::splitEx(get_dll(), _T(";"));
251                for (strEx::splitList::const_iterator cit = dlls.begin(); cit != dlls.end(); ++cit) {
252                        //std::wstring msg = error::format::message::from_module((*cit), eventID(), _sz);
253                        std::wstring msg = error::format::message::from_module((*cit), eventID(), dwArgs);
254                        if (msg.empty()) {
255                                msg = error::format::message::from_module((*cit), pevlr_->EventID, dwArgs);
256                        }
257                        strEx::replace(msg, _T("\n"), _T(" "));
258                        strEx::replace(msg, _T("\t"), _T(" "));
259                        std::string::size_type pos = msg.find_last_not_of(_T("\n\t "));
260                        if (pos != std::string::npos) {
261                                msg = msg.substr(0,pos);
262                        }
263                        if (!msg.empty()) {
264                                if (!ret.empty())
265                                        ret += _T(", ");
266                                ret += msg;
267                        }
268                }
269                delete [] dwArgs;
270                return ret;
271        }
272        SYSTEMTIME get_time(DWORD time) {
273                FILETIME FileTime, LocalFileTime;
274                SYSTEMTIME SysTime;
275                __int64 lgTemp;
276                __int64 SecsTo1970 = 116444736000000000;
277
278                lgTemp = Int32x32To64(time,10000000) + SecsTo1970;
279
280                FileTime.dwLowDateTime = (DWORD) lgTemp;
281                FileTime.dwHighDateTime = (DWORD)(lgTemp >> 32);
282
283                FileTimeToLocalFileTime(&FileTime, &LocalFileTime);
284                FileTimeToSystemTime(&LocalFileTime, &SysTime);
285                return SysTime;
286        }
287
288        SYSTEMTIME get_time_generated() {
289                return get_time(pevlr_->TimeGenerated);
290        }
291        SYSTEMTIME get_time_written() {
292                return get_time(pevlr_->TimeWritten);
293        }
294
295        std::wstring render(bool propper, std::wstring syntax, std::wstring date_format = DATE_FORMAT) {
296                if (propper) {
297                        // To obtain the appropriate message string from the message file, load the message file with the LoadLibrary function and use the FormatMessage function
298                        strEx::replace(syntax, _T("%message%"), render_message());
299                } else {
300                        strEx::replace(syntax, _T("%message%"), _T("%message% needs the descriptions flag set!"));
301                }
302
303                strEx::replace(syntax, _T("%source%"), eventSource());
304                strEx::replace(syntax, _T("%generated%"), strEx::format_date(get_time_generated(), date_format));
305                strEx::replace(syntax, _T("%written%"), strEx::format_date(get_time_written(), date_format));
306                strEx::replace(syntax, _T("%type%"), translateType(eventType()));
307                strEx::replace(syntax, _T("%severity%"), translateSeverity(severity()));
308                strEx::replace(syntax, _T("%strings%"), enumStrings());
309                strEx::replace(syntax, _T("%id%"), strEx::itos(eventID()));
310                return syntax;
311        }
312};
313/*
314return (pevlr_->EventID&0xffff);
315}
316inline DWORD severity() const {
317return (pevlr_->EventID>>30);
318*/
319class uniq_eventlog_record {
320        DWORD ID;
321        WORD type;
322        WORD category;
323public:
324        std::wstring message;
325        uniq_eventlog_record(EVENTLOGRECORD *pevlr) : ID(pevlr->EventID&0xffff), type(pevlr->EventType), category(pevlr->EventCategory) {}
326        bool operator< (const uniq_eventlog_record &other) const {
327                return (ID < other.ID) || ((ID==other.ID)&&(type < other.type)) || (ID==other.ID&&type==other.type)&&(category < other.category);
328        }
329        std::wstring to_string() const {
330                return _T("id=") + strEx::itos(ID) + _T("type=") + strEx::itos(type) + _T("category=") + strEx::itos(category);
331        }
332};
333typedef std::map<uniq_eventlog_record,unsigned int> uniq_eventlog_map;
334
335
336struct eventlog_filter {
337        filters::filter_all_strings eventSource;
338        filters::filter_all_numeric<unsigned int, filters::handlers::eventtype_handler> eventType;
339        filters::filter_all_numeric<unsigned int, filters::handlers::eventseverity_handler> eventSeverity;
340        filters::filter_all_strings message;
341        filters::filter_all_times timeWritten;
342        filters::filter_all_times timeGenerated;
343        filters::filter_all_numeric<DWORD, filters::handlers::eventtype_handler> eventID;
344        std::wstring value_;
345
346        inline bool hasFilter() {
347                return eventSource.hasFilter() || eventType.hasFilter() || eventID.hasFilter() || eventSeverity.hasFilter() || message.hasFilter() ||
348                        timeWritten.hasFilter() || timeGenerated.hasFilter();
349        }
350        std::wstring getValue() const {
351                if (eventSource.hasFilter())
352                        return _T("event-source: ") + eventSource.getValue();
353                if (eventType.hasFilter())
354                        return _T("event-type: ") + eventType.getValue();
355                if (eventSeverity.hasFilter())
356                        return _T("severity: ") + eventSeverity.getValue();
357                if (eventID.hasFilter())
358                        return _T("event-id: ") + eventID.getValue();
359                if (message.hasFilter())
360                        return _T("message: ") + message.getValue();
361                if (timeWritten.hasFilter())
362                        return _T("time-written: ") + timeWritten.getValue();
363                if (timeGenerated.hasFilter())
364                        return _T("time-generated: ") + timeGenerated.getValue();
365                return _T("UNknown...");
366        }
367        bool matchFilter(const EventLogRecord &value) const {
368                if ((eventSource.hasFilter())&&(eventSource.matchFilter(value.eventSource())))
369                        return true;
370                else if ((eventType.hasFilter())&&(eventType.matchFilter(value.eventType())))
371                        return true;
372                else if ((eventSeverity.hasFilter())&&(eventSeverity.matchFilter(value.severity())))
373                        return true;
374                else if ((eventID.hasFilter())&&(eventID.matchFilter(value.eventID())))
375                        return true;
376                else if ((message.hasFilter())&&(message.matchFilter(value.enumStrings())))
377                        return true;
378                else if ((timeWritten.hasFilter())&&(timeWritten.matchFilter(value.timeWritten())))
379                        return true;
380                else if ((timeGenerated.hasFilter())&&(timeGenerated.matchFilter(value.timeGenerated())))
381                        return true;
382                return false;
383        }
384};
385
386
387#define MAP_FILTER(value, obj, filtermode) \
388                        else if (p__.first == value) { eventlog_filter filter; filter.obj = p__.second; filter_chain.push_back(filteritem_type(filtermode, filter)); }
389
390struct event_log_buffer {
391        BYTE *bBuffer;
392        DWORD bufferSize_;
393        event_log_buffer(DWORD bufferSize) : bufferSize_(bufferSize) {
394                bBuffer = new BYTE[bufferSize+10];
395        }
396        ~event_log_buffer() {
397                delete [] bBuffer;
398        }
399        EVENTLOGRECORD* getBufferUnsafe() {
400                return reinterpret_cast<EVENTLOGRECORD*>(bBuffer);
401        }
402        DWORD getBufferSize() {
403                return bufferSize_;
404        }
405};
406
407NSCAPI::nagiosReturn CheckEventLog::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) {
408        if (command != _T("CheckEventLog"))
409                return NSCAPI::returnIgnored;
410        typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsULongInteger> EventLogQueryContainer;
411        typedef std::pair<int,eventlog_filter> filteritem_type;
412        typedef std::list<filteritem_type > filterlist_type;
413        NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
414        std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
415
416        std::list<std::wstring> files;
417        filterlist_type filter_chain;
418        EventLogQueryContainer query;
419
420        bool bPerfData = true;
421        bool bFilterIn = true;
422        bool bFilterAll = false;
423        bool bFilterNew = true;
424        bool bShowDescriptions = false;
425        bool unique = false;
426        unsigned int truncate = 0;
427        std::wstring syntax = syntax_;
428        const int filter_plus = 1;
429        const int filter_minus = 2;
430        const int filter_normal = 3;
431        const int filter_compat = 3;
432        event_log_buffer buffer(buffer_);
433
434        try {
435                MAP_OPTIONS_BEGIN(stl_args)
436                        MAP_OPTIONS_NUMERIC_ALL(query, _T(""))
437                        MAP_OPTIONS_STR2INT(_T("truncate"), truncate)
438                        MAP_OPTIONS_BOOL_TRUE(_T("unique"), unique)
439                        MAP_OPTIONS_BOOL_TRUE(_T("descriptions"), bShowDescriptions)
440                        MAP_OPTIONS_PUSH(_T("file"), files)
441                        MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
442                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterNew, _T("new"), _T("old"))
443                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterIn, _T("in"), _T("out"))
444                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterAll, _T("all"), _T("any"))
445                        MAP_OPTIONS_STR(_T("syntax"), syntax)
446                        /*
447                        MAP_FILTER_OLD("filter-eventType", eventType)
448                        MAP_FILTER_OLD("filter-severity", eventSeverity)
449                        MAP_FILTER_OLD("filter-eventID", eventID)
450                        MAP_FILTER_OLD("filter-eventSource", eventSource)
451                        MAP_FILTER_OLD("filter-generated", timeGenerated)
452                        MAP_FILTER_OLD("filter-written", timeWritten)
453                        MAP_FILTER_OLD("filter-message", message)
454*/
455                        MAP_FILTER(_T("filter+eventType"), eventType, filter_plus)
456                        MAP_FILTER(_T("filter+severity"), eventSeverity, filter_plus)
457                        MAP_FILTER(_T("filter+eventID"), eventID, filter_plus)
458                        MAP_FILTER(_T("filter+eventSource"), eventSource, filter_plus)
459                        MAP_FILTER(_T("filter+generated"), timeGenerated, filter_plus)
460                        MAP_FILTER(_T("filter+written"), timeWritten, filter_plus)
461                        MAP_FILTER(_T("filter+message"), message, filter_plus)
462
463                        MAP_FILTER(_T("filter.eventType"), eventType, filter_normal)
464                        MAP_FILTER(_T("filter.severity"), eventSeverity, filter_normal)
465                        MAP_FILTER(_T("filter.eventID"), eventID, filter_normal)
466                        MAP_FILTER(_T("filter.eventSource"), eventSource, filter_normal)
467                        MAP_FILTER(_T("filter.generated"), timeGenerated, filter_normal)
468                        MAP_FILTER(_T("filter.written"), timeWritten, filter_normal)
469                        MAP_FILTER(_T("filter.message"), message, filter_normal)
470
471                        MAP_FILTER(_T("filter-eventType"), eventType, filter_minus)
472                        MAP_FILTER(_T("filter-severity"), eventSeverity, filter_minus)
473                        MAP_FILTER(_T("filter-eventID"), eventID, filter_minus)
474                        MAP_FILTER(_T("filter-eventSource"), eventSource, filter_minus)
475                        MAP_FILTER(_T("filter-generated"), timeGenerated, filter_minus)
476                        MAP_FILTER(_T("filter-written"), timeWritten, filter_minus)
477                        MAP_FILTER(_T("filter-message"), message, filter_minus)
478
479                        MAP_OPTIONS_MISSING(message, _T("Unknown argument: "))
480                        MAP_OPTIONS_END()
481        } catch (filters::parse_exception e) {
482                message = e.getMessage();
483                return NSCAPI::returnUNKNOWN;
484        } catch (filters::filter_exception e) {
485                message = e.getMessage();
486                return NSCAPI::returnUNKNOWN;
487        }
488
489        unsigned long int hit_count = 0;
490        if (files.empty()) {
491                message = _T("No file specified try adding: file=Application");
492                return NSCAPI::returnUNKNOWN;
493        }
494
495        for (std::list<std::wstring>::const_iterator cit2 = files.begin(); cit2 != files.end(); ++cit2) {
496                HANDLE hLog = OpenEventLog(NULL, (*cit2).c_str());
497                if (hLog == NULL) {
498                        message = _T("Could not open the '") + (*cit2) + _T("' event log: ") + error::lookup::last_error();
499                        return NSCAPI::returnUNKNOWN;
500                }
501                uniq_eventlog_map uniq_records;
502
503                //DWORD dwThisRecord;
504                DWORD dwRead, dwNeeded;
505
506
507                __time64_t ltime;
508                _time64(&ltime);
509
510                //GetOldestEventLogRecord(hLog, &dwThisRecord);
511
512                while (ReadEventLog(hLog, EVENTLOG_FORWARDS_READ|EVENTLOG_SEQUENTIAL_READ,
513                        0, buffer.getBufferUnsafe(), buffer.getBufferSize(), &dwRead, &dwNeeded))
514                {
515                        EVENTLOGRECORD *pevlr = buffer.getBufferUnsafe();
516                        while (dwRead > 0) {
517                                //bool bMatch = bFilterAll;
518                                bool bMatch = !bFilterIn;
519                                EventLogRecord record((*cit2), pevlr, ltime);
520
521                                if (filter_chain.empty()) {
522                                        message = _T("No filters specified try adding: filter+generated=>2d");
523                                        return NSCAPI::returnUNKNOWN;
524                                }
525
526
527                                for (filterlist_type::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) {
528                                        std::wstring reason;
529                                        int mode = (*cit3).first;
530                                        bool bTmpMatched = (*cit3).second.matchFilter(record);
531                                        if (!bFilterNew) {
532                                                if (bFilterAll) {
533                                                        if (!bTmpMatched) {
534                                                                bMatch = false;
535                                                                break;
536                                                        }
537                                                } else {
538                                                        if (bTmpMatched) {
539                                                                bMatch = true;
540                                                                break;
541                                                        }
542                                                }
543                                        } else {
544                                                if ((mode == filter_minus)&&(bTmpMatched)) {
545                                                        // a -<filter> hit so thrash item and bail out!
546                                                        if (debug_)
547                                                                NSC_DEBUG_MSG_STD(_T("Matched: - ") + (*cit3).second.getValue() + _T(" for: ") + record.render(bShowDescriptions, syntax));
548                                                        bMatch = false;
549                                                        break;
550                                                } else if ((mode == filter_plus)&&(!bTmpMatched)) {
551                                                        // a +<filter> missed hit so thrash item and bail out!
552                                                        if (debug_)
553                                                                NSC_DEBUG_MSG_STD(_T("Matched: + ") + (*cit3).second.getValue() + _T(" for: ") + record.render(bShowDescriptions, syntax));
554                                                        bMatch = false;
555                                                        break;
556                                                } else if (bTmpMatched) {
557                                                        if (debug_)
558                                                                NSC_DEBUG_MSG_STD(_T("Matched: . (contiunue): ") + (*cit3).second.getValue() + _T(" for: ") + record.render(bShowDescriptions, syntax));
559                                                        bMatch = true;
560                                                }
561                                        }
562                                }
563                                bool match = false;
564                                if ((!bFilterNew)&&((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch))) {
565                                        match = true;
566                                } else if (bFilterNew&&bMatch) {
567                                        match = true;
568                                }
569                                if (match&&unique) {
570                                        match = false;
571                                        uniq_eventlog_record uniq_record = pevlr;
572                                        uniq_eventlog_map::iterator it = uniq_records.find(uniq_record);
573                                        if (it != uniq_records.end()) {
574                                                (*it).second ++;
575                                                //match = false;
576                                        }
577                                        else {
578                                                if (!syntax.empty()) {
579                                                        uniq_record.message = record.render(bShowDescriptions, syntax);
580                                                } else if (!bShowDescriptions) {
581                                                        uniq_record.message = record.eventSource();
582                                                } else {
583                                                        uniq_record.message = record.eventSource();
584                                                        uniq_record.message += _T("(") + EventLogRecord::translateType(record.eventType()) + _T(", ") +
585                                                                strEx::itos(record.eventID()) + _T(", ") + EventLogRecord::translateSeverity(record.severity()) + _T(")");
586                                                        uniq_record.message += _T("[") + record.enumStrings() + _T("]");
587                                                        uniq_record.message += _T("{%count%}");
588                                                }
589                                                uniq_records[uniq_record] = 1;
590                                        }
591                                        hit_count++;
592                                } else if (match) {
593                                        if (!syntax.empty()) {
594                                                strEx::append_list(message, record.render(bShowDescriptions, syntax));
595                                        } else if (!bShowDescriptions) {
596                                                strEx::append_list(message, record.eventSource());
597                                        } else {
598                                                strEx::append_list(message, record.eventSource());
599                                                message += _T("(") + EventLogRecord::translateType(record.eventType()) + _T(", ") +
600                                                        strEx::itos(record.eventID()) + _T(", ") + EventLogRecord::translateSeverity(record.severity()) + _T(")");
601                                                message += _T("[") + record.enumStrings() + _T("]");
602                                        }
603                                        hit_count++;
604                                }
605                                dwRead -= pevlr->Length;
606                                pevlr = reinterpret_cast<EVENTLOGRECORD*>((LPBYTE)pevlr + pevlr->Length);
607                        }
608                }
609                DWORD err = GetLastError();
610                if (err == ERROR_INSUFFICIENT_BUFFER) {
611                        NSC_LOG_ERROR_STD(_T("EvenlogBuffer is too small (set the value of ") + EVENTLOG_BUFFER + _T("): ") + error::lookup::last_error(err));
612                        message = std::wstring(_T("EvenlogBuffer is too small (set the value of ")) + EVENTLOG_BUFFER + _T("): ") + error::lookup::last_error(err);
613                        return NSCAPI::returnUNKNOWN;
614                } else if (err != ERROR_HANDLE_EOF) {
615                        NSC_LOG_ERROR_STD(_T("Failed to read from eventlog: ") + error::lookup::last_error(err));
616                        message = _T("Failed to read from eventlog: ") + error::lookup::last_error(err);
617                        return NSCAPI::returnUNKNOWN;
618                }
619                CloseEventLog(hLog);
620                for (uniq_eventlog_map::const_iterator cit = uniq_records.begin(); cit != uniq_records.end(); ++cit) {
621                        std::wstring msg = (*cit).first.message;
622                        strEx::replace(msg, _T("%count%"), strEx::itos((*cit).second));
623                        strEx::append_list(message, msg);
624                }
625        }
626
627        if (!bPerfData)
628                query.perfData = false;
629        if (query.alias.empty())
630                query.alias = _T("eventlog");
631        query.runCheck(hit_count, returnCode, message, perf);
632        if ((truncate > 0) && (message.length() > (truncate-4)))
633                message = message.substr(0, truncate-4) + _T("...");
634        if (message.empty())
635                message = _T("Eventlog check ok");
636        NSC_DEBUG_MSG_STD(_T("Result: ") + message) ;
637        return returnCode;
638}
639
640
641NSC_WRAPPERS_MAIN_DEF(gCheckEventLog);
642NSC_WRAPPERS_IGNORE_MSG_DEF();
643NSC_WRAPPERS_HANDLE_CMD_DEF(gCheckEventLog);
Note: See TracBrowser for help on using the repository browser.