VOID nt_rpc_report(LPTSTR lpszMsg) { CHAR chMsg[256]; HANDLE hEventSource; LPTSTR lpszStrings[2]; // Use event logging to log the error. // hEventSource = RegisterEventSource(NULL, TEXT("rpc.dll")); sprintf(chMsg, "sunrpc report: %d", GetLastError()); lpszStrings[0] = chMsg; lpszStrings[1] = lpszMsg; if (hEventSource != NULL) { ReportEvent(hEventSource, // handle of event source EVENTLOG_WARNING_TYPE, // event type 0, // event category 0, // event ID NULL, // current user's SID 2, // strings in lpszStrings 0, // no bytes of raw data lpszStrings, // array of error strings NULL); // no raw data (VOID) DeregisterEventSource(hEventSource); } }
/////////////////////////////////////////////////////////////////////////////////////// // Logging functions void CServiceModule::LogEvent(LPCTSTR pFormat, ...) { TCHAR chMsg[256]; HANDLE hEventSource; LPTSTR lpszStrings[1]; va_list pArg; va_start(pArg, pFormat); _vstprintf(chMsg, pFormat, pArg); va_end(pArg); lpszStrings[0] = chMsg; if (m_bService) { /* Get a handle to use with ReportEvent(). */ hEventSource = RegisterEventSource(NULL, m_szServiceName); if (hEventSource != NULL) { /* Write to event log. */ ReportEvent(hEventSource, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (LPCTSTR*) &lpszStrings[0], NULL); DeregisterEventSource(hEventSource); } } else { // As we are not running as a service, just write the error to the console. _putts(chMsg); } }
void SvcReportEvent(WORD wType, DWORD dwEventID, LPTSTR msg) { HANDLE hEventSource; LPCTSTR lpszStrings[2]; hEventSource = RegisterEventSource(nullptr, SVCNAME); if (hEventSource) { lpszStrings[0] = SVCNAME; lpszStrings[1] = msg; ReportEvent(hEventSource, wType, 0, dwEventID, nullptr, 2, 0, lpszStrings, nullptr); DeregisterEventSource(hEventSource); } }
void svOutput::OpenEventLog(void) { #ifdef __WIN32__ if (el_source == NULL) { el_source = RegisterEventSource(NULL, "Suva"); } #endif }
explicit Private( Facility facility_ ) : KDEncodingLogDevice::Private( QTextCodec::codecForLocale() ), facility( facility_ ), internal( RegisterEventSource( 0, TEXT("Application") ) ) { if ( !internal ) fprintf( stderr, "Error in RegisterEventSourceA(): %u\n", static_cast< unsigned int >( GetLastError() ) ); }
void openlog(const char *ident, int logopt, int facility) { closelog(); PW32G(log_source) = RegisterEventSource(NULL, "PHP-" PHP_VERSION); spprintf(&PW32G(log_header), 0, (logopt & LOG_PID) ? "%s[%d]" : "%s", ident, getpid()); }
void openlog (const char *ident,int logopt,int facility) { char tmp[MAILTMPLEN]; if (!check_nt ()) return; /* no-op on non-NT system */ if (loghdl) fatal ("Duplicate openlog()!"); loghdl = RegisterEventSource (NIL,ident); sprintf (tmp,(logopt & LOG_PID) ? "%s[%d]" : "%s",ident,getpid ()); loghdr = cpystr (tmp); /* save header for later */ }
void logToSystemLog(LogLevel_t level, char *msg) { #ifdef WIN32 HANDLE eventHandle; char *strings[2]; eventHandle = RegisterEventSource(NULL, Program); strings[0] = msg; strings[1] = NULL; if (eventHandle != NULL) { ReportEvent(eventHandle, /* Handle of event source */ (level == LLOG_SEVERE ? EVENTLOG_ERROR_TYPE : EVENTLOG_INFORMATION_TYPE), /* Event type */ (WORD)level, /* Event category */ 0, /* Event ID */ NULL, /* User SID */ 1, /* Number of message strings */ 0, /* Bytes of binary data */ (const char **)strings, /* Array of message strings */ NULL); /* No binary data */ DeregisterEventSource(eventHandle); } #else int logLevel; /* ** Messages at level 0 are errors, 1 is notice, 2 informational ** and everything else is classed as debug. */ switch (level) { case LLOG_SEVERE: logLevel = LOG_ERR; break; case LLOG_WARNING: logLevel = LOG_NOTICE; break; case LLOG_INFO: logLevel = LOG_INFO; break; default: logLevel = LOG_DEBUG; break; } syslog(logLevel, "%s", msg); #endif }
void mprWriteToOsLog(MprCtx ctx, cchar *message, int flags, int level) { HKEY hkey; void *event; long errorType; ulong exists; char buf[MPR_MAX_STRING], logName[MPR_MAX_STRING], *lines[9], *cp, *value; int type; static int once = 0; mprStrcpy(buf, sizeof(buf), message); cp = &buf[strlen(buf) - 1]; while (*cp == '\n' && cp > buf) { *cp-- = '\0'; } type = EVENTLOG_ERROR_TYPE; lines[0] = buf; lines[1] = 0; lines[2] = lines[3] = lines[4] = lines[5] = 0; lines[6] = lines[7] = lines[8] = 0; if (once == 0) { /* Initialize the registry */ once = 1; mprSprintf(logName, sizeof(logName), "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\%s", mprGetAppName(ctx)); hkey = 0; if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, logName, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, &exists) == ERROR_SUCCESS) { value = "%SystemRoot%\\System32\\netmsg.dll"; if (RegSetValueEx(hkey, "EventMessageFile", 0, REG_EXPAND_SZ, (uchar*) value, (int) strlen(value) + 1) != ERROR_SUCCESS) { RegCloseKey(hkey); return; } errorType = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE; if (RegSetValueEx(hkey, "TypesSupported", 0, REG_DWORD, (uchar*) &errorType, sizeof(DWORD)) != ERROR_SUCCESS) { RegCloseKey(hkey); return; } RegCloseKey(hkey); } } event = RegisterEventSource(0, mprGetAppName(ctx)); if (event) { /* * 3299 is the event number for the generic message in netmsg.dll. * "%1 %2 %3 %4 %5 %6 %7 %8 %9" -- thanks Apache for the tip */ ReportEvent(event, EVENTLOG_ERROR_TYPE, 0, 3299, NULL, sizeof(lines) / sizeof(char*), 0, (LPCSTR*) lines, 0); DeregisterEventSource(event); } }
void openlog(const char *ident, int option, int facility) { if (eventlog) closelog(); eventlog = RegisterEventSource(NULL, "Application"); if (ident) eventlogPrefix = strdup(ident); }
void lutil_LogStoppedEvent( char *svc ) { HANDLE hEventLog; hEventLog = RegisterEventSource( NULL, svc ); ReportEvent( hEventLog, EVENTLOG_INFORMATION_TYPE, 0, MSG_SVC_STOPPED, NULL, 0, 0, NULL, NULL ); DeregisterEventSource( hEventLog ); }
PUBLIC void syslog(int priority, char *fmt, ...) { va_list args; HKEY hkey; void *event; long errorType; ulong exists; char *buf, logName[ME_GOAHEAD_LIMIT_STRING], *lines[9], *cp, *value; int type; static int once = 0; va_start(args, fmt); buf = sfmtv(fmt, args); va_end(args); cp = &buf[slen(buf) - 1]; while (*cp == '\n' && cp > buf) { *cp-- = '\0'; } type = EVENTLOG_ERROR_TYPE; lines[0] = buf; lines[1] = 0; lines[2] = lines[3] = lines[4] = lines[5] = 0; lines[6] = lines[7] = lines[8] = 0; if (once == 0) { /* Initialize the registry */ once = 1; hkey = 0; if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, logName, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, &exists) == ERROR_SUCCESS) { value = "%SystemRoot%\\System32\\netmsg.dll"; if (RegSetValueEx(hkey, "EventMessageFile", 0, REG_EXPAND_SZ, (uchar*) value, (int) slen(value) + 1) != ERROR_SUCCESS) { RegCloseKey(hkey); wfree(buf); return; } errorType = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE; if (RegSetValueEx(hkey, "TypesSupported", 0, REG_DWORD, (uchar*) &errorType, sizeof(DWORD)) != ERROR_SUCCESS) { RegCloseKey(hkey); wfree(buf); return; } RegCloseKey(hkey); } } event = RegisterEventSource(0, ME_NAME); if (event) { ReportEvent(event, EVENTLOG_ERROR_TYPE, 0, 3299, NULL, sizeof(lines) / sizeof(char*), 0, (LPCSTR*) lines, 0); DeregisterEventSource(event); } wfree(buf); }
VOID RplReportEventEx( IN DWORD MessageId, IN LPWSTR * aStrings ) /*++ Routine Description: Writes an event in the event log. A related function lives is RplReportEvent() in lib\report.c. These two functions should be united. Arguments: MessageId - Message ID aStrings - a NULL terminated array of strings Return Value: None. --*/ { WORD cStrings; HANDLE logHandle; logHandle = RegisterEventSource( NULL, RPL_EVENTLOG_NAME); // If the event log cannot be opened, just return. if ( logHandle == NULL) { RplDump( ++RG_Assert, ("Error=%d", GetLastError())); return; } for ( cStrings = 0; aStrings[ cStrings] != NULL; cStrings++) { NOTHING; } if ( !ReportEvent( logHandle, EVENTLOG_ERROR_TYPE, 0, // event category MessageId, // event id NULL, // user SID. We're local system - uninteresting cStrings, // number of strings 0, // raw data size aStrings, // string array NULL // raw data buffer )) { RplDump( ++RG_Assert, ( "Error=%d", GetLastError())); } DeregisterEventSource( logHandle); }
void PrintEvent(const TCHAR* psz) { const TCHAR* rgsz[] = { psz }; HANDLE hes = RegisterEventSource(0, _T("appserv")); if(hes) { ReportEvent(hes, EVENTLOG_INFORMATION_TYPE, 0, 0, 0, 1, 0, rgsz, 0); DeregisterEventSource(hes); } }
void setupForRun(int argc, char **argv, bool debug, const wxString &executable) { if (!debug) { eventHandle = RegisterEventSource(0, serviceName.c_str()); if (!eventHandle) LogMessage(_("Couldn't register event handle."), LOG_ERROR); } setOptions(argc, argv, executable); }
void qsrStartUsingLogger( qsrLogMsg * pLog ) { PSO_PRE_CONDITION( pLog != NULL ); pLog->useLog = true; #if defined ( WIN32 ) pLog->handle = RegisterEventSource( NULL, pLog->name ); #else openlog( pLog->name, LOG_PID, LOG_USER ); #endif }
void osi_LogEvent0(char *a,char *b) { HANDLE h; char *ptbuf[1]; if (!ISCLIENTTRACE(osi_TraceOption)) return; h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME); ptbuf[0] = b; ReportEvent(h, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (const char **)ptbuf, NULL); DeregisterEventSource(h); }
/* Emulator for BSD openlog() routine * Accepts: identity * options * facility */ void openlog(const char *ident, int logopt, int facility) { char tmp[1024]; if (loghdl) { closelog(); } loghdl = RegisterEventSource(NULL, ident); sprintf(tmp, (logopt & WINLOG_PID) ? "%s[%d]" : "%s", ident, getpid()); loghdr = _strdup(tmp); /* save header for later */ }
MIKTEXINTERNALFUNC(bool) ReportMiKTeXEvent(unsigned short eventType, unsigned long eventId, ...) { #if ! REPORT_EVENTS UNUSED_ALWAYS(eventType); UNUSED_ALWAYS(eventId); return false; #else vector<const char *> vecStrings; va_list marker; va_start(marker, eventId); for (const char * lpsz = va_arg(marker, const char *); lpsz != nullptr; lpsz = va_arg(marker, const char *)) { vecStrings.push_back(lpsz); } va_end(marker); HANDLE hEventSource = RegisterEventSource(0, SOURCE); if (hEventSource == nullptr) { return false; } PSID pSid = 0; size_t bufSize = 8192; AutoMemoryPointer pBuf(malloc(bufSize)); if (pBuf.Get() == nullptr) { OUT_OF_MEMORY("malloc"); } char szAccountName[BufferSizes::MaxPath]; unsigned long n = BufferSizes::MaxPath; if (GetUserName(szAccountName, &n)) { unsigned long sidSize = static_cast<unsigned long>(bufSize); pSid = reinterpret_cast<PSID>(pBuf.Get()); char szDomainName[BufferSizes::MaxPath]; unsigned long domainNameSize = BufferSizes::MaxPath; SID_NAME_USE use; if (!LookupAccountName(0, szAccountName, pSid, &sidSize, szDomainName, &domainNameSize, &use)) { pSid = 0; } } BOOL done = ReportEvent(hEventSource, eventType, 0, eventId, pSid, static_cast<unsigned short>(vecStrings.size()), 0, &vecStrings[0], 0); DeregisterEventSource(hEventSource); return done ? true : false; #endif }
int SockListener(unsigned short *servPort) { int servSock; /* Socket descriptor for server */ int clntSock; /* Socket descriptor for client */ DWORD threadID; /* Thread ID from CreateThread() */ WSADATA wsaData; /* Structure for WinSock setup communication */ wchar_t tmp[TMPBUF]; if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) /* Load Winsock 2.2 DLL */ { wsprintf(tmp, L"SockListener WSAStartup() failed"); WriteLog(tmp); return(-1); } servSock = CreateTCPServerSocket(*servPort); for (;;) { clntSock = AcceptTCPConnection(servSock); { extern TCHAR *ServiceName; HANDLE hEventLog = RegisterEventSource(NULL, ServiceName); BOOL bSuccess; PCTSTR aInsertions [] = { L"call_usermodehelper:", L"Accepted", L"TCP connection" }; bSuccess = ReportEvent( hEventLog, // Handle to the eventlog EVENTLOG_INFORMATION_TYPE, // Type of event 0, // Category (could also be 0) MSG_ACCEPT_TCP, // Event id NULL, // User's sid (NULL for none) 3, // Number of insertion strings 0, // Number of additional bytes aInsertions, // Array of insertion strings NULL // Pointer to additional bytes ); DeregisterEventSource(hEventLog); } /* Create separate memory for client argument */ HANDLE h; if ((h = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) ThreadMain, &clntSock, 0, (LPDWORD) &threadID)) == NULL) { wsprintf(tmp, L"call_usermodehelper: CreateThread failed. err(%d)", GetLastError()); WriteLog(tmp); return -1; } } /* NOT REACHED */ }
BOOL LogEvent( LPCSTR lpUNCServerName, WORD wType, DWORD dwEventID, PSID lpUserSid, LPCSTR message) { LPCSTR messages[] = {message, NULL}; HANDLE hElog = RegisterEventSource(lpUNCServerName, "Shibboleth Daemon"); BOOL res = ReportEvent(hElog, wType, 0, dwEventID, lpUserSid, 1, 0, messages, NULL); return (DeregisterEventSource(hElog) && res); }
void log_init_platform(void) { int rc; _event_log = RegisterEventSource(NULL, "Brick Daemon"); if (_event_log == NULL) { rc = ERRNO_WINAPI_OFFSET + GetLastError(); // this will go to the logfile if it is enabled via --debug log_error("Could not open Windows event log: %s (%d)", get_errno_name(rc), rc); } }
void DebugEvent0(char *a) { HANDLE h; char *ptbuf[1]; if (!ISLOGONTRACE(TraceOption)) return; h = RegisterEventSource(NULL, AFS_LOGON_EVENT_NAME); if (h != INVALID_HANDLE_VALUE) { ptbuf[0] = a; ReportEvent(h, EVENTLOG_INFORMATION_TYPE, 0, 1008, NULL, 1, 0, (const char **)ptbuf, NULL); DeregisterEventSource(h); } }
/* * This function is for reporting errors to the application * event log in case the regular syslog is not available * mainly during startup. It should not be used under normal * circumstances. */ void NTReportError(const char *name, const char *str) { HANDLE hNTAppLog = NULL; const char *buf[1]; buf[0] = str; hNTAppLog = RegisterEventSource(NULL, name); ReportEvent(hNTAppLog, EVENTLOG_ERROR_TYPE, 0, NTP_ERROR, NULL, 1, 0, buf, NULL); DeregisterEventSource(hNTAppLog); }
void osi_LogEvent(char *a,char *b,char *c,...) { HANDLE h; char *ptbuf[1],buf[MAXBUF_+1]; va_list marker; if (!ISCLIENTTRACE(osi_TraceOption)) return; h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME); va_start(marker,c); StringCbVPrintfA(buf,MAXBUF_,c,marker); ptbuf[0] = buf; ReportEvent(h, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (const char **)ptbuf, NULL);\ DeregisterEventSource(h); va_end(marker); }
void EventLogChannel::open() { setUpRegistry(); #if defined(POCO_WIN32_UTF8) std::wstring uhost; UnicodeConverter::toUTF16(_host, uhost); std::wstring uname; UnicodeConverter::toUTF16(_name, uname); _h = 0;//RegisterEventSourceW(uhost.empty() ? NULL : uhost.c_str(), uname.c_str()); #else _h = RegisterEventSource(_host.empty() ? NULL : _host.c_str(), _name.c_str()); #endif if (!_h) throw SystemException("cannot register event source"); }
void rpcapd_log_init(const char *argv0, int also_stderr) { #ifdef WIN32 event_source = RegisterEventSource(NULL, "rpcapd"); #else int flags = LOG_CONS | LOG_PID; if (also_stderr) { flags |= LOG_PERROR; } setlogmask(LOG_UPTO(LOG_NOTICE)); openlog("rpcapd", flags, LOG_DAEMON); #endif }
ERL_NIF_TERM register_event_source(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { char event_source[_MAX_PATH]; HANDLE handle; NIF_GET_STRING(env, argv[0], event_source, _MAX_PATH); NIF_ERR( add_registry_info(env, event_source) ); WINAPI_LASTERR(env, handle = RegisterEventSource(NULL, event_source)); return enif_make_tuple2(env, atom_ok, enif_make_int(env, (int)handle)); }
//记录日志事件到系统中 void LogErrorEvent(LPCTSTR pFormat,...) { _TCHAR pMsg[MAX_PATH]; va_list pArg; va_start(pArg,pFormat); _vstprintf(pMsg,pFormat,pArg); va_end(pArg); LPCTSTR pStr[1] = {pMsg}; if (hEventSource == NULL) hEventSource = RegisterEventSource(NULL,PServiceManage::Instance()->ServiceName()); ReportEvent(hEventSource,EVENTLOG_ERROR_TYPE,0,EVENTID,NULL,1,0,pStr,NULL); }
void ReportError(BOOL bError, LPCTSTR szError) { static BOOL bEventSourceAdded = FALSE; if(!bEventSourceAdded) { TCHAR szModule[MAX_PATH]; GetModuleFileName(g_hInstance,szModule,MAX_PATH); AddEventSource(L"CVSNT",szModule); bEventSourceAdded=TRUE; } HANDLE hEvent = RegisterEventSource(NULL, L"CVSNT"); ReportEvent(hEvent,bError?EVENTLOG_ERROR_TYPE:EVENTLOG_INFORMATION_TYPE,0,MSG_STRING,NULL,1,0,&szError,NULL); DeregisterEventSource(hEvent); }