* Copyright 1995 Sven Verdoolaege
* Copyright 1998 Juergen Schmied
* Copyright 2003 Mike Hearn
- * Copyright 2007 Hervé Poussineau
+ * Copyright 2007 Hervé Poussineau
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+/* INCLUDES ******************************************************************/
+
#include <advapi32.h>
#include <ndk/kefuncs.h>
static RPC_STRING EmptyStringA = { 0, 0, "" };
+/* FUNCTIONS *****************************************************************/
+
handle_t __RPC_USER
EVENTLOG_HANDLE_A_bind(EVENTLOG_HANDLE_A UNCServerName)
{
handle_t hBinding = NULL;
- UCHAR *pszStringBinding;
+ RPC_CSTR pszStringBinding;
RPC_STATUS status;
TRACE("EVENTLOG_HANDLE_A_bind() called\n");
status = RpcStringBindingComposeA(NULL,
- (UCHAR *)"ncacn_np",
- (UCHAR *)UNCServerName,
- (UCHAR *)"\\pipe\\EventLog",
+ (RPC_CSTR)"ncacn_np",
+ (RPC_CSTR)UNCServerName,
+ (RPC_CSTR)"\\pipe\\EventLog",
NULL,
- (UCHAR **)&pszStringBinding);
+ &pszStringBinding);
if (status)
{
ERR("RpcStringBindingCompose returned 0x%x\n", status);
/* Set the binding handle that will be used to bind to the server. */
status = RpcBindingFromStringBindingA(pszStringBinding,
&hBinding);
- if (status)
+ if (status != RPC_S_OK)
{
ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
}
status = RpcStringFreeA(&pszStringBinding);
- if (status)
+ if (status != RPC_S_OK)
{
ERR("RpcStringFree returned 0x%x\n", status);
}
TRACE("EVENTLOG_HANDLE_A_unbind() called\n");
status = RpcBindingFree(&hBinding);
- if (status)
+ if (status != RPC_S_OK)
{
ERR("RpcBindingFree returned 0x%x\n", status);
}
EVENTLOG_HANDLE_W_bind(EVENTLOG_HANDLE_W UNCServerName)
{
handle_t hBinding = NULL;
- LPWSTR pszStringBinding;
+ RPC_WSTR pszStringBinding;
RPC_STATUS status;
TRACE("EVENTLOG_HANDLE_W_bind() called\n");
status = RpcStringBindingComposeW(NULL,
L"ncacn_np",
- (LPWSTR)UNCServerName,
+ UNCServerName,
L"\\pipe\\EventLog",
NULL,
&pszStringBinding);
- if (status)
+ if (status != RPC_S_OK)
{
ERR("RpcStringBindingCompose returned 0x%x\n", status);
return NULL;
/* Set the binding handle that will be used to bind to the server. */
status = RpcBindingFromStringBindingW(pszStringBinding,
&hBinding);
- if (status)
+ if (status != RPC_S_OK)
{
ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
}
status = RpcStringFreeW(&pszStringBinding);
- if (status)
+ if (status != RPC_S_OK)
{
ERR("RpcStringFree returned 0x%x\n", status);
}
TRACE("EVENTLOG_HANDLE_W_unbind() called\n");
status = RpcBindingFree(&hBinding);
- if (status)
+ if (status != RPC_S_OK)
{
ERR("RpcBindingFree returned 0x%x\n", status);
}
/******************************************************************************
* BackupEventLogA [ADVAPI32.@]
*/
+NTSTATUS
+NTAPI
+ElfBackupEventLogFileA(IN HANDLE hEventLog,
+ IN PANSI_STRING BackupFileNameA)
+{
+ NTSTATUS Status;
+
+ if (!BackupFileNameA || (BackupFileNameA->Length == 0))
+ return STATUS_INVALID_PARAMETER;
+
+ RpcTryExcept
+ {
+ Status = ElfrBackupELFA(hEventLog,
+ (PRPC_STRING)BackupFileNameA);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
BOOL WINAPI
BackupEventLogA(IN HANDLE hEventLog,
IN LPCSTR lpBackupFileName)
{
+ BOOL Success;
+ NTSTATUS Status;
ANSI_STRING BackupFileNameA;
UNICODE_STRING BackupFileNameW;
- NTSTATUS Status;
- BOOL Result;
TRACE("%p, %s\n", hEventLog, lpBackupFileName);
return FALSE;
}
- Result = BackupEventLogW(hEventLog,
- BackupFileNameW.Buffer);
+ Success = BackupEventLogW(hEventLog,
+ BackupFileNameW.Buffer);
RtlFreeUnicodeString(&BackupFileNameW);
- return(Result);
+ return Success;
}
* hEventLog []
* lpBackupFileName []
*/
+NTSTATUS
+NTAPI
+ElfBackupEventLogFileW(IN HANDLE hEventLog,
+ IN PUNICODE_STRING BackupFileNameU)
+{
+ NTSTATUS Status;
+
+ if (!BackupFileNameU || (BackupFileNameU->Length == 0))
+ return STATUS_INVALID_PARAMETER;
+
+ RpcTryExcept
+ {
+ Status = ElfrBackupELFW(hEventLog,
+ (PRPC_UNICODE_STRING)BackupFileNameU);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
BOOL WINAPI
BackupEventLogW(IN HANDLE hEventLog,
IN LPCWSTR lpBackupFileName)
{
- UNICODE_STRING BackupFileNameW;
NTSTATUS Status;
+ UNICODE_STRING BackupFileName;
TRACE("%p, %s\n", hEventLog, debugstr_w(lpBackupFileName));
return FALSE;
}
- if (!RtlDosPathNameToNtPathName_U(lpBackupFileName, &BackupFileNameW,
+ if (!RtlDosPathNameToNtPathName_U(lpBackupFileName, &BackupFileName,
NULL, NULL))
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
- RpcTryExcept
- {
- Status = ElfrBackupELFW(hEventLog,
- (PRPC_UNICODE_STRING)&BackupFileNameW);
- }
- RpcExcept(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = I_RpcMapWin32Status(RpcExceptionCode());
- }
- RpcEndExcept;
+ Status = ElfBackupEventLogFileW(hEventLog, &BackupFileName);
- RtlFreeHeap(RtlGetProcessHeap(), 0, BackupFileNameW.Buffer);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, BackupFileName.Buffer);
if (!NT_SUCCESS(Status))
{
/******************************************************************************
* ClearEventLogA [ADVAPI32.@]
*/
+NTSTATUS
+NTAPI
+ElfClearEventLogFileA(IN HANDLE hEventLog,
+ IN PANSI_STRING BackupFileNameA)
+{
+ NTSTATUS Status;
+
+ RpcTryExcept
+ {
+ Status = ElfrClearELFA(hEventLog,
+ (PRPC_STRING)BackupFileNameA);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
BOOL WINAPI
ClearEventLogA(IN HANDLE hEventLog,
IN LPCSTR lpBackupFileName)
{
+ BOOL Success;
+ NTSTATUS Status;
ANSI_STRING BackupFileNameA;
UNICODE_STRING BackupFileNameW;
- NTSTATUS Status;
- BOOL Result;
TRACE("%p, %s\n", hEventLog, lpBackupFileName);
}
}
- Result = ClearEventLogW(hEventLog,
- BackupFileNameW.Buffer);
+ Success = ClearEventLogW(hEventLog,
+ BackupFileNameW.Buffer);
RtlFreeUnicodeString(&BackupFileNameW);
- return Result;
+ return Success;
}
/******************************************************************************
* ClearEventLogW [ADVAPI32.@]
*/
+NTSTATUS
+NTAPI
+ElfClearEventLogFileW(IN HANDLE hEventLog,
+ IN PUNICODE_STRING BackupFileNameU)
+{
+ NTSTATUS Status;
+
+ RpcTryExcept
+ {
+ Status = ElfrClearELFW(hEventLog,
+ (PRPC_UNICODE_STRING)BackupFileNameU);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
BOOL WINAPI
ClearEventLogW(IN HANDLE hEventLog,
IN LPCWSTR lpBackupFileName)
{
- UNICODE_STRING BackupFileNameW;
NTSTATUS Status;
+ UNICODE_STRING BackupFileName;
TRACE("%p, %s\n", hEventLog, debugstr_w(lpBackupFileName));
if (lpBackupFileName == NULL)
{
- RtlInitUnicodeString(&BackupFileNameW, NULL);
+ RtlInitUnicodeString(&BackupFileName, NULL);
}
else
{
- if (!RtlDosPathNameToNtPathName_U(lpBackupFileName, &BackupFileNameW,
+ if (!RtlDosPathNameToNtPathName_U(lpBackupFileName, &BackupFileName,
NULL, NULL))
{
SetLastError(ERROR_INVALID_PARAMETER);
}
}
- RpcTryExcept
- {
- Status = ElfrClearELFW(hEventLog,
- (PRPC_UNICODE_STRING)&BackupFileNameW);
- }
- RpcExcept(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = I_RpcMapWin32Status(RpcExceptionCode());
- }
- RpcEndExcept;
+ Status = ElfClearEventLogFileW(hEventLog, &BackupFileName);
if (lpBackupFileName != NULL)
- RtlFreeHeap(RtlGetProcessHeap(), 0, BackupFileNameW.Buffer);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, BackupFileName.Buffer);
if (!NT_SUCCESS(Status))
{
/******************************************************************************
* CloseEventLog [ADVAPI32.@]
*/
-BOOL WINAPI
-CloseEventLog(IN HANDLE hEventLog)
+NTSTATUS
+NTAPI
+ElfCloseEventLog(IN HANDLE hEventLog)
{
NTSTATUS Status;
- TRACE("%p\n", hEventLog);
-
RpcTryExcept
{
Status = ElfrCloseEL(&hEventLog);
}
RpcEndExcept;
+ return Status;
+}
+
+BOOL WINAPI
+CloseEventLog(IN HANDLE hEventLog)
+{
+ NTSTATUS Status;
+
+ TRACE("%p\n", hEventLog);
+
+ Status = ElfCloseEventLog(hEventLog);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
*
* RETURNS STD
*/
-BOOL WINAPI
-DeregisterEventSource(IN HANDLE hEventLog)
+NTSTATUS
+NTAPI
+ElfDeregisterEventSource(IN HANDLE hEventLog)
{
NTSTATUS Status;
- TRACE("%p\n", hEventLog);
-
RpcTryExcept
{
Status = ElfrDeregisterEventSource(&hEventLog);
}
RpcEndExcept;
+ return Status;
+}
+
+BOOL WINAPI
+DeregisterEventSource(IN HANDLE hEventLog)
+{
+ NTSTATUS Status;
+
+ TRACE("%p\n", hEventLog);
+
+ Status = ElfDeregisterEventSource(hEventLog);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
* hEventLog []
* NumberOfRecords []
*/
-BOOL WINAPI
-GetNumberOfEventLogRecords(IN HANDLE hEventLog,
- OUT PDWORD NumberOfRecords)
+NTSTATUS
+NTAPI
+ElfNumberOfRecords(IN HANDLE hEventLog,
+ OUT PULONG NumberOfRecords)
{
NTSTATUS Status;
- DWORD Records;
-
- TRACE("%p, %p\n", hEventLog, NumberOfRecords);
- if (NumberOfRecords == NULL)
- {
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
+ if (!NumberOfRecords)
+ return STATUS_INVALID_PARAMETER;
RpcTryExcept
{
- Status = ElfrNumberOfRecords(hEventLog,
- &Records);
+ Status = ElfrNumberOfRecords(hEventLog, NumberOfRecords);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
+ return Status;
+}
+
+BOOL WINAPI
+GetNumberOfEventLogRecords(IN HANDLE hEventLog,
+ OUT PDWORD NumberOfRecords)
+{
+ NTSTATUS Status;
+
+ TRACE("%p, %p\n", hEventLog, NumberOfRecords);
+
+ Status = ElfNumberOfRecords(hEventLog, NumberOfRecords);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
- *NumberOfRecords = Records;
-
return TRUE;
}
* hEventLog []
* OldestRecord []
*/
-BOOL WINAPI
-GetOldestEventLogRecord(IN HANDLE hEventLog,
- OUT PDWORD OldestRecord)
+NTSTATUS
+NTAPI
+ElfOldestRecord(IN HANDLE hEventLog,
+ OUT PULONG OldestRecordNumber)
{
NTSTATUS Status;
- DWORD Oldest;
-
- TRACE("%p, %p\n", hEventLog, OldestRecord);
- if (OldestRecord == NULL)
- {
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
+ if (!OldestRecordNumber)
+ return STATUS_INVALID_PARAMETER;
RpcTryExcept
{
- Status = ElfrOldestRecord(hEventLog,
- &Oldest);
+ Status = ElfrOldestRecord(hEventLog, OldestRecordNumber);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
+ return Status;
+}
+
+BOOL WINAPI
+GetOldestEventLogRecord(IN HANDLE hEventLog,
+ OUT PDWORD OldestRecord)
+{
+ NTSTATUS Status;
+
+ TRACE("%p, %p\n", hEventLog, OldestRecord);
+
+ Status = ElfOldestRecord(hEventLog, OldestRecord);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
- *OldestRecord = Oldest;
-
return TRUE;
}
* hEventLog []
* hEvent []
*/
+NTSTATUS
+NTAPI
+ElfChangeNotify(IN HANDLE hEventLog,
+ IN HANDLE hEvent)
+{
+ NTSTATUS Status;
+ CLIENT_ID ClientId = NtCurrentTeb()->ClientId;
+ RPC_CLIENT_ID RpcClientId;
+
+ RpcClientId.UniqueProcess = HandleToUlong(ClientId.UniqueProcess);
+ RpcClientId.UniqueThread = HandleToUlong(ClientId.UniqueThread);
+
+ RpcTryExcept
+ {
+ Status = ElfrChangeNotify(hEventLog, RpcClientId, HandleToUlong(hEvent));
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
BOOL WINAPI
NotifyChangeEventLog(IN HANDLE hEventLog,
IN HANDLE hEvent)
{
- /* Use ElfrChangeNotify */
- UNIMPLEMENTED;
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ NTSTATUS Status;
+
+ TRACE("%p, %p\n", hEventLog, hEvent);
+
+ Status = ElfChangeNotify(hEventLog, hEvent);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastError(RtlNtStatusToDosError(Status));
+ return FALSE;
+ }
+
+ return TRUE;
}
/******************************************************************************
* OpenBackupEventLogA [ADVAPI32.@]
*/
+NTSTATUS
+NTAPI
+ElfOpenBackupEventLogA(IN PANSI_STRING UNCServerNameA,
+ IN PANSI_STRING BackupFileNameA,
+ OUT PHANDLE phEventLog)
+{
+ NTSTATUS Status;
+ PSTR pUNCServerName = NULL;
+
+ if (!phEventLog || !BackupFileNameA || (BackupFileNameA->Length == 0))
+ return STATUS_INVALID_PARAMETER;
+
+ if (UNCServerNameA && (UNCServerNameA->Length != 0))
+ pUNCServerName = UNCServerNameA->Buffer;
+
+ *phEventLog = NULL;
+
+ RpcTryExcept
+ {
+ Status = ElfrOpenBELA(pUNCServerName,
+ (PRPC_STRING)BackupFileNameA,
+ 1, 1,
+ (IELF_HANDLE*)phEventLog);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
HANDLE WINAPI
OpenBackupEventLogA(IN LPCSTR lpUNCServerName,
IN LPCSTR lpFileName)
{
+ NTSTATUS Status;
+ HANDLE LogHandle;
ANSI_STRING UNCServerNameA;
UNICODE_STRING UNCServerNameW;
ANSI_STRING FileNameA;
UNICODE_STRING FileNameW;
- HANDLE LogHandle;
- NTSTATUS Status;
TRACE("%s, %s\n", lpUNCServerName, lpFileName);
* lpUNCServerName []
* lpFileName []
*/
+NTSTATUS
+NTAPI
+ElfOpenBackupEventLogW(IN PUNICODE_STRING UNCServerNameU,
+ IN PUNICODE_STRING BackupFileNameU,
+ OUT PHANDLE phEventLog)
+{
+ NTSTATUS Status;
+ PWSTR pUNCServerName = NULL;
+
+ if (!phEventLog || !BackupFileNameU || (BackupFileNameU->Length == 0))
+ return STATUS_INVALID_PARAMETER;
+
+ if (UNCServerNameU && (UNCServerNameU->Length != 0))
+ pUNCServerName = UNCServerNameU->Buffer;
+
+ *phEventLog = NULL;
+
+ RpcTryExcept
+ {
+ Status = ElfrOpenBELW(pUNCServerName,
+ (PRPC_UNICODE_STRING)BackupFileNameU,
+ 1,
+ 1,
+ (IELF_HANDLE*)phEventLog);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
HANDLE WINAPI
OpenBackupEventLogW(IN LPCWSTR lpUNCServerName,
IN LPCWSTR lpFileName)
{
- UNICODE_STRING FileNameW;
- IELF_HANDLE LogHandle;
NTSTATUS Status;
+ HANDLE hEventLog;
+ UNICODE_STRING UNCServerName, FileName;
TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpFileName));
return NULL;
}
- if (!RtlDosPathNameToNtPathName_U(lpFileName, &FileNameW,
+ if (!RtlDosPathNameToNtPathName_U(lpFileName, &FileName,
NULL, NULL))
{
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
- RpcTryExcept
- {
- Status = ElfrOpenBELW((LPWSTR)lpUNCServerName,
- (PRPC_UNICODE_STRING)&FileNameW,
- 1,
- 1,
- &LogHandle);
- }
- RpcExcept(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = I_RpcMapWin32Status(RpcExceptionCode());
- }
- RpcEndExcept;
+ RtlInitUnicodeString(&UNCServerName, lpUNCServerName);
- if (FileNameW.Buffer != NULL)
- RtlFreeHeap(RtlGetProcessHeap(), 0, FileNameW.Buffer);
+ Status = ElfOpenBackupEventLogW(&UNCServerName, &FileName, &hEventLog);
+
+ if (FileName.Buffer != NULL)
+ RtlFreeHeap(RtlGetProcessHeap(), 0, FileName.Buffer);
if (!NT_SUCCESS(Status))
{
return NULL;
}
- return (HANDLE)LogHandle;
+ return hEventLog;
}
* Success: Handle to an event log.
* Failure: NULL
*/
-HANDLE WINAPI
-OpenEventLogA(IN LPCSTR lpUNCServerName,
- IN LPCSTR lpSourceName)
+NTSTATUS
+NTAPI
+ElfOpenEventLogA(IN PANSI_STRING UNCServerNameA,
+ IN PANSI_STRING SourceNameA,
+ OUT PHANDLE phEventLog)
{
- LPSTR UNCServerName;
- ANSI_STRING SourceName;
- IELF_HANDLE LogHandle = NULL;
NTSTATUS Status;
+ PSTR pUNCServerName = NULL;
- TRACE("%s, %s\n", lpUNCServerName, lpSourceName);
+ if (!phEventLog || !SourceNameA || (SourceNameA->Length == 0))
+ return STATUS_INVALID_PARAMETER;
- if (lpSourceName == NULL)
- {
- SetLastError(ERROR_INVALID_PARAMETER);
- return NULL;
- }
-
- if (lpUNCServerName == NULL || *lpUNCServerName == 0)
- UNCServerName = NULL;
- else
- UNCServerName = (LPSTR)lpUNCServerName;
+ if (UNCServerNameA && (UNCServerNameA->Length != 0))
+ pUNCServerName = UNCServerNameA->Buffer;
- RtlInitAnsiString(&SourceName, lpSourceName);
+ *phEventLog = NULL;
RpcTryExcept
{
- Status = ElfrOpenELA(UNCServerName,
- (PRPC_STRING)&SourceName,
+ Status = ElfrOpenELA(pUNCServerName,
+ (PRPC_STRING)SourceNameA,
&EmptyStringA,
1,
1,
- &LogHandle);
+ (IELF_HANDLE*)phEventLog);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
+ return Status;
+}
+
+HANDLE WINAPI
+OpenEventLogA(IN LPCSTR lpUNCServerName,
+ IN LPCSTR lpSourceName)
+{
+ NTSTATUS Status;
+ HANDLE hEventLog;
+ ANSI_STRING UNCServerName, SourceName;
+
+ TRACE("%s, %s\n", lpUNCServerName, lpSourceName);
+
+ RtlInitAnsiString(&UNCServerName, lpUNCServerName);
+ RtlInitAnsiString(&SourceName, lpSourceName);
+
+ Status = ElfOpenEventLogA(&UNCServerName, &SourceName, &hEventLog);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return NULL;
}
- return (HANDLE)LogHandle;
+ return hEventLog;
}
* lpUNCServerName []
* lpSourceName []
*/
-HANDLE WINAPI
-OpenEventLogW(IN LPCWSTR lpUNCServerName,
- IN LPCWSTR lpSourceName)
+NTSTATUS
+NTAPI
+ElfOpenEventLogW(IN PUNICODE_STRING UNCServerNameU,
+ IN PUNICODE_STRING SourceNameU,
+ OUT PHANDLE phEventLog)
{
- LPWSTR UNCServerName;
- UNICODE_STRING SourceName;
- IELF_HANDLE LogHandle;
NTSTATUS Status;
+ PWSTR pUNCServerName = NULL;
- TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
-
- if (lpSourceName == NULL)
- {
- SetLastError(ERROR_INVALID_PARAMETER);
- return NULL;
- }
+ if (!phEventLog || !SourceNameU || (SourceNameU->Length == 0))
+ return STATUS_INVALID_PARAMETER;
- if (lpUNCServerName == NULL || *lpUNCServerName == 0)
- UNCServerName = NULL;
- else
- UNCServerName = (LPWSTR)lpUNCServerName;
+ if (UNCServerNameU && (UNCServerNameU->Length != 0))
+ pUNCServerName = UNCServerNameU->Buffer;
- RtlInitUnicodeString(&SourceName, lpSourceName);
+ *phEventLog = NULL;
RpcTryExcept
{
- Status = ElfrOpenELW(UNCServerName,
- (PRPC_UNICODE_STRING)&SourceName,
+ Status = ElfrOpenELW(pUNCServerName,
+ (PRPC_UNICODE_STRING)SourceNameU,
&EmptyStringU,
1,
1,
- &LogHandle);
+ (IELF_HANDLE*)phEventLog);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
+ return Status;
+}
+
+HANDLE WINAPI
+OpenEventLogW(IN LPCWSTR lpUNCServerName,
+ IN LPCWSTR lpSourceName)
+{
+ NTSTATUS Status;
+ HANDLE hEventLog;
+ UNICODE_STRING UNCServerName, SourceName;
+
+ TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
+
+ RtlInitUnicodeString(&UNCServerName, lpUNCServerName);
+ RtlInitUnicodeString(&SourceName, lpSourceName);
+
+ Status = ElfOpenEventLogW(&UNCServerName, &SourceName, &hEventLog);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return NULL;
}
- return (HANDLE)LogHandle;
+ return hEventLog;
}
/******************************************************************************
* ReadEventLogA [ADVAPI32.@]
*/
-BOOL WINAPI
-ReadEventLogA(IN HANDLE hEventLog,
- IN DWORD dwReadFlags,
- IN DWORD dwRecordOffset,
- OUT LPVOID lpBuffer,
- IN DWORD nNumberOfBytesToRead,
- OUT DWORD *pnBytesRead,
- OUT DWORD *pnMinNumberOfBytesNeeded)
+NTSTATUS
+NTAPI
+ElfReadEventLogA(IN HANDLE hEventLog,
+ IN ULONG ReadFlags,
+ IN ULONG RecordOffset,
+ OUT LPVOID Buffer,
+ IN ULONG NumberOfBytesToRead,
+ OUT PULONG NumberOfBytesRead,
+ OUT PULONG MinNumberOfBytesNeeded)
{
NTSTATUS Status;
- DWORD bytesRead, minNumberOfBytesNeeded;
- DWORD dwFlags;
+ ULONG Flags;
- TRACE("%p, %lu, %lu, %p, %lu, %p, %p\n",
- hEventLog, dwReadFlags, dwRecordOffset, lpBuffer,
- nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
-
- if (lpBuffer == NULL ||
- pnBytesRead == NULL ||
- pnMinNumberOfBytesNeeded == NULL)
+ if (!Buffer || !NumberOfBytesRead || !MinNumberOfBytesNeeded)
{
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
+ return STATUS_INVALID_PARAMETER;
}
- dwFlags = dwReadFlags & (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ);
- if (dwFlags == (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ))
+ Flags = ReadFlags & (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ);
+ if (Flags == (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ))
{
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
+ return STATUS_INVALID_PARAMETER;
}
- dwFlags = dwReadFlags & (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ);
- if (dwFlags == (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ))
+ Flags = ReadFlags & (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ);
+ if (Flags == (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ))
{
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
+ return STATUS_INVALID_PARAMETER;
}
RpcTryExcept
{
Status = ElfrReadELA(hEventLog,
- dwReadFlags,
- dwRecordOffset,
- nNumberOfBytesToRead,
- lpBuffer,
- &bytesRead,
- &minNumberOfBytesNeeded);
+ ReadFlags,
+ RecordOffset,
+ NumberOfBytesToRead,
+ Buffer,
+ NumberOfBytesRead,
+ MinNumberOfBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
- *pnBytesRead = (DWORD)bytesRead;
- *pnMinNumberOfBytesNeeded = (DWORD)minNumberOfBytesNeeded;
+ return Status;
+}
+
+BOOL WINAPI
+ReadEventLogA(IN HANDLE hEventLog,
+ IN DWORD dwReadFlags,
+ IN DWORD dwRecordOffset,
+ OUT LPVOID lpBuffer,
+ IN DWORD nNumberOfBytesToRead,
+ OUT DWORD *pnBytesRead,
+ OUT DWORD *pnMinNumberOfBytesNeeded)
+{
+ NTSTATUS Status;
+ TRACE("%p, %lu, %lu, %p, %lu, %p, %p\n",
+ hEventLog, dwReadFlags, dwRecordOffset, lpBuffer,
+ nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
+
+ Status = ElfReadEventLogA(hEventLog,
+ dwReadFlags,
+ dwRecordOffset,
+ lpBuffer,
+ nNumberOfBytesToRead,
+ pnBytesRead,
+ pnMinNumberOfBytesNeeded);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
* pnBytesRead []
* pnMinNumberOfBytesNeeded []
*/
-BOOL WINAPI
-ReadEventLogW(IN HANDLE hEventLog,
- IN DWORD dwReadFlags,
- IN DWORD dwRecordOffset,
- OUT LPVOID lpBuffer,
- IN DWORD nNumberOfBytesToRead,
- OUT DWORD *pnBytesRead,
- OUT DWORD *pnMinNumberOfBytesNeeded)
+NTSTATUS
+NTAPI
+ElfReadEventLogW(IN HANDLE hEventLog,
+ IN ULONG ReadFlags,
+ IN ULONG RecordOffset,
+ OUT LPVOID Buffer,
+ IN ULONG NumberOfBytesToRead,
+ OUT PULONG NumberOfBytesRead,
+ OUT PULONG MinNumberOfBytesNeeded)
{
NTSTATUS Status;
- DWORD bytesRead, minNumberOfBytesNeeded;
- DWORD dwFlags;
-
- TRACE("%p, %lu, %lu, %p, %lu, %p, %p\n",
- hEventLog, dwReadFlags, dwRecordOffset, lpBuffer,
- nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
+ ULONG Flags;
- if (lpBuffer == NULL ||
- pnBytesRead == NULL ||
- pnMinNumberOfBytesNeeded == NULL)
+ if (!Buffer || !NumberOfBytesRead || !MinNumberOfBytesNeeded)
{
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
+ return STATUS_INVALID_PARAMETER;
}
- dwFlags = dwReadFlags & (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ);
- if (dwFlags == (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ))
+ Flags = ReadFlags & (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ);
+ if (Flags == (EVENTLOG_SEQUENTIAL_READ | EVENTLOG_SEEK_READ))
{
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
+ return STATUS_INVALID_PARAMETER;
}
- dwFlags = dwReadFlags & (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ);
- if (dwFlags == (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ))
+ Flags = ReadFlags & (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ);
+ if (Flags == (EVENTLOG_FORWARDS_READ | EVENTLOG_BACKWARDS_READ))
{
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
+ return STATUS_INVALID_PARAMETER;
}
RpcTryExcept
{
Status = ElfrReadELW(hEventLog,
- dwReadFlags,
- dwRecordOffset,
- nNumberOfBytesToRead,
- lpBuffer,
- &bytesRead,
- &minNumberOfBytesNeeded);
+ ReadFlags,
+ RecordOffset,
+ NumberOfBytesToRead,
+ Buffer,
+ NumberOfBytesRead,
+ MinNumberOfBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
- *pnBytesRead = (DWORD)bytesRead;
- *pnMinNumberOfBytesNeeded = (DWORD)minNumberOfBytesNeeded;
+ return Status;
+}
+
+BOOL WINAPI
+ReadEventLogW(IN HANDLE hEventLog,
+ IN DWORD dwReadFlags,
+ IN DWORD dwRecordOffset,
+ OUT LPVOID lpBuffer,
+ IN DWORD nNumberOfBytesToRead,
+ OUT DWORD *pnBytesRead,
+ OUT DWORD *pnMinNumberOfBytesNeeded)
+{
+ NTSTATUS Status;
+ TRACE("%p, %lu, %lu, %p, %lu, %p, %p\n",
+ hEventLog, dwReadFlags, dwRecordOffset, lpBuffer,
+ nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
+
+ Status = ElfReadEventLogW(hEventLog,
+ dwReadFlags,
+ dwRecordOffset,
+ lpBuffer,
+ nNumberOfBytesToRead,
+ pnBytesRead,
+ pnMinNumberOfBytesNeeded);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
/******************************************************************************
* RegisterEventSourceA [ADVAPI32.@]
*/
-HANDLE WINAPI
-RegisterEventSourceA(IN LPCSTR lpUNCServerName,
- IN LPCSTR lpSourceName)
+NTSTATUS
+NTAPI
+ElfRegisterEventSourceA(IN PANSI_STRING UNCServerNameA,
+ IN PANSI_STRING SourceNameA,
+ OUT PHANDLE phEventLog)
{
- ANSI_STRING SourceName;
- IELF_HANDLE LogHandle;
NTSTATUS Status;
+ PSTR pUNCServerName = NULL;
- TRACE("%s, %s\n", lpUNCServerName, lpSourceName);
+ if (!phEventLog || !SourceNameA || (SourceNameA->Length == 0))
+ return STATUS_INVALID_PARAMETER;
- RtlInitAnsiString(&SourceName, lpSourceName);
+ if (UNCServerNameA && (UNCServerNameA->Length != 0))
+ pUNCServerName = UNCServerNameA->Buffer;
+
+ *phEventLog = NULL;
RpcTryExcept
{
- Status = ElfrRegisterEventSourceA((LPSTR)lpUNCServerName,
- (PRPC_STRING)&SourceName,
+ Status = ElfrRegisterEventSourceA(pUNCServerName,
+ (PRPC_STRING)SourceNameA,
&EmptyStringA,
1,
1,
- &LogHandle);
+ (IELF_HANDLE*)phEventLog);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
+ return Status;
+}
+
+HANDLE WINAPI
+RegisterEventSourceA(IN LPCSTR lpUNCServerName,
+ IN LPCSTR lpSourceName)
+{
+ NTSTATUS Status;
+ HANDLE hEventLog;
+ ANSI_STRING UNCServerName, SourceName;
+
+ TRACE("%s, %s\n", lpUNCServerName, lpSourceName);
+
+ RtlInitAnsiString(&UNCServerName, lpUNCServerName);
+ RtlInitAnsiString(&SourceName, lpSourceName);
+
+ Status = ElfRegisterEventSourceA(&UNCServerName, &SourceName, &hEventLog);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return NULL;
}
- return (HANDLE)LogHandle;
+ return hEventLog;
}
* Success: Handle
* Failure: NULL
*/
-HANDLE WINAPI
-RegisterEventSourceW(IN LPCWSTR lpUNCServerName,
- IN LPCWSTR lpSourceName)
+NTSTATUS
+NTAPI
+ElfRegisterEventSourceW(IN PUNICODE_STRING UNCServerNameU,
+ IN PUNICODE_STRING SourceNameU,
+ OUT PHANDLE phEventLog)
{
- UNICODE_STRING SourceName;
- IELF_HANDLE LogHandle;
NTSTATUS Status;
+ PWSTR pUNCServerName = NULL;
- TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
+ if (!phEventLog || !SourceNameU || (SourceNameU->Length == 0))
+ return STATUS_INVALID_PARAMETER;
- RtlInitUnicodeString(&SourceName, lpSourceName);
+ if (UNCServerNameU && (UNCServerNameU->Length != 0))
+ pUNCServerName = UNCServerNameU->Buffer;
+
+ *phEventLog = NULL;
RpcTryExcept
{
- Status = ElfrRegisterEventSourceW((LPWSTR)lpUNCServerName,
- (PRPC_UNICODE_STRING)&SourceName,
+ Status = ElfrRegisterEventSourceW(pUNCServerName,
+ (PRPC_UNICODE_STRING)SourceNameU,
&EmptyStringU,
1,
1,
- &LogHandle);
+ (IELF_HANDLE*)phEventLog);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
}
RpcEndExcept;
+ return Status;
+}
+
+HANDLE WINAPI
+RegisterEventSourceW(IN LPCWSTR lpUNCServerName,
+ IN LPCWSTR lpSourceName)
+{
+ NTSTATUS Status;
+ HANDLE hEventLog;
+ UNICODE_STRING UNCServerName, SourceName;
+
+ TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
+
+ RtlInitUnicodeString(&UNCServerName, lpUNCServerName);
+ RtlInitUnicodeString(&SourceName, lpSourceName);
+
+ Status = ElfRegisterEventSourceW(&UNCServerName, &SourceName, &hEventLog);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return NULL;
}
- return (HANDLE)LogHandle;
+ return hEventLog;
}
/******************************************************************************
* ReportEventA [ADVAPI32.@]
*/
+NTSTATUS
+NTAPI
+ElfReportEventA(IN HANDLE hEventLog,
+ IN USHORT EventType,
+ IN USHORT EventCategory,
+ IN ULONG EventID,
+ IN PSID UserSID,
+ IN USHORT NumStrings,
+ IN ULONG DataSize,
+ IN PANSI_STRING* Strings,
+ IN PVOID Data,
+ IN USHORT Flags,
+ IN OUT PULONG RecordNumber,
+ IN OUT PULONG TimeWritten)
+{
+ NTSTATUS Status;
+ LARGE_INTEGER SystemTime;
+ ULONG Time;
+ ULONG dwSize;
+ ANSI_STRING ComputerName;
+ CHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
+
+ dwSize = ARRAYSIZE(szComputerName);
+ GetComputerNameA(szComputerName, &dwSize);
+ RtlInitAnsiString(&ComputerName, szComputerName);
+
+ NtQuerySystemTime(&SystemTime);
+ RtlTimeToSecondsSince1970(&SystemTime, &Time);
+
+ RpcTryExcept
+ {
+ Status = ElfrReportEventA(hEventLog,
+ Time,
+ EventType,
+ EventCategory,
+ EventID,
+ NumStrings,
+ DataSize,
+ (PRPC_STRING)&ComputerName,
+ (PRPC_SID)UserSID,
+ (PRPC_STRING*)Strings,
+ Data,
+ Flags,
+ RecordNumber,
+ TimeWritten);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
BOOL WINAPI
ReportEventA(IN HANDLE hEventLog,
IN WORD wType,
{
NTSTATUS Status;
PANSI_STRING *Strings;
- ANSI_STRING ComputerName;
WORD i;
- CHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
- DWORD dwSize;
- LARGE_INTEGER SystemTime;
- ULONG Seconds;
TRACE("%p, %u, %u, %lu, %p, %u, %lu, %p, %p\n",
hEventLog, wType, wCategory, dwEventID, lpUserSid,
}
}
- dwSize = MAX_COMPUTERNAME_LENGTH + 1;
- GetComputerNameA(szComputerName, &dwSize);
- RtlInitAnsiString(&ComputerName, szComputerName);
-
- NtQuerySystemTime(&SystemTime);
- RtlTimeToSecondsSince1970(&SystemTime, &Seconds);
-
- RpcTryExcept
- {
- Status = ElfrReportEventA(hEventLog,
- Seconds,
- wType,
- wCategory,
- dwEventID,
- wNumStrings,
- dwDataSize,
- (PRPC_STRING)&ComputerName,
- lpUserSid,
- (PRPC_STRING*)Strings,
- lpRawData,
- 0,
- NULL,
- NULL);
- }
- RpcExcept(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = I_RpcMapWin32Status(RpcExceptionCode());
- }
- RpcEndExcept;
+ Status = ElfReportEventA(hEventLog,
+ wType,
+ wCategory,
+ dwEventID,
+ lpUserSid,
+ wNumStrings,
+ dwDataSize,
+ Strings,
+ lpRawData,
+ 0,
+ NULL,
+ NULL);
for (i = 0; i < wNumStrings; i++)
{
* lpStrings []
* lpRawData []
*/
+NTSTATUS
+NTAPI
+ElfReportEventW(IN HANDLE hEventLog,
+ IN USHORT EventType,
+ IN USHORT EventCategory,
+ IN ULONG EventID,
+ IN PSID UserSID,
+ IN USHORT NumStrings,
+ IN ULONG DataSize,
+ IN PUNICODE_STRING* Strings,
+ IN PVOID Data,
+ IN USHORT Flags,
+ IN OUT PULONG RecordNumber,
+ IN OUT PULONG TimeWritten)
+{
+ NTSTATUS Status;
+ LARGE_INTEGER SystemTime;
+ ULONG Time;
+ ULONG dwSize;
+ UNICODE_STRING ComputerName;
+ WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
+
+ dwSize = ARRAYSIZE(szComputerName);
+ GetComputerNameW(szComputerName, &dwSize);
+ RtlInitUnicodeString(&ComputerName, szComputerName);
+
+ NtQuerySystemTime(&SystemTime);
+ RtlTimeToSecondsSince1970(&SystemTime, &Time);
+
+ RpcTryExcept
+ {
+ Status = ElfrReportEventW(hEventLog,
+ Time,
+ EventType,
+ EventCategory,
+ EventID,
+ NumStrings,
+ DataSize,
+ (PRPC_UNICODE_STRING)&ComputerName,
+ (PRPC_SID)UserSID,
+ (PRPC_UNICODE_STRING*)Strings,
+ Data,
+ Flags,
+ RecordNumber,
+ TimeWritten);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
BOOL WINAPI
ReportEventW(IN HANDLE hEventLog,
IN WORD wType,
{
NTSTATUS Status;
PUNICODE_STRING *Strings;
- UNICODE_STRING ComputerName;
WORD i;
- WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
- DWORD dwSize;
- LARGE_INTEGER SystemTime;
- ULONG Seconds;
TRACE("%p, %u, %u, %lu, %p, %u, %lu, %p, %p\n",
hEventLog, wType, wCategory, dwEventID, lpUserSid,
wNumStrings, dwDataSize, lpStrings, lpRawData);
Strings = HeapAlloc(GetProcessHeap(),
- 0,
+ HEAP_ZERO_MEMORY,
wNumStrings * sizeof(PUNICODE_STRING));
if (!Strings)
{
{
Strings[i] = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
- sizeof(ANSI_STRING));
+ sizeof(UNICODE_STRING));
if (Strings[i])
{
RtlInitUnicodeString(Strings[i], lpStrings[i]);
}
}
- dwSize = MAX_COMPUTERNAME_LENGTH + 1;
- GetComputerNameW(szComputerName, &dwSize);
- RtlInitUnicodeString(&ComputerName, szComputerName);
-
- NtQuerySystemTime(&SystemTime);
- RtlTimeToSecondsSince1970(&SystemTime, &Seconds);
-
- RpcTryExcept
- {
- Status = ElfrReportEventW(hEventLog,
- Seconds,
- wType,
- wCategory,
- dwEventID,
- wNumStrings,
- dwDataSize,
- (PRPC_UNICODE_STRING)&ComputerName,
- lpUserSid,
- (PRPC_UNICODE_STRING*)Strings,
- lpRawData,
- 0,
- NULL,
- NULL);
- }
- RpcExcept(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = I_RpcMapWin32Status(RpcExceptionCode());
- }
- RpcEndExcept;
+ Status = ElfReportEventW(hEventLog,
+ wType,
+ wCategory,
+ dwEventID,
+ lpUserSid,
+ wNumStrings,
+ dwDataSize,
+ Strings,
+ lpRawData,
+ 0,
+ NULL,
+ NULL);
for (i = 0; i < wNumStrings; i++)
{
return TRUE;
}
+NTSTATUS
+NTAPI
+ElfReportEventAndSourceW(IN HANDLE hEventLog,
+ IN ULONG Time,
+ IN PUNICODE_STRING ComputerName,
+ IN USHORT EventType,
+ IN USHORT EventCategory,
+ IN ULONG EventID,
+ IN PSID UserSID,
+ IN PUNICODE_STRING SourceName,
+ IN USHORT NumStrings,
+ IN ULONG DataSize,
+ IN PUNICODE_STRING* Strings,
+ IN PVOID Data,
+ IN USHORT Flags,
+ IN OUT PULONG RecordNumber,
+ IN OUT PULONG TimeWritten)
+{
+ NTSTATUS Status;
+
+ RpcTryExcept
+ {
+ Status = ElfrReportEventAndSourceW(hEventLog,
+ Time,
+ EventType,
+ EventCategory,
+ EventID,
+ (PRPC_UNICODE_STRING)SourceName,
+ NumStrings,
+ DataSize,
+ (PRPC_UNICODE_STRING)ComputerName,
+ (PRPC_SID)UserSID,
+ (PRPC_UNICODE_STRING*)Strings,
+ (PBYTE)Data,
+ Flags,
+ RecordNumber,
+ TimeWritten);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+ElfFlushEventLog(IN HANDLE hEventLog)
+{
+ NTSTATUS Status;
+
+ RpcTryExcept
+ {
+ Status = ElfrFlushEL(hEventLog);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
projects / reactos.git / blobdiff