/*
 * 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;
}
int wmain(int argc, wchar_t *argv[]) {
  if (argc < 3) {
    printf("usage: %ls <pid> (n_args args ...)+\n", argv[0]);
    return 0;
  }

  event_log = RegisterEventSourceW(NULL, PROVIDER_NAME);

  wait_for_parent(argv[1]);

  int arg_index = 2;
  while (arg_index < argc - 1) {
    unsigned long cmd_argc = wcstoul(argv[arg_index++], NULL, 10);
    if (cmd_argc == 0 || cmd_argc > argc - arg_index) {
      log_event(ERR_ARGS, "unexpected '%s' @ %d", argv[arg_index - 1], arg_index - 1);
      break;
    } else {
      wchar_t **cmd_argv = argv + arg_index;
      arg_index += cmd_argc;
      run_command((int)cmd_argc, cmd_argv, arg_index >= argc - 1);
    }
  }

  if (event_log != NULL) {
    DeregisterEventSource(event_log);
  }

  return 0;
}
Exemple #3
0
//
// 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);
    }
}
/*
 * Class:     org.apache.log4j.nt.NTEventLogAppender
 * Method:    registerEventSource
 * Signature: (Ljava/lang/String;Ljava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_org_apache_log4j_nt_NTEventLogAppender_registerEventSource(
   JNIEnv *env, jobject java_this, jstring server, jstring source) {

  jchar *nserver = 0;
  jchar *nsource = 0;

  if (server != 0) {
    jsize serverLen = env->GetStringLength(server);
    nserver = (jchar*) malloc((serverLen +1) * sizeof(jchar));
    env->GetStringRegion(server, 0, serverLen, nserver);
    nserver[serverLen] = 0;
  }
  if (source != 0) {
    jsize sourceLen = env->GetStringLength(source);
    nsource = (jchar*) malloc((sourceLen +1) * sizeof(jchar));
    env->GetStringRegion(source, 0, sourceLen, nsource);
    nsource[sourceLen] = 0;
  }
  addRegistryInfo((wchar_t*) nsource);
  jint handle = gEventSources.createKey(RegisterEventSourceW(
         (const wchar_t*) nserver, (const wchar_t*) nsource));
  free(nserver);
  free(nsource);
  return handle;
}
// 
//   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); 
    } 
} 
Exemple #6
0
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);
}
void EventLogChannel::open()
{
	setUpRegistry();
#if defined(POCO_WIN32_UTF8)
	std::wstring uhost;
	UnicodeConverter::toUTF16(_host, uhost);
	std::wstring uname;
	UnicodeConverter::toUTF16(_name, uname);
	_h = 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");
}
Exemple #8
0
/******************************************************************************
 * RegisterEventSourceA [ADVAPI32.@]
 *
 * Returns a registered handle to an event log.
 *
 * PARAMS
 *  lpUNCServerName [I] UNC name of the source server.
 *  lpSourceName    [I] Specifies the name of the event source to retrieve.
 *
 * RETURNS
 *  Success: Handle to the event log.
 *  Failure: NULL. Returns ERROR_INVALID_HANDLE if lpSourceName specifies the
 *           Security event log.
 */
HANDLE WINAPI RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
{
    UNICODE_STRING lpUNCServerNameW;
    UNICODE_STRING lpSourceNameW;
    HANDLE ret;

    FIXME("(%s,%s): stub\n", debugstr_a(lpUNCServerName), debugstr_a(lpSourceName));

    RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW, lpUNCServerName);
    RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW, lpSourceName);
    ret = RegisterEventSourceW(lpUNCServerNameW.Buffer,lpSourceNameW.Buffer);
    RtlFreeUnicodeString (&lpUNCServerNameW);
    RtlFreeUnicodeString (&lpSourceNameW);
    return ret;
}
static gboolean
gkrellmd_syslog_init()
	{
#if defined(WIN32)
	h_event_log = RegisterEventSourceW(NULL, service_name);
	if (h_event_log == NULL)
		{
		g_warning("Cannot register event source for logging into Windows Event Log.\n");
		return FALSE;
		}
#else
	// Unix needs no logging initialization
#endif
	return TRUE;
	}
