source: nscp/modules/CheckEventLog/CheckEventLog.cpp @ 6b690bf

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

+ Added API for scripts to register commands

+ Added command descriptions (for some modules)

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