source: nscp/modules/CheckEventLog/CheckEventLog.cpp @ 5ac88c0a

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

2008-01-27 MickeM

  • Fixed a memory-leak in format_time
  • Fixed so time/date is displayed in "local time" (not UTC) for the eventlog check + Added %message% to evenlog check. Will display the "proper formated eventlog message" as in the eventlog viewer. For this to work you need to have the descriptions flag set In short: /nrpe -H 192.168.0.147 -c checkEventLog -a truncate=1024 "syntax=%generated%: %message%" descriptions=true file=System MaxWarn=1 MaxCrit=1 filter+eventType==error filter+generated=\<12h filter=new filter=all filter=in
  • Property mode set to 100644
File size: 17.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
31CheckEventLog gCheckEventLog;
32
33BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
34{
35        NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call);
36        return TRUE;
37}
38
39CheckEventLog::CheckEventLog() {
40}
41CheckEventLog::~CheckEventLog() {
42}
43
44
45bool CheckEventLog::loadModule() {
46        return true;
47}
48bool CheckEventLog::unloadModule() {
49        return true;
50}
51
52bool CheckEventLog::hasCommandHandler() {
53        return true;
54}
55bool CheckEventLog::hasMessageHandler() {
56        return false;
57}
58
59
60
61class EventLogRecord {
62        EVENTLOGRECORD *pevlr_;
63        __int64 currentTime_;
64        std::wstring file_;
65public:
66        EventLogRecord(std::wstring file, EVENTLOGRECORD *pevlr, __int64 currentTime) : file_(file), pevlr_(pevlr), currentTime_(currentTime) {
67        }
68        inline __int64 timeGenerated() const {
69                return (currentTime_-pevlr_->TimeGenerated)*1000;
70        }
71        inline __int64 timeWritten() const {
72                return (currentTime_-pevlr_->TimeWritten)*1000;
73        }
74        inline std::wstring eventSource() const {
75                return reinterpret_cast<WCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + sizeof(EVENTLOGRECORD));
76        }
77        inline DWORD eventID() const {
78                return (pevlr_->EventID&0xffff);
79        }
80        inline DWORD severity() const {
81                return (pevlr_->EventID>>30);
82        }
83
84        inline DWORD eventType() const {
85                return pevlr_->EventType;
86        }
87/*
88        std::wstring userSID() const {
89                if (pevlr_->UserSidOffset == 0)
90                        return "";
91                PSID p = reinterpret_cast<PSID>(reinterpret_cast<LPBYTE>(pevlr_) + + pevlr_->UserSidOffset);
92                LPSTR user = new CHAR[1025];
93                LPSTR domain = new CHAR[1025];
94                DWORD userLen = 1024;
95                DWORD domainLen = 1024;
96                SID_NAME_USE sidName;
97                LookupAccountSid(NULL, p, user, &userLen, domain, &domainLen, &sidName);
98                user[userLen] = 0;
99                domain[domainLen] = 0;
100                return std::wstring(domain) + "\\" + std::wstring(user);
101        }
102        */
103
104        std::wstring enumStrings() const {
105                std::wstring ret;
106                TCHAR* p = reinterpret_cast<TCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + pevlr_->StringOffset);
107                for (unsigned int i =0;i<pevlr_->NumStrings;i++) {
108                        std::wstring s = p;
109                        if (!s.empty())
110                                s += _T(", ");
111                        ret += s;
112                        p+= wcslen(p)+1;
113                }
114                return ret;
115        }
116
117        static DWORD appendType(DWORD dwType, std::wstring sType) {
118                return dwType | translateType(sType);
119        }
120        static DWORD subtractType(DWORD dwType, std::wstring sType) {
121                return dwType & (!translateType(sType));
122        }
123        static DWORD translateType(std::wstring sType) {
124                if (sType == _T("error"))
125                        return EVENTLOG_ERROR_TYPE;
126                if (sType == _T("warning"))
127                        return EVENTLOG_WARNING_TYPE;
128                if (sType == _T("info"))
129                        return EVENTLOG_INFORMATION_TYPE;
130                if (sType == _T("auditSuccess"))
131                        return EVENTLOG_AUDIT_SUCCESS;
132                if (sType == _T("auditFailure"))
133                        return EVENTLOG_AUDIT_FAILURE;
134                return strEx::stoi(sType);
135        }
136        static std::wstring translateType(DWORD dwType) {
137                if (dwType == EVENTLOG_ERROR_TYPE)
138                        return _T("error");
139                if (dwType == EVENTLOG_WARNING_TYPE)
140                        return _T("warning");
141                if (dwType == EVENTLOG_INFORMATION_TYPE)
142                        return _T("info");
143                if (dwType == EVENTLOG_AUDIT_SUCCESS)
144                        return _T("auditSuccess");
145                if (dwType == EVENTLOG_AUDIT_FAILURE)
146                        return _T("auditFailure");
147                return strEx::itos(dwType);
148        }
149        static DWORD translateSeverity(std::wstring sType) {
150                if (sType == _T("success"))
151                        return 0;
152                if (sType == _T("informational"))
153                        return 1;
154                if (sType == _T("warning"))
155                        return 2;
156                if (sType == _T("error"))
157                        return 3;
158                return strEx::stoi(sType);
159        }
160        static std::wstring translateSeverity(DWORD dwType) {
161                if (dwType == 0)
162                        return _T("success");
163                if (dwType == 1)
164                        return _T("informational");
165                if (dwType == 2)
166                        return _T("warning");
167                if (dwType == 3)
168                        return _T("error");
169                return strEx::itos(dwType);
170        }
171        std::wstring get_dll() {
172                HKEY hKey = HKEY_LOCAL_MACHINE;
173                std::wstring path = ((std::wstring)_T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\") + file_ + (std::wstring)_T("\\") + eventSource()).c_str();
174                std::wstring ret;
175                HKEY hTemp;
176                LONG lRet = ERROR_SUCCESS;
177                if (lRet = RegOpenKeyEx(hKey, path.c_str(), 0, KEY_QUERY_VALUE, &hTemp) != ERROR_SUCCESS) {
178                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource() + error::format::from_system(lRet));
179                        return ret;
180                }
181                DWORD type;
182                const DWORD data_length = 2048;
183                DWORD cbData = data_length;
184                BYTE *bData = new BYTE[cbData];
185                lRet = RegQueryValueEx(hTemp, _T("EventMessageFile"), NULL, &type, bData, &cbData);
186                if (lRet == ERROR_SUCCESS) {
187                        if (type == REG_SZ) {
188                                if (cbData < data_length-1) {
189                                        bData[cbData] = 0;
190                                        ret = reinterpret_cast<LPCTSTR>(bData);
191                                } else {
192                                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
193                                }
194                        } else if (type == REG_EXPAND_SZ) {
195#define EXPAND_BUFFER_SIZE 2048
196                                if (cbData < data_length-1) {
197                                        bData[cbData] = 0;
198                                        std::wstring s = reinterpret_cast<LPCTSTR>(bData);
199                                        TCHAR *buffer = new TCHAR[EXPAND_BUFFER_SIZE+1];
200                                        DWORD expRet = ExpandEnvironmentStrings(s.c_str(), buffer, EXPAND_BUFFER_SIZE);
201                                        if (expRet >= EXPAND_BUFFER_SIZE)
202                                                NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
203                                        else
204                                                ret = buffer;
205                                } else {
206                                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
207                                }
208                        } else {
209                                NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource());
210                        }
211                } else {
212                        NSC_LOG_ERROR_STD(_T("Could not extract DLL for eventsource: ") + eventSource() + error::format::from_system(lRet));
213                }
214                RegCloseKey(hTemp);
215                delete [] bData;
216                return ret;
217        }
218
219        std::wstring render_message() {
220                DWORD *dwArgs = new DWORD[pevlr_->NumStrings+1];
221                TCHAR* p = reinterpret_cast<TCHAR*>(reinterpret_cast<LPBYTE>(pevlr_) + pevlr_->StringOffset);
222                for (unsigned int i =0;i<pevlr_->NumStrings;i++) {
223                        dwArgs[i] = reinterpret_cast<DWORD>(p);
224                        DWORD len = wcslen(p);
225                        p += len+1;
226                }
227                std::wstring ret = error::format::message::from_module(get_dll(), eventID(), dwArgs);
228                delete [] dwArgs;
229                std::string::size_type pos = ret.find_last_not_of(_T("\n\t\m"));
230                if (pos != std::string::npos) {
231                        ret = ret.substr(0,pos-1);
232                }
233                return ret;
234        }
235        SYSTEMTIME get_time(DWORD time) {
236                FILETIME FileTime, LocalFileTime;
237                SYSTEMTIME SysTime;
238                __int64 lgTemp;
239                __int64 SecsTo1970 = 116444736000000000;
240
241                lgTemp = Int32x32To64(time,10000000) + SecsTo1970;
242
243                FileTime.dwLowDateTime = (DWORD) lgTemp;
244                FileTime.dwHighDateTime = (DWORD)(lgTemp >> 32);
245
246                FileTimeToLocalFileTime(&FileTime, &LocalFileTime);
247                FileTimeToSystemTime(&LocalFileTime, &SysTime);
248                return SysTime;
249        }
250
251        SYSTEMTIME get_time_generated() {
252                return get_time(pevlr_->TimeGenerated);
253        }
254        SYSTEMTIME get_time_written() {
255                return get_time(pevlr_->TimeWritten);
256        }
257
258        std::wstring render(bool propper, std::wstring syntax, std::wstring date_format = DATE_FORMAT) {
259                if (propper) {
260                        // To obtain the appropriate message string from the message file, load the message file with the LoadLibrary function and use the FormatMessage function
261                        strEx::replace(syntax, _T("%message%"), render_message());
262                } else {
263                        strEx::replace(syntax, _T("%message%"), _T("%message% needs the descriptions flag set!"));
264                }
265
266                strEx::replace(syntax, _T("%source%"), eventSource());
267                strEx::replace(syntax, _T("%generated%"), strEx::format_date(get_time_generated(), date_format));
268                strEx::replace(syntax, _T("%written%"), strEx::format_date(get_time_written(), date_format));
269                strEx::replace(syntax, _T("%type%"), translateType(eventType()));
270                strEx::replace(syntax, _T("%severity%"), translateSeverity(severity()));
271                strEx::replace(syntax, _T("%strings%"), enumStrings());
272                strEx::replace(syntax, _T("%id%"), strEx::itos(eventID()));
273                return syntax;
274        }
275};
276
277
278struct eventlog_filter {
279        filters::filter_all_strings eventSource;
280        filters::filter_all_numeric<unsigned int, filters::handlers::eventtype_handler> eventType;
281        filters::filter_all_numeric<unsigned int, filters::handlers::eventseverity_handler> eventSeverity;
282        filters::filter_all_strings message;
283        filters::filter_all_times timeWritten;
284        filters::filter_all_times timeGenerated;
285        filters::filter_all_numeric<DWORD, filters::handlers::eventtype_handler> eventID;
286
287        inline bool hasFilter() {
288                return eventSource.hasFilter() || eventType.hasFilter() || eventID.hasFilter() || eventSeverity.hasFilter() || message.hasFilter() ||
289                        timeWritten.hasFilter() || timeGenerated.hasFilter();
290        }
291        bool matchFilter(const EventLogRecord &value) const {
292                if ((eventSource.hasFilter())&&(eventSource.matchFilter(value.eventSource())))
293                        return true;
294                else if ((eventType.hasFilter())&&(eventType.matchFilter(value.eventType())))
295                        return true;
296                else if ((eventSeverity.hasFilter())&&(eventSeverity.matchFilter(value.severity())))
297                        return true;
298                else if ((eventID.hasFilter())&&(eventID.matchFilter(value.eventID())))
299                        return true;
300                else if ((message.hasFilter())&&(message.matchFilter(value.enumStrings())))
301                        return true;
302                else if ((timeWritten.hasFilter())&&(timeWritten.matchFilter(value.timeWritten())))
303                        return true;
304                else if ((timeGenerated.hasFilter())&&(timeGenerated.matchFilter(value.timeGenerated())))
305                        return true;
306                return false;
307        }
308};
309
310
311#define MAP_FILTER(value, obj, filtermode) \
312                        else if (p__.first == value) { eventlog_filter filter; filter.obj = p__.second; filter_chain.push_back(filteritem_type(filtermode, filter)); }
313
314
315#define BUFFER_SIZE 1024*64
316NSCAPI::nagiosReturn CheckEventLog::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) {
317        if (command != _T("CheckEventLog"))
318                return NSCAPI::returnIgnored;
319        typedef checkHolders::CheckConatiner<checkHolders::MaxMinBoundsULongInteger> EventLogQueryConatiner;
320        typedef std::pair<int,eventlog_filter> filteritem_type;
321        typedef std::list<filteritem_type > filterlist_type;
322        NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
323        std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args);
324
325        std::list<std::wstring> files;
326        filterlist_type filter_chain;
327        EventLogQueryConatiner query;
328
329        bool bPerfData = true;
330        bool bFilterIn = true;
331        bool bFilterAll = false;
332        bool bFilterNew = false;
333        bool bShowDescriptions = false;
334        unsigned int truncate = 0;
335        std::wstring syntax;
336        const int filter_plus = 1;
337        const int filter_minus = 2;
338        const int filter_normal = 3;
339        const int filter_compat = 3;
340        NSC_DEBUG_MSG_STD(_T("000") + message) ;
341
342        try {
343                MAP_OPTIONS_BEGIN(stl_args)
344                        MAP_OPTIONS_NUMERIC_ALL(query, _T(""))
345                        MAP_OPTIONS_STR2INT(_T("truncate"), truncate)
346                        MAP_OPTIONS_BOOL_TRUE(_T("descriptions"), bShowDescriptions)
347                        MAP_OPTIONS_PUSH(_T("file"), files)
348                        MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
349                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterNew, _T("new"), _T("old"))
350                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterIn, _T("in"), _T("out"))
351                        MAP_OPTIONS_BOOL_EX(_T("filter"), bFilterAll, _T("all"), _T("any"))
352                        MAP_OPTIONS_STR(_T("syntax"), syntax)
353                        /*
354                        MAP_FILTER_OLD("filter-eventType", eventType)
355                        MAP_FILTER_OLD("filter-severity", eventSeverity)
356                        MAP_FILTER_OLD("filter-eventID", eventID)
357                        MAP_FILTER_OLD("filter-eventSource", eventSource)
358                        MAP_FILTER_OLD("filter-generated", timeGenerated)
359                        MAP_FILTER_OLD("filter-written", timeWritten)
360                        MAP_FILTER_OLD("filter-message", message)
361*/
362                        MAP_FILTER(_T("filter+eventType"), eventType, filter_plus)
363                        MAP_FILTER(_T("filter+severity"), eventSeverity, filter_plus)
364                        MAP_FILTER(_T("filter+eventID"), eventID, filter_plus)
365                        MAP_FILTER(_T("filter+eventSource"), eventSource, filter_plus)
366                        MAP_FILTER(_T("filter+generated"), timeGenerated, filter_plus)
367                        MAP_FILTER(_T("filter+written"), timeWritten, filter_plus)
368                        MAP_FILTER(_T("filter+message"), message, filter_plus)
369
370                        MAP_FILTER(_T("filter.eventType"), eventType, filter_normal)
371                        MAP_FILTER(_T("filter.severity"), eventSeverity, filter_normal)
372                        MAP_FILTER(_T("filter.eventID"), eventID, filter_normal)
373                        MAP_FILTER(_T("filter.eventSource"), eventSource, filter_normal)
374                        MAP_FILTER(_T("filter.generated"), timeGenerated, filter_normal)
375                        MAP_FILTER(_T("filter.written"), timeWritten, filter_normal)
376                        MAP_FILTER(_T("filter.message"), message, filter_normal)
377
378                        MAP_FILTER(_T("filter-eventType"), eventType, filter_minus)
379                        MAP_FILTER(_T("filter-severity"), eventSeverity, filter_minus)
380                        MAP_FILTER(_T("filter-eventID"), eventID, filter_minus)
381                        MAP_FILTER(_T("filter-eventSource"), eventSource, filter_minus)
382                        MAP_FILTER(_T("filter-generated"), timeGenerated, filter_minus)
383                        MAP_FILTER(_T("filter-written"), timeWritten, filter_minus)
384                        MAP_FILTER(_T("filter-message"), message, filter_minus)
385
386                        MAP_OPTIONS_MISSING(message, _T("Unknown argument: "))
387                        MAP_OPTIONS_END()
388        } catch (filters::parse_exception e) {
389                message = e.getMessage();
390                return NSCAPI::returnUNKNOWN;
391        } catch (filters::filter_exception e) {
392                message = e.getMessage();
393                return NSCAPI::returnUNKNOWN;
394        }
395
396        unsigned long int hit_count = 0;
397
398        for (std::list<std::wstring>::const_iterator cit2 = files.begin(); cit2 != files.end(); ++cit2) {
399                HANDLE hLog = OpenEventLog(NULL, (*cit2).c_str());
400                if (hLog == NULL) {
401                        message = _T("Could not open the '") + (*cit2) + _T("' event log: ") + error::lookup::last_error();
402                        return NSCAPI::returnUNKNOWN;
403                }
404
405                //DWORD dwThisRecord;
406                DWORD dwRead, dwNeeded;
407                EVENTLOGRECORD *pevlr;
408                BYTE bBuffer[BUFFER_SIZE];
409
410                pevlr = reinterpret_cast<EVENTLOGRECORD*>(&bBuffer);
411
412                __time64_t ltime;
413                _time64(&ltime);
414
415                //GetOldestEventLogRecord(hLog, &dwThisRecord);
416
417                while (ReadEventLog(hLog, EVENTLOG_FORWARDS_READ|EVENTLOG_SEQUENTIAL_READ,
418                        0, pevlr, BUFFER_SIZE, &dwRead, &dwNeeded))
419                {
420                        while (dwRead > 0)
421                        {
422                                bool bMatch = bFilterAll;
423                                EventLogRecord record((*cit2), pevlr, ltime);
424
425                                if (filter_chain.empty()) {
426                                        message = _T("No filters specified.");
427                                        return NSCAPI::returnUNKNOWN;
428                                }
429
430
431                                for (filterlist_type::const_iterator cit3 = filter_chain.begin(); cit3 != filter_chain.end(); ++cit3 ) {
432                                        int mode = (*cit3).first;
433                                        bool bTmpMatched = (*cit3).second.matchFilter(record);
434                                        if (!bFilterNew) {
435                                                if (bFilterAll) {
436                                                        if (!bTmpMatched) {
437                                                                bMatch = false;
438                                                                break;
439                                                        }
440                                                } else {
441                                                        if (bTmpMatched) {
442                                                                bMatch = true;
443                                                                break;
444                                                        }
445                                                }
446                                        } else {
447                                                if ((mode == filter_minus)&&(bTmpMatched)) {
448                                                        // a -<filter> hit so thrash item and bail out!
449                                                        bMatch = false;
450                                                        break;
451                                                } else if ((mode == filter_plus)&&(!bTmpMatched)) {
452                                                                // a +<filter> missed hit so thrash item and bail out!
453                                                                bMatch = false;
454                                                                break;
455                                                } else if (bTmpMatched) {
456                                                        bMatch = true;
457                                                }
458                                        }
459                                }
460                                bool match = false;
461                                if ((!bFilterNew)&&((bFilterIn&&bMatch)||(!bFilterIn&&!bMatch))) {
462                                        match = true;
463                                } else if (bFilterNew&&bMatch) {
464                                        match = true;
465                                }
466
467                                if (match) {
468                                        if (!syntax.empty()) {
469                                                strEx::append_list(message, record.render(bShowDescriptions, syntax));
470                                        } else if (!bShowDescriptions) {
471                                                strEx::append_list(message, record.eventSource());
472                                        } else {
473                                                strEx::append_list(message, record.eventSource());
474                                                message += _T("(") + EventLogRecord::translateType(record.eventType()) + _T(", ") +
475                                                        strEx::itos(record.eventID()) + _T(", ") + EventLogRecord::translateSeverity(record.severity()) + _T(")");
476                                                message += _T("[") + record.enumStrings() + _T("]");
477                                        }
478                                        hit_count++;
479                                }
480                                dwRead -= pevlr->Length;
481                                pevlr = (EVENTLOGRECORD *) ((LPBYTE) pevlr + pevlr->Length);
482                        }
483                        pevlr = (EVENTLOGRECORD *) &bBuffer;
484                }
485                CloseEventLog(hLog);
486        }
487
488        if (!bPerfData)
489                query.perfData = false;
490        query.runCheck(hit_count, returnCode, message, perf);
491        if ((truncate > 0) && (message.length() > (truncate-4)))
492                message = message.substr(0, truncate-4) + _T("...");
493        if (message.empty())
494                message = _T("Eventlog check ok");
495        NSC_DEBUG_MSG_STD(_T("Result: ") + message) ;
496        return returnCode;
497}
498
499
500NSC_WRAPPERS_MAIN_DEF(gCheckEventLog);
501NSC_WRAPPERS_IGNORE_MSG_DEF();
502NSC_WRAPPERS_HANDLE_CMD_DEF(gCheckEventLog);
Note: See TracBrowser for help on using the repository browser.