git.oblomov.eu Git - wine/blob - dlls/advapi32/eventlog.c

   1 /*
   2  * Win32 advapi functions
   3  *
   4  * Copyright 1995 Sven Verdoolaege
   5  * Copyright 1998 Juergen Schmied
   6  * Copyright 2003 Mike Hearn
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "winternl.h"
  29 #include "wmistr.h"
  30 #include "evntrace.h"
  31
  32 #include "wine/unicode.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  36 WINE_DECLARE_DEBUG_CHANNEL(eventlog);
  37
  38 static inline LPWSTR SERV_dup( LPCSTR str )
  39 {
  40     UINT len;
  41     LPWSTR wstr;
  42
  43     if( !str )
  44         return NULL;
  45     len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
  46     wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
  47     MultiByteToWideChar( CP_ACP, 0, str, -1, wstr, len );
  48     return wstr;
  49 }
  50
  51 /******************************************************************************
  52  * BackupEventLogA [ADVAPI32.@]
  53  *
  54  * Saves the event log to a backup file.
  55  *
  56  * PARAMS
  57  *  hEventLog        [I] Handle to event log to backup.
  58  *  lpBackupFileName [I] Name of the backup file.
  59  *
  60  * RETURNS
  61  *  Success: nonzero. File lpBackupFileName will contain the contents of
  62  *           hEvenLog.
  63  *  Failure: zero.
  64  */
  65 BOOL WINAPI BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
  66 {
  67     LPWSTR backupW;
  68     BOOL ret;
  69
  70     backupW = SERV_dup(lpBackupFileName);
  71     ret = BackupEventLogW(hEventLog, backupW);
  72     HeapFree(GetProcessHeap(), 0, backupW);
  73
  74     return ret;
  75 }
  76
  77 /******************************************************************************
  78  * BackupEventLogW [ADVAPI32.@]
  79  *
  80  * See BackupEventLogA.
  81  */
  82 BOOL WINAPI BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
  83 {
  84     FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
  85
  86     if (!lpBackupFileName)
  87     {
  88         SetLastError(ERROR_INVALID_PARAMETER);
  89         return FALSE;
  90     }
  91
  92     if (!hEventLog)
  93     {
  94         SetLastError(ERROR_INVALID_HANDLE);
  95         return FALSE;
  96     }
  97
  98     if (GetFileAttributesW(lpBackupFileName) != INVALID_FILE_ATTRIBUTES)
  99     {
 100         SetLastError(ERROR_ALREADY_EXISTS);
 101         return FALSE;
 102     }
 103
 104     return TRUE;
 105 }
 106
 107 /******************************************************************************
 108  * ClearEventLogA [ADVAPI32.@]
 109  *
 110  * Clears the event log and optionally saves the log to a backup file.
 111  *
 112  * PARAMS
 113  *  hEvenLog         [I] Handle to event log to clear.
 114  *  lpBackupFileName [I] Name of the backup file.
 115  *
 116  * RETURNS
 117  *  Success: nonzero. if lpBackupFileName != NULL, lpBackupFileName will
 118  *           contain the contents of hEvenLog and the log will be cleared.
 119  *  Failure: zero. Fails if the event log is empty or if lpBackupFileName
 120  *           exists.
 121  */
 122 BOOL WINAPI ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
 123 {
 124     LPWSTR backupW;
 125     BOOL ret;
 126
 127     backupW = SERV_dup(lpBackupFileName);
 128     ret = ClearEventLogW(hEventLog, backupW);
 129     HeapFree(GetProcessHeap(), 0, backupW);
 130
 131     return ret;
 132 }
 133
 134 /******************************************************************************
 135  * ClearEventLogW [ADVAPI32.@]
 136  *
 137  * See ClearEventLogA.
 138  */
 139 BOOL WINAPI ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
 140 {
 141     FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
 142
 143     if (!hEventLog)
 144     {
 145         SetLastError(ERROR_INVALID_HANDLE);
 146         return FALSE;
 147     }
 148
 149     return TRUE;
 150 }
 151
 152 /******************************************************************************
 153  * CloseEventLog [ADVAPI32.@]
 154  *
 155  * Closes a read handle to the event log.
 156  *
 157  * PARAMS
 158  *  hEventLog [I/O] Handle of the event log to close.
 159  *
 160  * RETURNS
 161  *  Success: nonzero
 162  *  Failure: zero
 163  */
 164 BOOL WINAPI CloseEventLog( HANDLE hEventLog )
 165 {
 166     FIXME("(%p) stub\n", hEventLog);
 167
 168     if (!hEventLog)
 169     {
 170         SetLastError(ERROR_INVALID_HANDLE);
 171         return FALSE;
 172     }
 173
 174     return TRUE;
 175 }
 176
 177 /******************************************************************************
 178  * ControlTraceW [ADVAPI32.@]
 179  *
 180  * Control a givel event trace session
 181  *
 182  */
 183 ULONG WINAPI ControlTraceW( TRACEHANDLE hSession, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 184 {
 185     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_w(SessionName), Properties, control);
 186     return ERROR_SUCCESS;
 187 }
 188
 189 /******************************************************************************
 190  * ControlTraceA [ADVAPI32.@]
 191  *
 192  * See ControlTraceW.
 193  *
 194  */
 195 ULONG WINAPI ControlTraceA( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 196 {
 197     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_a(SessionName), Properties, control);
 198     return ERROR_SUCCESS;
 199 }
 200
 201 /******************************************************************************
 202  * FlushTraceA [ADVAPI32.@]
 203  */
 204 ULONG WINAPI FlushTraceA ( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 205 {
 206     return ControlTraceA( hSession, SessionName, Properties, EVENT_TRACE_CONTROL_FLUSH );
 207 }
 208
 209 /******************************************************************************
 210  * FlushTraceW [ADVAPI32.@]
 211  */
 212 ULONG WINAPI FlushTraceW ( TRACEHANDLE hSession, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 213 {
 214     return ControlTraceW( hSession, SessionName, Properties, EVENT_TRACE_CONTROL_FLUSH );
 215 }
 216
 217
 218 /******************************************************************************
 219  * DeregisterEventSource [ADVAPI32.@]
 220  *
 221  * Closes a write handle to an event log
 222  *
 223  * PARAMS
 224  *  hEventLog [I/O] Handle of the event log.
 225  *
 226  * RETURNS
 227  *  Success: nonzero
 228  *  Failure: zero
 229  */
 230 BOOL WINAPI DeregisterEventSource( HANDLE hEventLog )
 231 {
 232     FIXME("(%p) stub\n", hEventLog);
 233     return TRUE;
 234 }
 235
 236 /******************************************************************************
 237  * EnableTrace [ADVAPI32.@]
 238  */
 239 ULONG WINAPI EnableTrace( ULONG enable, ULONG flag, ULONG level, LPCGUID guid, TRACEHANDLE hSession )
 240 {
 241     FIXME("(%d, 0x%x, %d, %s, %s): stub\n", enable, flag, level,
 242             debugstr_guid(guid), wine_dbgstr_longlong(hSession));
 243
 244     return ERROR_SUCCESS;
 245 }
 246
 247 /******************************************************************************
 248  * GetEventLogInformation [ADVAPI32.@]
 249  *
 250  * Retrieve some information about an event log.
 251  *
 252  * PARAMS
 253  *  hEventLog      [I]   Handle to an open event log.
 254  *  dwInfoLevel    [I]   Level of information (only EVENTLOG_FULL_INFO)
 255  *  lpBuffer       [I/O] The buffer for the returned information
 256  *  cbBufSize      [I]   The size of the buffer
 257  *  pcbBytesNeeded [O]   The needed bytes to hold the information
 258  *
 259  * RETURNS
 260  *  Success: TRUE. lpBuffer will hold the information and pcbBytesNeeded shows
 261  *           the needed buffer size.
 262  *  Failure: FALSE.
 263  */
 264 BOOL WINAPI GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
 265 {
 266     EVENTLOG_FULL_INFORMATION *efi;
 267
 268     FIXME("(%p, %d, %p, %d, %p) stub\n", hEventLog, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 269
 270     if (dwInfoLevel != EVENTLOG_FULL_INFO)
 271     {
 272         SetLastError(ERROR_INVALID_LEVEL);
 273         return FALSE;
 274     }
 275
 276     if (!hEventLog)
 277     {
 278         SetLastError(ERROR_INVALID_HANDLE);
 279         return FALSE;
 280     }
 281
 282     if (!lpBuffer || !pcbBytesNeeded)
 283     {
 284         /* FIXME: This will be handled properly when eventlog is moved
 285          * to a higher level
 286          */
 287         SetLastError(RPC_X_NULL_REF_POINTER);
 288         return FALSE;
 289     }
 290
 291     *pcbBytesNeeded = sizeof(EVENTLOG_FULL_INFORMATION);
 292     if (cbBufSize < sizeof(EVENTLOG_FULL_INFORMATION))
 293     {
 294         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 295         return FALSE;
 296     }
 297
 298     /* Pretend the log is not full */
 299     efi = (EVENTLOG_FULL_INFORMATION *)lpBuffer;
 300     efi->dwFull = 0;
 301
 302     return TRUE;
 303 }
 304
 305 /******************************************************************************
 306  * GetNumberOfEventLogRecords [ADVAPI32.@]
 307  *
 308  * Retrieves the number of records in an event log.
 309  *
 310  * PARAMS
 311  *  hEventLog       [I] Handle to an open event log.
 312  *  NumberOfRecords [O] Number of records in the log.
 313  *
 314  * RETURNS
 315  *  Success: nonzero. NumberOfRecords will contain the number of records in
 316  *           the log.
 317  *  Failure: zero
 318  */
 319 BOOL WINAPI GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
 320 {
 321     FIXME("(%p,%p) stub\n", hEventLog, NumberOfRecords);
 322
 323     if (!NumberOfRecords)
 324     {
 325         SetLastError(ERROR_INVALID_PARAMETER);
 326         return FALSE;
 327     }
 328
 329     if (!hEventLog)
 330     {
 331         SetLastError(ERROR_INVALID_HANDLE);
 332         return FALSE;
 333     }
 334
 335     *NumberOfRecords = 0;
 336
 337     return TRUE;
 338 }
 339
 340 /******************************************************************************
 341  * GetOldestEventLogRecord [ADVAPI32.@]
 342  *
 343  * Retrieves the absolute record number of the oldest record in an even log.
 344  *
 345  * PARAMS
 346  *  hEventLog    [I] Handle to an open event log.
 347  *  OldestRecord [O] Absolute record number of the oldest record.
 348  *
 349  * RETURNS
 350  *  Success: nonzero. OldestRecord contains the record number of the oldest
 351  *           record in the log.
 352  *  Failure: zero
 353  */
 354 BOOL WINAPI GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
 355 {
 356     FIXME("(%p,%p) stub\n", hEventLog, OldestRecord);
 357
 358     if (!OldestRecord)
 359     {
 360         SetLastError(ERROR_INVALID_PARAMETER);
 361         return FALSE;
 362     }
 363
 364     if (!hEventLog)
 365     {
 366         SetLastError(ERROR_INVALID_HANDLE);
 367         return FALSE;
 368     }
 369
 370     *OldestRecord = 0;
 371
 372     return TRUE;
 373 }
 374
 375 /******************************************************************************
 376  * NotifyChangeEventLog [ADVAPI32.@]
 377  *
 378  * Enables an application to receive notification when an event is written
 379  * to an event log.
 380  *
 381  * PARAMS
 382  *  hEventLog [I] Handle to an event log.
 383  *  hEvent    [I] Handle to a manual-reset event object.
 384  *
 385  * RETURNS
 386  *  Success: nonzero
 387  *  Failure: zero
 388  */
 389 BOOL WINAPI NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
 390 {
 391         FIXME("(%p,%p) stub\n", hEventLog, hEvent);
 392         return TRUE;
 393 }
 394
 395 /******************************************************************************
 396  * OpenBackupEventLogA [ADVAPI32.@]
 397  *
 398  * Opens a handle to a backup event log.
 399  *
 400  * PARAMS
 401  *  lpUNCServerName [I] Universal Naming Convention name of the server on which
 402  *                      this will be performed.
 403  *  lpFileName      [I] Specifies the name of the backup file.
 404  *
 405  * RETURNS
 406  *  Success: Handle to the backup event log.
 407  *  Failure: NULL
 408  */
 409 HANDLE WINAPI OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
 410 {
 411     LPWSTR uncnameW, filenameW;
 412     HANDLE handle;
 413
 414     uncnameW = SERV_dup(lpUNCServerName);
 415     filenameW = SERV_dup(lpFileName);
 416     handle = OpenBackupEventLogW(uncnameW, filenameW);
 417     HeapFree(GetProcessHeap(), 0, uncnameW);
 418     HeapFree(GetProcessHeap(), 0, filenameW);
 419
 420     return handle;
 421 }
 422
 423 /******************************************************************************
 424  * OpenBackupEventLogW [ADVAPI32.@]
 425  *
 426  * See OpenBackupEventLogA.
 427  */
 428 HANDLE WINAPI OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
 429 {
 430     FIXME("(%s,%s) stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpFileName));
 431
 432     if (!lpFileName)
 433     {
 434         SetLastError(ERROR_INVALID_PARAMETER);
 435         return NULL;
 436     }
 437
 438     if (lpUNCServerName && lpUNCServerName[0])
 439     {
 440         FIXME("Remote server not supported\n");
 441         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 442         return NULL;
 443     }
 444
 445     if (GetFileAttributesW(lpFileName) == INVALID_FILE_ATTRIBUTES)
 446     {
 447         SetLastError(ERROR_FILE_NOT_FOUND);
 448         return NULL;
 449     }
 450
 451     return (HANDLE)0xcafe4242;
 452 }
 453
 454 /******************************************************************************
 455  * OpenEventLogA [ADVAPI32.@]
 456  *
 457  * Opens a handle to the specified event log.
 458  *
 459  * PARAMS
 460  *  lpUNCServerName [I] UNC name of the server on which the event log is
 461  *                      opened.
 462  *  lpSourceName    [I] Name of the log.
 463  *
 464  * RETURNS
 465  *  Success: Handle to an event log.
 466  *  Failure: NULL
 467  */
 468 HANDLE WINAPI OpenEventLogA( LPCSTR uncname, LPCSTR source )
 469 {
 470     LPWSTR uncnameW, sourceW;
 471     HANDLE handle;
 472
 473     uncnameW = SERV_dup(uncname);
 474     sourceW = SERV_dup(source);
 475     handle = OpenEventLogW(uncnameW, sourceW);
 476     HeapFree(GetProcessHeap(), 0, uncnameW);
 477     HeapFree(GetProcessHeap(), 0, sourceW);
 478
 479     return handle;
 480 }
 481
 482 /******************************************************************************
 483  * OpenEventLogW [ADVAPI32.@]
 484  *
 485  * See OpenEventLogA.
 486  */
 487 HANDLE WINAPI OpenEventLogW( LPCWSTR uncname, LPCWSTR source )
 488 {
 489     FIXME("(%s,%s) stub\n", debugstr_w(uncname), debugstr_w(source));
 490
 491     if (!source)
 492     {
 493         SetLastError(ERROR_INVALID_PARAMETER);
 494         return NULL;
 495     }
 496
 497     if (uncname && uncname[0])
 498     {
 499         FIXME("Remote server not supported\n");
 500         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 501         return NULL;
 502     }
 503
 504     return (HANDLE)0xcafe4242;
 505 }
 506
 507 /******************************************************************************
 508  * QueryAllTracesW [ADVAPI32.@]
 509  *
 510  * Query information for started event trace sessions
 511  *
 512  */
 513 ULONG WINAPI QueryAllTracesW( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 514 {
 515     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 516
 517     if (psessioncount) *psessioncount = 0;
 518     return ERROR_SUCCESS;
 519 }
 520
 521 /******************************************************************************
 522  * QueryAllTracesA [ADVAPI32.@]
 523  *
 524  * See QueryAllTracesW.
 525  */
 526 ULONG WINAPI QueryAllTracesA( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 527 {
 528     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 529
 530     if (psessioncount) *psessioncount = 0;
 531     return ERROR_SUCCESS;
 532 }
 533
 534 /******************************************************************************
 535  * ReadEventLogA [ADVAPI32.@]
 536  *
 537  * Reads a whole number of entries from an event log.
 538  *
 539  * PARAMS
 540  *  hEventLog                [I] Handle of the event log to read.
 541  *  dwReadFlags              [I] see MSDN doc.
 542  *  dwRecordOffset           [I] Log-entry record number to start at.
 543  *  lpBuffer                 [O] Buffer for the data read.
 544  *  nNumberOfBytesToRead     [I] Size of lpBuffer.
 545  *  pnBytesRead              [O] Receives number of bytes read.
 546  *  pnMinNumberOfBytesNeeded [O] Receives number of bytes required for the
 547  *                               next log entry.
 548  *
 549  * RETURNS
 550  *  Success: nonzero
 551  *  Failure: zero
 552  */
 553 BOOL WINAPI ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 554     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 555 {
 556     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 557           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 558     return FALSE;
 559 }
 560
 561 /******************************************************************************
 562  * ReadEventLogW [ADVAPI32.@]
 563  *
 564  * See ReadEventLogA.
 565  */
 566 BOOL WINAPI ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 567     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 568 {
 569     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 570           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 571     return FALSE;
 572 }
 573
 574 /******************************************************************************
 575  * RegisterEventSourceA [ADVAPI32.@]
 576  *
 577  * Returns a registered handle to an event log.
 578  *
 579  * PARAMS
 580  *  lpUNCServerName [I] UNC name of the source server.
 581  *  lpSourceName    [I] Specifies the name of the event source to retrieve.
 582  *
 583  * RETURNS
 584  *  Success: Handle to the event log.
 585  *  Failure: NULL. Returns ERROR_INVALID_HANDLE if lpSourceName specifies the
 586  *           Security event log.
 587  */
 588 HANDLE WINAPI RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
 589 {
 590     UNICODE_STRING lpUNCServerNameW;
 591     UNICODE_STRING lpSourceNameW;
 592     HANDLE ret;
 593
 594     FIXME("(%s,%s): stub\n", debugstr_a(lpUNCServerName), debugstr_a(lpSourceName));
 595
 596     RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW, lpUNCServerName);
 597     RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW, lpSourceName);
 598     ret = RegisterEventSourceW(lpUNCServerNameW.Buffer,lpSourceNameW.Buffer);
 599     RtlFreeUnicodeString (&lpUNCServerNameW);
 600     RtlFreeUnicodeString (&lpSourceNameW);
 601     return ret;
 602 }
 603
 604 /******************************************************************************
 605  * RegisterEventSourceW [ADVAPI32.@]
 606  *
 607  * See RegisterEventSourceA.
 608  */
 609 HANDLE WINAPI RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
 610 {
 611     FIXME("(%s,%s): stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
 612     return (HANDLE)0xcafe4242;
 613 }
 614
 615 /******************************************************************************
 616  * ReportEventA [ADVAPI32.@]
 617  *
 618  * Writes an entry at the end of an event log.
 619  *
 620  * PARAMS
 621  *  hEventLog   [I] Handle of an event log.
 622  *  wType       [I] See MSDN doc.
 623  *  wCategory   [I] Event category.
 624  *  dwEventID   [I] Event identifier.
 625  *  lpUserSid   [I] Current user's security identifier.
 626  *  wNumStrings [I] Number of insert strings in lpStrings.
 627  *  dwDataSize  [I] Size of event-specific raw data to write.
 628  *  lpStrings   [I] Buffer containing an array of string to be merged.
 629  *  lpRawData   [I] Buffer containing the binary data.
 630  *
 631  * RETURNS
 632  *  Success: nonzero. Entry was written to the log.
 633  *  Failure: zero.
 634  *
 635  * NOTES
 636  *  The ReportEvent function adds the time, the entry's length, and the
 637  *  offsets before storing the entry in the log. If lpUserSid != NULL, the
 638  *  username is also logged.
 639  */
 640 BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 641     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData)
 642 {
 643     LPWSTR *wideStrArray;
 644     UNICODE_STRING str;
 645     int i;
 646     BOOL ret;
 647
 648     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 649           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 650
 651     if (wNumStrings == 0) return TRUE;
 652     if (!lpStrings) return TRUE;
 653
 654     wideStrArray = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWSTR) * wNumStrings);
 655     for (i = 0; i < wNumStrings; i++)
 656     {
 657         RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
 658         wideStrArray[i] = str.Buffer;
 659     }
 660     ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
 661                        wNumStrings, dwDataSize, (LPCWSTR *)wideStrArray, lpRawData);
 662     for (i = 0; i < wNumStrings; i++)
 663     {
 664         HeapFree( GetProcessHeap(), 0, wideStrArray[i] );
 665     }
 666     HeapFree(GetProcessHeap(), 0, wideStrArray);
 667     return ret;
 668 }
 669
 670 /******************************************************************************
 671  * ReportEventW [ADVAPI32.@]
 672  *
 673  * See ReportEventA.
 674  */
 675 BOOL WINAPI ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 676     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData )
 677 {
 678     int i;
 679
 680     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 681           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 682
 683     /* partial stub */
 684
 685     if (wNumStrings == 0) return TRUE;
 686     if (!lpStrings) return TRUE;
 687
 688     for (i = 0; i < wNumStrings; i++)
 689     {
 690         switch (wType)
 691         {
 692         case EVENTLOG_SUCCESS:
 693             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 694             break;
 695         case EVENTLOG_ERROR_TYPE:
 696             ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 697             break;
 698         case EVENTLOG_WARNING_TYPE:
 699             WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 700             break;
 701         default:
 702             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 703             break;
 704         }
 705     }
 706     return TRUE;
 707 }
 708
 709 /******************************************************************************
 710  * RegisterTraceGuidsW [ADVAPI32.@]
 711  *
 712  * Register an event trace provider and the event trace classes that it uses
 713  * to generate events.
 714  *
 715  * PARAMS
 716  *  RequestAddress     [I]   ControlCallback function
 717  *  RequestContext     [I]   Optional provider-defined context
 718  *  ControlGuid        [I]   GUID of the registering provider
 719  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 720  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 721  *  MofImagePath       [I]   not supported, set to NULL
 722  *  MofResourceNmae    [I]   not supported, set to NULL
 723  *  RegistrationHandle [O]   Provider's registration handle
 724  *
 725  * RETURNS
 726  *  Success: ERROR_SUCCESS
 727  *  Failure: System error code
 728  *
 729  * FIXME
 730  *  Stub.
 731  */
 732 ULONG WINAPI RegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 733                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 734                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCWSTR MofImagePath,
 735                 LPCWSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 736 {
 737     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p,)\n", RequestAddress, RequestContext,
 738           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 739           debugstr_w(MofResourceName), RegistrationHandle);
 740     return ERROR_CALL_NOT_IMPLEMENTED;
 741 }
 742
 743 /******************************************************************************
 744  * RegisterTraceGuidsA [ADVAPI32.@]
 745  *
 746  * See RegisterTraceGuidsW.
 747  *
 748  * FIXME
 749  *  Stub.
 750  */
 751 ULONG WINAPI RegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 752                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 753                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCSTR MofImagePath,
 754                 LPCSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 755 {
 756     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p,)\n", RequestAddress, RequestContext,
 757           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 758           debugstr_a(MofResourceName), RegistrationHandle);
 759     return ERROR_CALL_NOT_IMPLEMENTED;
 760 }
 761
 762 /******************************************************************************
 763  * StartTraceW [ADVAPI32.@]
 764  *
 765  * Register and start an event trace session
 766  *
 767  */
 768 ULONG WINAPI StartTraceW( PTRACEHANDLE pSessionHandle, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 769 {
 770     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_w(SessionName), Properties);
 771     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 772     return ERROR_SUCCESS;
 773 }
 774
 775 /******************************************************************************
 776  * StartTraceA [ADVAPI32.@]
 777  *
 778  * See StartTraceW.
 779  *
 780  */
 781 ULONG WINAPI StartTraceA( PTRACEHANDLE pSessionHandle, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 782 {
 783     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_a(SessionName), Properties);
 784     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 785     return ERROR_SUCCESS;
 786 }
 787
 788 /******************************************************************************
 789  * TraceEvent [ADVAPI32.@]
 790  */
 791 ULONG WINAPI TraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 792 {
 793     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 794     return ERROR_CALL_NOT_IMPLEMENTED;
 795 }
 796
 797 /******************************************************************************
 798  * UnregisterTraceGuids [ADVAPI32.@]
 799  *
 800  * See RegisterTraceGuids
 801  *
 802  * FIXME
 803  *  Stub.
 804  */
 805 ULONG WINAPI UnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 806 {
 807     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 808     return ERROR_CALL_NOT_IMPLEMENTED;
 809 }