Exemple #10
0
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;
}
Exemple #11
0
static DWORD WINAPI service_stderr_thread(LPVOID hPipe)
{
    HANDLE hPipeRead = (HANDLE) hPipe;
    HANDLE hEventSource;
    char errbuf[256];
    char *errmsg = errbuf;
    const char *errarg[9];
    DWORD errres;
    ap_regkey_t *regkey;
    apr_status_t rv;
    apr_pool_t *p;

    apr_pool_create_ex(&p, NULL, NULL, NULL);

    errarg[0] = "The Apache service named";
    errarg[1] = display_name;
    errarg[2] = "reported the following error:\r\n>>>";
    errarg[3] = errbuf;
    errarg[4] = NULL;
    errarg[5] = NULL;
    errarg[6] = NULL;
    errarg[7] = NULL;
    errarg[8] = NULL;

    /* What are we going to do in here, bail on the user?  not. */
    if ((rv = ap_regkey_open(&regkey, AP_REGKEY_LOCAL_MACHINE,
                             "SYSTEM\\CurrentControlSet\\Services\\"
                             "EventLog\\Application\\Apache Service",
                             APR_READ | APR_WRITE | APR_CREATE, p))
            == APR_SUCCESS)
    {
        DWORD dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE |
                       EVENTLOG_INFORMATION_TYPE;

        /* The stock message file */
        ap_regkey_value_set(regkey, "EventMessageFile",
                            "%SystemRoot%\\System32\\netmsg.dll",
                            AP_REGKEY_EXPAND, p);

        ap_regkey_value_raw_set(regkey, "TypesSupported", &dwData,
                                sizeof(dwData), REG_DWORD, p);
        ap_regkey_close(regkey);
    }

    hEventSource = RegisterEventSourceW(NULL, L"Apache Service");

    SetEvent(stderr_ready);

    while (ReadFile(hPipeRead, errmsg, 1, &errres, NULL) && (errres == 1))
    {
        if ((errmsg > errbuf) || !apr_isspace(*errmsg))
        {
            ++errmsg;
            if ((*(errmsg - 1) == '\n')
                    || (errmsg >= errbuf + sizeof(errbuf) - 1))
            {
                while ((errmsg > errbuf) && apr_isspace(*(errmsg - 1))) {
                    --errmsg;
                }
                *errmsg = '\0';

                /* Generic message: '%1 %2 %3 %4 %5 %6 %7 %8 %9'
                 * The event code in netmsg.dll is 3299
                 */
                ReportEvent(hEventSource, EVENTLOG_ERROR_TYPE, 0,
                            3299, NULL, 9, 0, errarg, NULL);
                errmsg = errbuf;
            }
        }
    }

    if ((errres = GetLastError()) != ERROR_BROKEN_PIPE) {
        apr_snprintf(errbuf, sizeof(errbuf),
                     "Win32 error %lu reading stderr pipe stream\r\n",
                     GetLastError());

        ReportEvent(hEventSource, EVENTLOG_ERROR_TYPE, 0,
                    3299, NULL, 9, 0, errarg, NULL);
    }

    CloseHandle(hPipeRead);
    DeregisterEventSource(hEventSource);
    CloseHandle(stderr_thread);
    stderr_thread = NULL;
    apr_pool_destroy(p);
    return 0;
}
Exemple #12
0
VOID
InitLogs(VOID)
{
    WCHAR szBuf[MAX_PATH] = L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\ReactOS Application Manager\\ReactOS Application Manager";
    WCHAR szPath[MAX_PATH];
    DWORD dwCategoryNum = 1;
    DWORD dwDisp, dwData;
    HKEY hKey;

    if (!SettingsInfo.bLogEnabled) return;

    if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                        szBuf, 0, NULL,
                        REG_OPTION_NON_VOLATILE,
                        KEY_WRITE, NULL, &hKey, &dwDisp) != ERROR_SUCCESS) 
    {
        return;
    }

    if (!GetCurrentDirectoryW(MAX_PATH, szPath)) return;
    wcscat(szPath, L"\\rapps.exe");

    if (RegSetValueExW(hKey,
                       L"EventMessageFile",
                       0,
                       REG_EXPAND_SZ,
                       (LPBYTE)szPath,
                       (DWORD)(wcslen(szPath) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
    {
        RegCloseKey(hKey); 
        return;
    }

    dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | 
             EVENTLOG_INFORMATION_TYPE; 
 
    if (RegSetValueExW(hKey,
                       L"TypesSupported",
                       0,
                       REG_DWORD,
                       (LPBYTE)&dwData,
                       sizeof(DWORD)) != ERROR_SUCCESS)
    {
        RegCloseKey(hKey); 
        return;
    }

    if (RegSetValueExW(hKey,
                       L"CategoryMessageFile",
                       0,
                       REG_EXPAND_SZ,
                       (LPBYTE)szPath,
                       (DWORD)(wcslen(szPath) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
    {
        RegCloseKey(hKey); 
        return;
    }

    if (RegSetValueExW(hKey,
                       L"CategoryCount",
                       0,
                       REG_DWORD,
                       (LPBYTE)&dwCategoryNum,
                       sizeof(DWORD)) != ERROR_SUCCESS)
    {
        RegCloseKey(hKey); 
        return;
    }

    RegCloseKey(hKey);

    hLog = RegisterEventSourceW(NULL, L"ReactOS Application Manager");
}
Exemple #13
0
void Logger::initLog(LPCWSTR name, DWORD logLevel) {
    if (!m_hEventSrc) m_hEventSrc = RegisterEventSourceW(NULL, name);
    if (!m_reportLogBuf) m_reportLogBuf = (WCHAR*)malloc(REPORT_LOG_BUF_SIZE);
    m_logLevel = logLevel;
}