//
// Purpose:
// Logs messages to the event log
//
// Parameters:
// szFunction - name of function that failed
//
// Return value:
// None
//
// Remarks:
// The service must have an entry in the Application event log.
//
VOID SvcReportEvent(LPTSTR szFunction)
{
HANDLE hEventSource;
LPCWSTR lpszStrings[2];
WCHAR Buffer[80];
hEventSource = RegisterEventSourceW(NULL, SVCNAME);
if( NULL != hEventSource )
{
StringCchPrintfW(Buffer, 80, L"%s failed with %d", szFunction, GetLastError());
lpszStrings[0] = SVCNAME;
lpszStrings[1] = Buffer;
ReportEventW(hEventSource, // event log handle
EVENTLOG_ERROR_TYPE, // event type
0, // event category
EVENTLOG_ERROR_TYPE, // event identifier
NULL, // no security identifier
2, // size of lpszStrings array
0, // no binary data
lpszStrings, // array of strings
NULL); // no binary data
DeregisterEventSource(hEventSource);
}
}
/******************************************************************************
* ReportEventA [ADVAPI32.@]
*
* Writes an entry at the end of an event log.
*
* PARAMS
* hEventLog [I] Handle of an event log.
* wType [I] See MSDN doc.
* wCategory [I] Event category.
* dwEventID [I] Event identifier.
* lpUserSid [I] Current user's security identifier.
* wNumStrings [I] Number of insert strings in lpStrings.
* dwDataSize [I] Size of event-specific raw data to write.
* lpStrings [I] Buffer containing an array of string to be merged.
* lpRawData [I] Buffer containing the binary data.
*
* RETURNS
* Success: nonzero. Entry was written to the log.
* Failure: zero.
*
* NOTES
* The ReportEvent function adds the time, the entry's length, and the
* offsets before storing the entry in the log. If lpUserSid != NULL, the
* username is also logged.
*/
BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData)
{
LPWSTR *wideStrArray;
UNICODE_STRING str;
UINT i;
BOOL ret;
FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
if (wNumStrings == 0) return TRUE;
if (!lpStrings) return TRUE;
wideStrArray = heap_alloc(sizeof(LPWSTR) * wNumStrings);
for (i = 0; i < wNumStrings; i++)
{
RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
wideStrArray[i] = str.Buffer;
}
ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
wNumStrings, dwDataSize, (LPCWSTR *)wideStrArray, lpRawData);
for (i = 0; i < wNumStrings; i++)
heap_free( wideStrArray[i] );
heap_free(wideStrArray);
return ret;
}
/*
* Class: org_apache_log4j_nt_NTEventLogAppender
* Method: reportEvent
* Signature: (ILjava/lang/String;I)V
*/
JNIEXPORT void JNICALL Java_org_apache_log4j_nt_NTEventLogAppender_reportEvent(
JNIEnv *env, jobject java_this, jint jhandle, jstring jstr, jint priority) {
jboolean localHandle = JNI_FALSE;
HANDLE handle = gEventSources.getHandle(jhandle);
if (handle == 0) {
// Client didn't give us a handle so make a local one.
handle = RegisterEventSourceW(NULL, L"Log4j");
localHandle = JNI_TRUE;
}
// convert Java String to character array
jsize msgLen = env->GetStringLength(jstr);
jchar* msg = (jchar*) malloc((msgLen + 1) * sizeof(jchar));
env->GetStringRegion(jstr, 0, msgLen, msg);
msg[msgLen] = 0;
// This is the only message supported by the package. It is backed by
// a message resource which consists of just '%1' which is replaced
// by the string we just created.
const DWORD messageID = 0x1000;
ReportEventW(handle, getType(priority),
getCategory(priority),
messageID, NULL, 1, 0, (const wchar_t**) &msg, NULL);
free((void *)msg);
if (localHandle == JNI_TRUE) {
// Created the handle here so free it here too.
DeregisterEventSource(handle);
}
return;
}
//
// FUNCTION: CServiceBase::WriteEventLogEntry(PWSTR, WORD)
//
// PURPOSE: Log a message to the Application event log.
//
// PARAMETERS:
// * pszMessage - string message to be logged.
// * wType - the type of event to be logged. The parameter can be one of
// the following values.
//
// EVENTLOG_SUCCESS
// EVENTLOG_AUDIT_FAILURE
// EVENTLOG_AUDIT_SUCCESS
// EVENTLOG_ERROR_TYPE
// EVENTLOG_INFORMATION_TYPE
// EVENTLOG_WARNING_TYPE
//
void CServiceBase::WriteEventLogEntry(const wchar_t* pszMessage, WORD wType)
{
HANDLE hEventSource = NULL;
LPCWSTR lpszStrings[2] = { NULL, NULL };
hEventSource = RegisterEventSourceW(NULL, m_name);
if (hEventSource)
{
lpszStrings[0] = m_name;
lpszStrings[1] = pszMessage;
ReportEventW(hEventSource, // Event log handle
wType, // Event type
0, // Event category
0, // Event identifier
NULL, // No security identifier
2, // Size of lpszStrings array
0, // No binary data
lpszStrings, // Array of strings
NULL // No binary data
);
DeregisterEventSource(hEventSource);
}
}
void Logger::reportLog(DWORD type, DWORD msgId, LPCWSTR message, va_list ap) {
if (m_hEventSrc && m_reportLogBuf) {
ZeroMemory(m_reportLogBuf, REPORT_LOG_BUF_SIZE);
int sprintfResult = wvsprintfW(m_reportLogBuf, message, ap);
if (sprintfResult > -1)
ReportEventW(m_hEventSrc, type & 0xFFFF, 0, msgId, NULL, 1, 0, const_cast<const WCHAR **>(&m_reportLogBuf), NULL);
}
}
void log_info(wchar_t *mess){
HANDLE logh;
wchar_t *strings[] = {service_name, mess , NULL};
if(!(logh = RegisterEventSourceW(NULL,APP_NAME)))
return;
ReportEventW(logh, EVENTLOG_INFORMATION_TYPE, 0, MSG_INFO,
NULL, 2, 0, strings, NULL);
DeregisterEventSource(logh);
}
static void log_event(unsigned int event_id, const char *format, ...) {
va_list ap;
va_start(ap, format);
if (event_log != NULL) {
char message[MESSAGE_SIZE];
int n = vsnprintf_s(message, MESSAGE_SIZE, _TRUNCATE, format, ap);
if (n > 0) {
int severity = event_id >> 30;
WORD type = (WORD)(severity == 3 ? EVENTLOG_ERROR_TYPE : severity == 2 ? EVENTLOG_WARNING_TYPE : EVENTLOG_INFORMATION_TYPE);
ReportEventW(event_log, type, 0, event_id, NULL, 0, (DWORD)n, NULL, message);
}
void EventLogChannel::log(const Message& msg)
{
if (!_h) open();
#if defined(POCO_WIN32_UTF8)
std::wstring utext;
UnicodeConverter::toUTF16(msg.getText(), utext);
const wchar_t* pMsg = utext.c_str();
ReportEventW(_h, getType(msg), getCategory(msg), POCO_MSG_LOG, NULL, 1, 0, &pMsg, NULL);
#else
const char* pMsg = msg.getText().c_str();
ReportEvent(_h, getType(msg), getCategory(msg), POCO_MSG_LOG, NULL, 1, 0, &pMsg, NULL);
#endif
}
void writeLogW(const wchar_t* const infoStr) {
#if TARGET_OS_MAC
printf("%ls\n", infoStr);
#endif
#if TARGET_OS_WIN
HANDLE hSource;
wchar_t* szList[1];
szList[0] = const_cast<wchar_t*>(infoStr);
hSource = RegisterEventSource(NULL, VizKit::VisualConfiguration::kVisualPluginName);
if (hSource != NULL) {
ReportEventW(hSource, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (LPCWSTR*)szList, NULL);
DeregisterEventSource(hSource);
}
#endif
}
DWORD logMessage(WORD wType, LPCWSTR message)
{
debug(L"Starting RegisterEventSourceW\n");
HANDLE hEventLog = RegisterEventSourceW(NULL, PROVIDER_NAME);
LPCWSTR pInsertStrings[1] = {message};
DWORD dwEventDataSize = 0;
if (hEventLog == NULL)
return FALSE;
debug(L"Starting ReportEventW\n");
if (!ReportEventW(hEventLog, wType, NULL, EVMSG_STDMSG, NULL, 1, 0, pInsertStrings, NULL)) {
DeregisterEventSource(hEventLog);
return FALSE;
}
DeregisterEventSource(hEventLog);
return TRUE;
}
BOOL
WriteLogMessage(WORD wType, DWORD dwEventID, LPWSTR lpMsg)
{
if (!SettingsInfo.bLogEnabled) return TRUE;
if (!ReportEventW(hLog,
wType,
0,
dwEventID,
NULL,
1,
0,
(LPCWSTR*)&lpMsg,
NULL))
{
return FALSE;
}
return TRUE;
}
void LogChannelSyslog::writeLogEntry( const String& entry, LogChannel::LogMessage* pOrigMsg )
{
WORD wType;
DWORD dwEventID;
if ( pOrigMsg->m_level <= LOGLEVEL_ERROR )
{
wType = EVENTLOG_ERROR_TYPE;
dwEventID = 3 << 30;
}
else if ( pOrigMsg->m_level == LOGLEVEL_WARN )
{
wType = EVENTLOG_WARNING_TYPE;
dwEventID = 2 << 30;
}
else {
wType = EVENTLOG_INFORMATION_TYPE;
dwEventID = 1 << 30;
}
// From MS docs; event ID = gravity | custom | facility | code;
dwEventID |= (1 << 29) | ((m_facility&0x1FF) << 16) | (pOrigMsg->m_code & 0xFFFF);
AutoWString w_msg( entry );
const wchar_t* strings[] = { w_msg.w_str() };
ReportEventW(
(HANDLE)m_sysdata, // __in HANDLE hEventLog,
wType, // __in WORD wType,
m_facility, // __in WORD wCategory,
dwEventID, // __in DWORD dwEventID,
NULL, // __in PSID lpUserSid,
1, // __in WORD wNumStrings,
0, // __in DWORD dwDataSize,
strings, // __in LPCTSTR *lpStrings,
NULL // __in LPVOID lpRawData
);
}
static void
windows_event_logger_log(grn_ctx *ctx, grn_log_level level,
const char *timestamp, const char *title,
const char *message, const char *location,
void *user_data)
{
grn_windows_event_logger_data *data = user_data;
WORD type;
WORD category = 0;
DWORD event_id = 0;
PSID user_sid = NULL;
WORD n_strings = 1;
DWORD event_data_size = 0;
const WCHAR *strings[1];
LPVOID event_data = NULL;
const char level_marks[] = " EACewnid-";
grn_obj formatted_buffer;
UINT code_page;
DWORD convert_flags = 0;
int n_converted_chars;
switch (level) {
case GRN_LOG_NONE :
return;
break;
case GRN_LOG_EMERG :
case GRN_LOG_ALERT :
case GRN_LOG_CRIT :
case GRN_LOG_ERROR :
type = EVENTLOG_ERROR_TYPE;
break;
case GRN_LOG_WARNING :
type = EVENTLOG_WARNING_TYPE;
break;
case GRN_LOG_NOTICE :
case GRN_LOG_INFO :
case GRN_LOG_DEBUG :
case GRN_LOG_DUMP :
type = EVENTLOG_INFORMATION_TYPE;
break;
default :
type = EVENTLOG_ERROR_TYPE;
break;
}
if (data->event_source == INVALID_HANDLE_VALUE) {
data->event_source = RegisterEventSourceA(NULL, data->event_source_name);
if (data->event_source == INVALID_HANDLE_VALUE) {
return;
}
}
GRN_TEXT_INIT(&formatted_buffer, 0);
if (location && location[0]) {
grn_text_printf(ctx, &formatted_buffer, "%s|%c|%s %s %s",
timestamp, level_marks[level], title, message, location);
} else {
grn_text_printf(ctx, &formatted_buffer, "%s|%c|%s %s",
timestamp, level_marks[level], title, message);
}
code_page = grn_windows_encoding_to_code_page(ctx->encoding);
n_converted_chars = MultiByteToWideChar(code_page,
convert_flags,
GRN_TEXT_VALUE(&formatted_buffer),
GRN_TEXT_LEN(&formatted_buffer),
NULL,
0);
#define CONVERTED_BUFFER_SIZE 512
if (n_converted_chars < CONVERTED_BUFFER_SIZE) {
WCHAR converted_buffer[CONVERTED_BUFFER_SIZE];
n_converted_chars = MultiByteToWideChar(code_page,
convert_flags,
GRN_TEXT_VALUE(&formatted_buffer),
GRN_TEXT_LEN(&formatted_buffer),
converted_buffer,
CONVERTED_BUFFER_SIZE);
converted_buffer[n_converted_chars] = L'\0';
strings[0] = converted_buffer;
ReportEventW(data->event_source, type, category, event_id, user_sid,
n_strings, event_data_size,
strings, event_data);
#undef CONVERTED_BUFFER_SIZE
} else {
WCHAR *converted;
converted = GRN_MALLOCN(WCHAR, n_converted_chars);
n_converted_chars = MultiByteToWideChar(code_page,
convert_flags,
GRN_TEXT_VALUE(&formatted_buffer),
GRN_TEXT_LEN(&formatted_buffer),
converted,
n_converted_chars);
converted[n_converted_chars] = L'\0';
strings[0] = converted;
ReportEventW(data->event_source, type, category, event_id, user_sid,
n_strings, event_data_size,
strings, event_data);
GRN_FREE(converted);
}
GRN_OBJ_FIN(ctx, &formatted_buffer);
}
void CAGCEventLogger::LogEvent(IAGCEvent* pEvent, bool bSynchronous)
{
PRIVATE_ASSERTE(pEvent);
XLock lock(this);
// Determine if we can log to either event log type
bool bLogToNT = m_bLoggingToNTEnabled && !m_shEventLog.IsNull();
bool bLogToDB = m_bLoggingToDBEnabled && m_ds.m_spInit != NULL;
// Get the event ID
AGCEventID idEvent;
PRIVATE_VERIFYE(SUCCEEDED(pEvent->get_ID(&idEvent)));
// Determine if the event is enabled for each event log type
VARIANT_BOOL bEnabled;
if (bLogToNT && NULL != m_spRangesNT
&& SUCCEEDED(m_spRangesNT->get_IntersectsWithValue(idEvent, &bEnabled)))
bLogToNT = !!bEnabled;
if (bLogToDB && NULL != m_spRangesDB
&& SUCCEEDED(m_spRangesDB->get_IntersectsWithValue(idEvent, &bEnabled)))
bLogToDB = !!bEnabled;
// Unlock the CritSec
lock.Unlock();
// Do nothing if we're not logging this event anywhere
if (!bLogToNT && !bLogToDB)
return;
// Find the event definition
const CAGCEventDef::XEventDef* pEventDef = CAGCEventDef::find(idEvent);
PRIVATE_ASSERTE(pEventDef);
// Output the event to the debug monitor
#if 0 && defined(_DEBUG)
{
CComBSTR bstrDescription, bstrSubjectName;
PRIVATE_VERIFYE(SUCCEEDED(pEvent->get_Description(&bstrDescription)));
PRIVATE_VERIFYE(SUCCEEDED(pEvent->get_SubjectName (&bstrSubjectName)));
int cchDbg = bstrSubjectName.Length() + bstrDescription.Length() + 16;
_TRACE_BEGIN_SIZE(cchDbg)
if (bstrSubjectName.Length())
_TRACE_PART1("%ls:\n", (BSTR)bstrSubjectName);
if (bstrDescription.Length())
_TRACE_PART1("%ls\n" , (BSTR)bstrDescription);
_TRACE_END
}
#endif // defined(_DEBUG)
// Log the event to the NT Event Log, if specified
if (bLogToNT)
{
PRIVATE_ASSERTE(IsWinNT());
IAGCEventLoggerHookPtr spHook;
get_HookForNTLogging(&spHook);
if (NULL == spHook || S_FALSE == spHook->LogEvent(pEvent, VARBOOL(bSynchronous)))
{
XLock lockNT(this);
if (m_bLoggingToNTEnabled && !m_shEventLog.IsNull())
{
// Get the event severity
WORD wSeverity = pEventDef->m_wSeverity;
// Create the full event id (regarding the MC-generated id's)
UINT nBits;
switch (wSeverity)
{
case EVENTLOG_INFORMATION_TYPE: nBits = 0x01 << 30; break;
case EVENTLOG_WARNING_TYPE : nBits = 0x02 << 30; break;
case EVENTLOG_ERROR_TYPE : nBits = 0x03 << 30; break;
case EVENTLOG_SUCCESS : nBits = 0x00 << 30; break;
default : PRIVATE_ASSERTE(!"Bad severity code.");
}
DWORD dwEventID = nBits | idEvent;
// Get the event replacement parameters
CAGCEventDef::XParamStrings vecParamStrings;
PRIVATE_VERIFYE(SUCCEEDED(CAGCEventDef::GetEventParameters(pEvent,
vecParamStrings, pEventDef)));
// mdvalley: prevent crashes when no %Parameter% in strings.
// That took so long to figure out.
WORD NumStrings = vecParamStrings.size();
LPCWSTR* lpStrings = NULL;
if(NumStrings)
lpStrings = (LPCWSTR*)(&(*vecParamStrings.begin()));
// Report the event to the NT Event log
ReportEventW(m_shEventLog, wSeverity, 0, dwEventID, NULL,
vecParamStrings.size(), 0,
// VS.Net 2003 port
#if _MSC_VER >= 1310
lpStrings, NULL);
// (LPCWSTR*)(&(*vecParamStrings.begin())), NULL);
#else
(LPCWSTR*)(vecParamStrings.begin()), NULL);
#endif
// Free the replacement parameters BSTR's
for (CAGCEventDef::XParamStrings::iterator it = vecParamStrings.begin();
it != vecParamStrings.end(); ++it)
SysFreeString(*it);
}
}
