- Implement GetEventLogInformation.

- OpenBackupEventLogA, OpenEventLogA, RegisterEventSourceA and ReportEventA: Call the ANSI RPC-Server Function directly instead of converting arguments to Unicode and calling the matching Unicode Function.
- OpenEventLogW: Fix argument checks.

svn path=/trunk/; revision=45401

reactos/dll/win32/advapi32/service/eventlog.c

@@ -26,20 +26,9 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
 
-static RPC_UNICODE_STRING EmptyString = { 0, 0, L"" };
+static RPC_UNICODE_STRING EmptyStringU = { 0, 0, L"" };
+static RPC_STRING EmptyStringA = { 0, 0, "" };
 
-static inline LPWSTR SERV_dup( LPCSTR str )
-{
-    UINT len;
-    LPWSTR wstr;
-
-    if( !str )
-        return NULL;
-    len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
-    wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
-    MultiByteToWideChar( CP_ACP, 0, str, -1, wstr, len );
-    return wstr;
-}
 
 handle_t __RPC_USER
 EVENTLOG_HANDLE_A_bind(EVENTLOG_HANDLE_A UNCServerName)
@@ -166,7 +155,7 @@ BackupEventLogA(IN HANDLE hEventLog,
     BackupFileName.Buffer = (LPSTR)lpBackupFileName;
     BackupFileName.Length = BackupFileName.MaximumLength =
         lpBackupFileName ? strlen(lpBackupFileName) : 0;
-	BackupFileName.MaximumLength += sizeof(CHAR);
+    BackupFileName.MaximumLength += sizeof(CHAR);
 
     RpcTryExcept
     {
@@ -389,9 +378,29 @@ GetEventLogInformation(IN HANDLE hEventLog,
                        IN DWORD cbBufSize,
                        OUT LPDWORD pcbBytesNeeded)
 {
-    UNIMPLEMENTED;
+    NTSTATUS Status;
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+
-    return FALSE;
+    RpcTryExcept
+    {
+        Status = ElfrGetLogInformation(hEventLog,
+                                       dwInfoLevel,
+                                       (LPBYTE)lpBuffer,
+                                       cbBufSize,
+                                       pcbBytesNeeded);
+    }
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+    {
+        Status = I_RpcMapWin32Status(RpcExceptionCode());
+    }
+    RpcEndExcept;
+
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastError(RtlNtStatusToDosError(Status));
+        return FALSE;
+    }
+
+    return TRUE;
 }
 
 
@@ -416,7 +425,7 @@ GetNumberOfEventLogRecords(IN HANDLE hEventLog,
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
-    
+
     RpcTryExcept
     {
         Status = ElfrNumberOfRecords(hEventLog,
@@ -461,7 +470,7 @@ GetOldestEventLogRecord(IN HANDLE hEventLog,
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
-    
+
     RpcTryExcept
     {
         Status = ElfrOldestRecord(hEventLog,
@@ -510,32 +519,35 @@ HANDLE WINAPI
 OpenBackupEventLogA(IN LPCSTR lpUNCServerName,
                     IN LPCSTR lpFileName)
 {
-    UNICODE_STRING UNCServerName;
+    ANSI_STRING FileName;
-    UNICODE_STRING FileName;
+    IELF_HANDLE LogHandle;
-    HANDLE Handle;
+    NTSTATUS Status;
 
     TRACE("%s, %s\n", lpUNCServerName, lpFileName);
 
-    if (!RtlCreateUnicodeStringFromAsciiz(&UNCServerName, lpUNCServerName))
+    RtlInitAnsiString(&FileName, lpFileName);
+
+    RpcTryExcept
     {
-        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        Status = ElfrOpenBELA((LPSTR)lpUNCServerName,
+                              (PRPC_STRING)&FileName,
+                              1,
+                              1,
+                              &LogHandle);
+    }
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+    {
+        Status = I_RpcMapWin32Status(RpcExceptionCode());
+    }
+    RpcEndExcept;
+
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastError(RtlNtStatusToDosError(Status));
         return NULL;
     }
 
-    if (!RtlCreateUnicodeStringFromAsciiz(&FileName, lpFileName))
+    return (HANDLE)LogHandle;
-    {
-        RtlFreeUnicodeString(&UNCServerName);
-        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-
-    Handle = OpenBackupEventLogW(UNCServerName.Buffer,
-                                 FileName.Buffer);
-
-    RtlFreeUnicodeString(&UNCServerName);
-    RtlFreeUnicodeString(&FileName);
-
-    return Handle;
 }
 
 
@@ -600,19 +612,51 @@ OpenBackupEventLogW(IN LPCWSTR lpUNCServerName,
  *  Failure: NULL
  */
 HANDLE WINAPI
-OpenEventLogA(IN LPCSTR uncname,
+OpenEventLogA(IN LPCSTR lpUNCServerName,
-              IN LPCSTR source)
+              IN LPCSTR lpSourceName)
 {
-    LPWSTR uncnameW, sourceW;
+    LPSTR UNCServerName;
-    HANDLE handle;
+    ANSI_STRING SourceName;
+    IELF_HANDLE LogHandle = NULL;
+    NTSTATUS Status;
 
-    uncnameW = SERV_dup(uncname);
+    TRACE("%s, %s\n", lpUNCServerName, lpSourceName);
-    sourceW = SERV_dup(source);
-    handle = OpenEventLogW(uncnameW, sourceW);
-    HeapFree(GetProcessHeap(), 0, uncnameW);
-    HeapFree(GetProcessHeap(), 0, sourceW);
 
-    return handle;
+    if (lpSourceName == NULL)
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return NULL;
+    }
+
+    if (lpUNCServerName == NULL || *lpUNCServerName == 0)
+        UNCServerName = NULL;
+    else
+        UNCServerName = (LPSTR)lpUNCServerName;
+
+    RtlInitAnsiString(&SourceName, lpSourceName);
+
+    RpcTryExcept
+    {
+        Status = ElfrOpenELA(UNCServerName,
+                             (PRPC_STRING)&SourceName,
+                             &EmptyStringA,
+                             1,
+                             1,
+                             &LogHandle);
+    }
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+    {
+        Status = I_RpcMapWin32Status(RpcExceptionCode());
+    }
+    RpcEndExcept;
+
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastError(RtlNtStatusToDosError(Status));
+        return NULL;
+    }
+
+    return (HANDLE)LogHandle;
 }
 
 
@@ -627,22 +671,31 @@ HANDLE WINAPI
 OpenEventLogW(IN LPCWSTR lpUNCServerName,
               IN LPCWSTR lpSourceName)
 {
-    RPC_UNICODE_STRING SourceName;
+    LPWSTR UNCServerName;
+    UNICODE_STRING SourceName;
     IELF_HANDLE LogHandle;
     NTSTATUS Status;
 
     TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
 
-    SourceName.Buffer = (LPWSTR)lpSourceName;
+    if (lpSourceName == NULL)
-    SourceName.Length = SourceName.MaximumLength =
+    {
-        lpSourceName ? wcslen(lpSourceName) * sizeof(WCHAR) : 0;
+        SetLastError(ERROR_INVALID_PARAMETER);
-    SourceName.MaximumLength += sizeof(WCHAR);
+        return NULL;
+    }
+
+    if (lpUNCServerName == NULL || *lpUNCServerName == 0)
+        UNCServerName = NULL;
+    else
+        UNCServerName = (LPWSTR)lpUNCServerName;
+
+    RtlInitUnicodeString(&SourceName, lpSourceName);
 
     RpcTryExcept
     {
-        Status = ElfrOpenELW((LPWSTR)lpUNCServerName,
+        Status = ElfrOpenELW(UNCServerName,
-                             &SourceName,
+                             (PRPC_UNICODE_STRING)&SourceName,
-                             &EmptyString,
+                             &EmptyStringU,
                              1,
                              1,
                              &LogHandle);
@@ -801,32 +854,36 @@ HANDLE WINAPI
 RegisterEventSourceA(IN LPCSTR lpUNCServerName,
                      IN LPCSTR lpSourceName)
 {
-    UNICODE_STRING UNCServerName;
+    ANSI_STRING SourceName;
-    UNICODE_STRING SourceName;
+    IELF_HANDLE LogHandle;
-    HANDLE Handle;
+    NTSTATUS Status;
 
     TRACE("%s, %s\n", lpUNCServerName, lpSourceName);
 
-    if (!RtlCreateUnicodeStringFromAsciiz(&UNCServerName, lpUNCServerName))
+    RtlInitAnsiString(&SourceName, lpSourceName);
+
+    RpcTryExcept
     {
-        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        Status = ElfrRegisterEventSourceA((LPSTR)lpUNCServerName,
+                                          (PRPC_STRING)&SourceName,
+                                          &EmptyStringA,
+                                          1,
+                                          1,
+                                          &LogHandle);
+    }
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+    {
+        Status = I_RpcMapWin32Status(RpcExceptionCode());
+    }
+    RpcEndExcept;
+
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastError(RtlNtStatusToDosError(Status));
         return NULL;
     }
 
-    if (!RtlCreateUnicodeStringFromAsciiz(&SourceName, lpSourceName))
+    return (HANDLE)LogHandle;
-    {
-        RtlFreeUnicodeString(&UNCServerName);
-        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-
-    Handle = RegisterEventSourceW(UNCServerName.Buffer,
-                                  SourceName.Buffer);
-
-    RtlFreeUnicodeString(&UNCServerName);
-    RtlFreeUnicodeString(&SourceName);
-
-    return Handle;
 }
 
 
@@ -861,7 +918,7 @@ RegisterEventSourceW(IN LPCWSTR lpUNCServerName,
     {
         Status = ElfrRegisterEventSourceW((LPWSTR)lpUNCServerName,
                                           &SourceName,
-                                          &EmptyString,
+                                          &EmptyStringU,
                                           1,
                                           1,
                                           &LogHandle);
@@ -896,61 +953,62 @@ ReportEventA(IN HANDLE hEventLog,
              IN LPCSTR *lpStrings,
              IN LPVOID lpRawData)
 {
-    LPCWSTR *wideStrArray;
+    NTSTATUS Status;
-    UNICODE_STRING str;
+    ANSI_STRING *Strings;
+    ANSI_STRING ComputerName;
     WORD i;
-    BOOL ret;
 
-    if (wNumStrings == 0)
+    TRACE("%p, %u, %u, %lu, %p, %u, %lu, %p, %p\n",
-        return TRUE;
+          hEventLog, wType, wCategory, dwEventID, lpUserSid,
+          wNumStrings, dwDataSize, lpStrings, lpRawData);
 
-    if (lpStrings == NULL)
+    Strings = HeapAlloc(GetProcessHeap(),
-        return TRUE;
+                        0,
-
+                        wNumStrings * sizeof(ANSI_STRING));
-    wideStrArray = HeapAlloc(GetProcessHeap(),
+    if (!Strings)
-                             HEAP_ZERO_MEMORY,
-                             sizeof(LPCWSTR) * wNumStrings);
-
-    for (i = 0; i < wNumStrings; i++)
-    {
-        if (!RtlCreateUnicodeStringFromAsciiz(&str, (PSTR)lpStrings[i]))
-            break;
-        wideStrArray[i] = str.Buffer;
-    }
-
-    if (i == wNumStrings)
-    {
-        ret = ReportEventW(hEventLog,
-                           wType,
-                           wCategory,
-                           dwEventID,
-                           lpUserSid,
-                           wNumStrings,
-                           dwDataSize,
-                           wideStrArray,
-                           lpRawData);
-    }
-    else
     {
         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        ret = FALSE;
+        return FALSE;
     }
 
     for (i = 0; i < wNumStrings; i++)
+        RtlInitAnsiString(&Strings[i], lpStrings[i]);
+
+    /*FIXME: ComputerName */
+    RtlInitAnsiString(&ComputerName, "");
+
+    RpcTryExcept
     {
-        if (wideStrArray[i])
+        Status = ElfrReportEventA(hEventLog,
-        {
+                                  0, /* FIXME: Time */
-            HeapFree(GetProcessHeap(),
+                                  wType,
-                     0,
+                                  wCategory,
-                     (PVOID)wideStrArray[i]);
+                                  dwEventID,
-        }
+                                  wNumStrings,
+                                  dwDataSize,
+                                  (PRPC_STRING) &ComputerName,
+                                  lpUserSid,
+                                  (PRPC_STRING*) &Strings,
+                                  lpRawData,
+                                  0,
+                                  NULL,
+                                  NULL);
+    }
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+    {
+        Status = I_RpcMapWin32Status(RpcExceptionCode());
+    }
+    RpcEndExcept;
+
+    HeapFree(GetProcessHeap(), 0, Strings);
+
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastError(RtlNtStatusToDosError(Status));
+        return FALSE;
     }
 
-    HeapFree(GetProcessHeap(),
+    return TRUE;
-             0,
-             (PVOID)wideStrArray);
-
-    return ret;
 }