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/or 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         FIXME("(%p,%s) stub\n", hEventLog, debugstr_a(lpBackupFileName));
 125         return TRUE;
 126 }
 127
 128 /******************************************************************************
 129  * ClearEventLogW [ADVAPI32.@]
 130  *
 131  * See ClearEventLogA.
 132  */
 133 BOOL WINAPI ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
 134 {
 135         FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
 136         return TRUE;
 137 }
 138
 139 /******************************************************************************
 140  * CloseEventLog [ADVAPI32.@]
 141  *
 142  * Closes a read handle to the event log.
 143  *
 144  * PARAMS
 145  *  hEventLog [I/O] Handle of the event log to close.
 146  *
 147  * RETURNS
 148  *  Success: nonzero
 149  *  Failure: zero
 150  */
 151 BOOL WINAPI CloseEventLog( HANDLE hEventLog )
 152 {
 153     FIXME("(%p) stub\n", hEventLog);
 154
 155     if (!hEventLog)
 156     {
 157         SetLastError(ERROR_INVALID_HANDLE);
 158         return FALSE;
 159     }
 160
 161     return TRUE;
 162 }
 163
 164 /******************************************************************************
 165  * ControlTraceW [ADVAPI32.@]
 166  *
 167  * Control a givel event trace session
 168  *
 169  */
 170 ULONG WINAPI ControlTraceW( TRACEHANDLE hSession, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 171 {
 172     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_w(SessionName), Properties, control);
 173     return ERROR_SUCCESS;
 174 }
 175
 176 /******************************************************************************
 177  * ControlTraceA [ADVAPI32.@]
 178  *
 179  * See ControlTraceW.
 180  *
 181  */
 182 ULONG WINAPI ControlTraceA( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 183 {
 184     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_a(SessionName), Properties, control);
 185     return ERROR_SUCCESS;
 186 }
 187
 188 /******************************************************************************
 189  * DeregisterEventSource [ADVAPI32.@]
 190  *
 191  * Closes a write handle to an event log
 192  *
 193  * PARAMS
 194  *  hEventLog [I/O] Handle of the event log.
 195  *
 196  * RETURNS
 197  *  Success: nonzero
 198  *  Failure: zero
 199  */
 200 BOOL WINAPI DeregisterEventSource( HANDLE hEventLog )
 201 {
 202     FIXME("(%p) stub\n", hEventLog);
 203     return TRUE;
 204 }
 205
 206 /******************************************************************************
 207  * EnableTrace [ADVAPI32.@]
 208  */
 209 ULONG WINAPI EnableTrace( ULONG enable, ULONG flag, ULONG level, LPCGUID guid, TRACEHANDLE hSession )
 210 {
 211     FIXME("(%d, 0x%x, %d, %s, %s): stub\n", enable, flag, level,
 212             debugstr_guid(guid), wine_dbgstr_longlong(hSession));
 213
 214     return ERROR_SUCCESS;
 215 }
 216
 217 /******************************************************************************
 218  * GetEventLogInformation [ADVAPI32.@]
 219  *
 220  * Retrieve some information about an event log.
 221  *
 222  * PARAMS
 223  *  hEventLog      [I]   Handle to an open event log.
 224  *  dwInfoLevel    [I]   Level of information (only EVENTLOG_FULL_INFO)
 225  *  lpBuffer       [I/O] The buffer for the returned information
 226  *  cbBufSize      [I]   The size of the buffer
 227  *  pcbBytesNeeded [O]   The needed bytes to hold the information
 228  *
 229  * RETURNS
 230  *  Success: TRUE. lpBuffer will hold the information and pcbBytesNeeded shows
 231  *           the needed buffer size.
 232  *  Failure: FALSE.
 233  */
 234 BOOL WINAPI GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
 235 {
 236     EVENTLOG_FULL_INFORMATION *efi;
 237
 238     FIXME("(%p, %d, %p, %d, %p) stub\n", hEventLog, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 239
 240     if (dwInfoLevel != EVENTLOG_FULL_INFO)
 241     {
 242         SetLastError(ERROR_INVALID_LEVEL);
 243         return FALSE;
 244     }
 245
 246     if (!hEventLog)
 247     {
 248         SetLastError(ERROR_INVALID_HANDLE);
 249         return FALSE;
 250     }
 251
 252     if (!lpBuffer || !pcbBytesNeeded)
 253     {
 254         /* FIXME: This will be handled properly when eventlog is moved
 255          * to a higher level
 256          */
 257         SetLastError(RPC_X_NULL_REF_POINTER);
 258         return FALSE;
 259     }
 260
 261     *pcbBytesNeeded = sizeof(EVENTLOG_FULL_INFORMATION);
 262     if (cbBufSize < sizeof(EVENTLOG_FULL_INFORMATION))
 263     {
 264         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 265         return FALSE;
 266     }
 267
 268     /* Pretend the log is not full */
 269     efi = (EVENTLOG_FULL_INFORMATION *)lpBuffer;
 270     efi->dwFull = 0;
 271
 272     return TRUE;
 273 }
 274
 275 /******************************************************************************
 276  * GetNumberOfEventLogRecords [ADVAPI32.@]
 277  *
 278  * Retrieves the number of records in an event log.
 279  *
 280  * PARAMS
 281  *  hEventLog       [I] Handle to an open event log.
 282  *  NumberOfRecords [O] Number of records in the log.
 283  *
 284  * RETURNS
 285  *  Success: nonzero. NumberOfRecords will contain the number of records in
 286  *           the log.
 287  *  Failure: zero
 288  */
 289 BOOL WINAPI GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
 290 {
 291     FIXME("(%p,%p) stub\n", hEventLog, NumberOfRecords);
 292
 293     if (!NumberOfRecords)
 294     {
 295         SetLastError(ERROR_INVALID_PARAMETER);
 296         return FALSE;
 297     }
 298
 299     if (!hEventLog)
 300     {
 301         SetLastError(ERROR_INVALID_HANDLE);
 302         return FALSE;
 303     }
 304
 305     *NumberOfRecords = 0;
 306
 307     return TRUE;
 308 }
 309
 310 /******************************************************************************
 311  * GetOldestEventLogRecord [ADVAPI32.@]
 312  *
 313  * Retrieves the absolute record number of the oldest record in an even log.
 314  *
 315  * PARAMS
 316  *  hEventLog    [I] Handle to an open event log.
 317  *  OldestRecord [O] Absolute record number of the oldest record.
 318  *
 319  * RETURNS
 320  *  Success: nonzero. OldestRecord contains the record number of the oldest
 321  *           record in the log.
 322  *  Failure: zero
 323  */
 324 BOOL WINAPI GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
 325 {
 326     FIXME("(%p,%p) stub\n", hEventLog, OldestRecord);
 327
 328     if (!OldestRecord)
 329     {
 330         SetLastError(ERROR_INVALID_PARAMETER);
 331         return FALSE;
 332     }
 333
 334     if (!hEventLog)
 335     {
 336         SetLastError(ERROR_INVALID_HANDLE);
 337         return FALSE;
 338     }
 339
 340     *OldestRecord = 0;
 341
 342     return TRUE;
 343 }
 344
 345 /******************************************************************************
 346  * NotifyChangeEventLog [ADVAPI32.@]
 347  *
 348  * Enables an application to receive notification when an event is written
 349  * to an event log.
 350  *
 351  * PARAMS
 352  *  hEventLog [I] Handle to an event log.
 353  *  hEvent    [I] Handle to a manual-reset event object.
 354  *
 355  * RETURNS
 356  *  Success: nonzero
 357  *  Failure: zero
 358  */
 359 BOOL WINAPI NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
 360 {
 361         FIXME("(%p,%p) stub\n", hEventLog, hEvent);
 362         return TRUE;
 363 }
 364
 365 /******************************************************************************
 366  * OpenBackupEventLogA [ADVAPI32.@]
 367  *
 368  * Opens a handle to a backup event log.
 369  *
 370  * PARAMS
 371  *  lpUNCServerName [I] Universal Naming Convention name of the server on which
 372  *                      this will be performed.
 373  *  lpFileName      [I] Specifies the name of the backup file.
 374  *
 375  * RETURNS
 376  *  Success: Handle to the backup event log.
 377  *  Failure: NULL
 378  */
 379 HANDLE WINAPI OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
 380 {
 381     LPWSTR uncnameW, filenameW;
 382     HANDLE handle;
 383
 384     uncnameW = SERV_dup(lpUNCServerName);
 385     filenameW = SERV_dup(lpFileName);
 386     handle = OpenBackupEventLogW(uncnameW, filenameW);
 387     HeapFree(GetProcessHeap(), 0, uncnameW);
 388     HeapFree(GetProcessHeap(), 0, filenameW);
 389
 390     return handle;
 391 }
 392
 393 /******************************************************************************
 394  * OpenBackupEventLogW [ADVAPI32.@]
 395  *
 396  * See OpenBackupEventLogA.
 397  */
 398 HANDLE WINAPI OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
 399 {
 400     FIXME("(%s,%s) stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpFileName));
 401
 402     if (!lpFileName)
 403     {
 404         SetLastError(ERROR_INVALID_PARAMETER);
 405         return NULL;
 406     }
 407
 408     if (lpUNCServerName && lpUNCServerName[0])
 409     {
 410         FIXME("Remote server not supported\n");
 411         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 412         return NULL;
 413     }
 414
 415     if (GetFileAttributesW(lpFileName) == INVALID_FILE_ATTRIBUTES)
 416     {
 417         SetLastError(ERROR_FILE_NOT_FOUND);
 418         return NULL;
 419     }
 420
 421     return (HANDLE)0xcafe4242;
 422 }
 423
 424 /******************************************************************************
 425  * OpenEventLogA [ADVAPI32.@]
 426  *
 427  * Opens a handle to the specified event log.
 428  *
 429  * PARAMS
 430  *  lpUNCServerName [I] UNC name of the server on which the event log is
 431  *                      opened.
 432  *  lpSourceName    [I] Name of the log.
 433  *
 434  * RETURNS
 435  *  Success: Handle to an event log.
 436  *  Failure: NULL
 437  */
 438 HANDLE WINAPI OpenEventLogA( LPCSTR uncname, LPCSTR source )
 439 {
 440     LPWSTR uncnameW, sourceW;
 441     HANDLE handle;
 442
 443     uncnameW = SERV_dup(uncname);
 444     sourceW = SERV_dup(source);
 445     handle = OpenEventLogW(uncnameW, sourceW);
 446     HeapFree(GetProcessHeap(), 0, uncnameW);
 447     HeapFree(GetProcessHeap(), 0, sourceW);
 448
 449     return handle;
 450 }
 451
 452 /******************************************************************************
 453  * OpenEventLogW [ADVAPI32.@]
 454  *
 455  * See OpenEventLogA.
 456  */
 457 HANDLE WINAPI OpenEventLogW( LPCWSTR uncname, LPCWSTR source )
 458 {
 459     FIXME("(%s,%s) stub\n", debugstr_w(uncname), debugstr_w(source));
 460
 461     if (!source)
 462     {
 463         SetLastError(ERROR_INVALID_PARAMETER);
 464         return NULL;
 465     }
 466
 467     if (uncname && uncname[0])
 468     {
 469         FIXME("Remote server not supported\n");
 470         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 471         return NULL;
 472     }
 473
 474     return (HANDLE)0xcafe4242;
 475 }
 476
 477 /******************************************************************************
 478  * QueryAllTracesW [ADVAPI32.@]
 479  *
 480  * Query informations for started event trace sessions
 481  *
 482  */
 483 ULONG WINAPI QueryAllTracesW( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 484 {
 485     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 486
 487     if (psessioncount) *psessioncount = 0;
 488     return ERROR_SUCCESS;
 489 }
 490
 491 /******************************************************************************
 492  * QueryAllTracesA [ADVAPI32.@]
 493  *
 494  * See QueryAllTracesW.
 495  */
 496 ULONG WINAPI QueryAllTracesA( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 497 {
 498     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 499
 500     if (psessioncount) *psessioncount = 0;
 501     return ERROR_SUCCESS;
 502 }
 503
 504 /******************************************************************************
 505  * ReadEventLogA [ADVAPI32.@]
 506  *
 507  * Reads a whole number of entries from an event log.
 508  *
 509  * PARAMS
 510  *  hEventLog                [I] Handle of the event log to read.
 511  *  dwReadFlags              [I] see MSDN doc.
 512  *  dwRecordOffset           [I] Log-entry record number to start at.
 513  *  lpBuffer                 [O] Buffer for the data read.
 514  *  nNumberOfBytesToRead     [I] Size of lpBuffer.
 515  *  pnBytesRead              [O] Receives number of bytes read.
 516  *  pnMinNumberOfBytesNeeded [O] Receives number of bytes required for the
 517  *                               next log entry.
 518  *
 519  * RETURNS
 520  *  Success: nonzero
 521  *  Failure: zero
 522  */
 523 BOOL WINAPI ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 524     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 525 {
 526     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 527           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 528     return FALSE;
 529 }
 530
 531 /******************************************************************************
 532  * ReadEventLogW [ADVAPI32.@]
 533  *
 534  * See ReadEventLogA.
 535  */
 536 BOOL WINAPI ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 537     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 538 {
 539     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 540           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 541     return FALSE;
 542 }
 543
 544 /******************************************************************************
 545  * RegisterEventSourceA [ADVAPI32.@]
 546  *
 547  * Returns a registered handle to an event log.
 548  *
 549  * PARAMS
 550  *  lpUNCServerName [I] UNC name of the source server.
 551  *  lpSourceName    [I] Specifies the name of the event source to retrieve.
 552  *
 553  * RETURNS
 554  *  Success: Handle to the event log.
 555  *  Failure: NULL. Returns ERROR_INVALID_HANDLE if lpSourceName specifies the
 556  *           Security event log.
 557  */
 558 HANDLE WINAPI RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
 559 {
 560     UNICODE_STRING lpUNCServerNameW;
 561     UNICODE_STRING lpSourceNameW;
 562     HANDLE ret;
 563
 564     FIXME("(%s,%s): stub\n", debugstr_a(lpUNCServerName), debugstr_a(lpSourceName));
 565
 566     RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW, lpUNCServerName);
 567     RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW, lpSourceName);
 568     ret = RegisterEventSourceW(lpUNCServerNameW.Buffer,lpSourceNameW.Buffer);
 569     RtlFreeUnicodeString (&lpUNCServerNameW);
 570     RtlFreeUnicodeString (&lpSourceNameW);
 571     return ret;
 572 }
 573
 574 /******************************************************************************
 575  * RegisterEventSourceW [ADVAPI32.@]
 576  *
 577  * See RegisterEventSourceA.
 578  */
 579 HANDLE WINAPI RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
 580 {
 581     FIXME("(%s,%s): stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
 582     return (HANDLE)0xcafe4242;
 583 }
 584
 585 /******************************************************************************
 586  * ReportEventA [ADVAPI32.@]
 587  *
 588  * Writes an entry at the end of an event log.
 589  *
 590  * PARAMS
 591  *  hEventLog   [I] Handle of an event log.
 592  *  wType       [I] See MSDN doc.
 593  *  wCategory   [I] Event category.
 594  *  dwEventID   [I] Event identifier.
 595  *  lpUserSid   [I] Current user's security identifier.
 596  *  wNumStrings [I] Number of insert strings in lpStrings.
 597  *  dwDataSize  [I] Size of event-specific raw data to write.
 598  *  lpStrings   [I] Buffer containing an array of string to be merged.
 599  *  lpRawData   [I] Buffer containing the binary data.
 600  *
 601  * RETURNS
 602  *  Success: nonzero. Entry was written to the log.
 603  *  Failure: zero.
 604  *
 605  * NOTES
 606  *  The ReportEvent function adds the time, the entry's length, and the
 607  *  offsets before storing the entry in the log. If lpUserSid != NULL, the
 608  *  username is also logged.
 609  */
 610 BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 611     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData)
 612 {
 613     LPWSTR *wideStrArray;
 614     UNICODE_STRING str;
 615     int i;
 616     BOOL ret;
 617
 618     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 619           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 620
 621     if (wNumStrings == 0) return TRUE;
 622     if (!lpStrings) return TRUE;
 623
 624     wideStrArray = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWSTR) * wNumStrings);
 625     for (i = 0; i < wNumStrings; i++)
 626     {
 627         RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
 628         wideStrArray[i] = str.Buffer;
 629     }
 630     ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
 631                        wNumStrings, dwDataSize, (LPCWSTR *)wideStrArray, lpRawData);
 632     for (i = 0; i < wNumStrings; i++)
 633     {
 634         HeapFree( GetProcessHeap(), 0, wideStrArray[i] );
 635     }
 636     HeapFree(GetProcessHeap(), 0, wideStrArray);
 637     return ret;
 638 }
 639
 640 /******************************************************************************
 641  * ReportEventW [ADVAPI32.@]
 642  *
 643  * See ReportEventA.
 644  */
 645 BOOL WINAPI ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 646     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData )
 647 {
 648     int i;
 649
 650     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 651           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 652
 653     /* partial stub */
 654
 655     if (wNumStrings == 0) return TRUE;
 656     if (!lpStrings) return TRUE;
 657
 658     for (i = 0; i < wNumStrings; i++)
 659     {
 660         switch (wType)
 661         {
 662         case EVENTLOG_SUCCESS:
 663             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 664             break;
 665         case EVENTLOG_ERROR_TYPE:
 666             ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 667             break;
 668         case EVENTLOG_WARNING_TYPE:
 669             WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 670             break;
 671         default:
 672             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 673             break;
 674         }
 675     }
 676     return TRUE;
 677 }
 678
 679 /******************************************************************************
 680  * RegisterTraceGuidsW [ADVAPI32.@]
 681  *
 682  * Register an event trace provider and the event trace classes that it uses
 683  * to generate events.
 684  *
 685  * PARAMS
 686  *  RequestAddress     [I]   ControlCallback function
 687  *  RequestContext     [I]   Optional provider-defined context
 688  *  ControlGuid        [I]   GUID of the registering provider
 689  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 690  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 691  *  MofImagePath       [I]   not supported, set to NULL
 692  *  MofResourceNmae    [I]   not supported, set to NULL
 693  *  RegistrationHandle [O]   Provider's registration handle
 694  *
 695  * RETURNS
 696  *  Success: ERROR_SUCCESS
 697  *  Failure: System error code
 698  *
 699  * FIXME
 700  *  Stub.
 701  */
 702 ULONG WINAPI RegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 703                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 704                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCWSTR MofImagePath,
 705                 LPCWSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 706 {
 707     FIXME("%p %p %p %u %p %s %s %p\n", RequestAddress, RequestContext,
 708           ControlGuid, GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 709           debugstr_w(MofResourceName), RegistrationHandle);
 710     return ERROR_CALL_NOT_IMPLEMENTED;
 711 }
 712
 713 /******************************************************************************
 714  * RegisterTraceGuidsA [ADVAPI32.@]
 715  *
 716  * See RegisterTraceGuidsW.
 717  *
 718  * FIXME
 719  *  Stub.
 720  */
 721 ULONG WINAPI RegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 722                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 723                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCSTR MofImagePath,
 724                 LPCSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 725 {
 726     FIXME("%p %p %p %u %p %s %s %p\n", RequestAddress, RequestContext,
 727           ControlGuid, GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 728           debugstr_a(MofResourceName), RegistrationHandle);
 729     return ERROR_CALL_NOT_IMPLEMENTED;
 730 }
 731
 732 /******************************************************************************
 733  * StartTraceW [ADVAPI32.@]
 734  *
 735  * Register and start an event trace session
 736  *
 737  */
 738 ULONG WINAPI StartTraceW( PTRACEHANDLE pSessionHandle, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 739 {
 740     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_w(SessionName), Properties);
 741     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 742     return ERROR_SUCCESS;
 743 }
 744
 745 /******************************************************************************
 746  * StartTraceA [ADVAPI32.@]
 747  *
 748  * See StartTraceW.
 749  *
 750  */
 751 ULONG WINAPI StartTraceA( PTRACEHANDLE pSessionHandle, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 752 {
 753     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_a(SessionName), Properties);
 754     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 755     return ERROR_SUCCESS;
 756 }
 757
 758 /******************************************************************************
 759  * TraceEvent [ADVAPI32.@]
 760  */
 761 ULONG WINAPI TraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 762 {
 763     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 764     return ERROR_CALL_NOT_IMPLEMENTED;
 765 }
 766
 767 /******************************************************************************
 768  * UnregisterTraceGuids [ADVAPI32.@]
 769  *
 770  * See RegisterTraceGuids
 771  *
 772  * FIXME
 773  *  Stub.
 774  */
 775 ULONG WINAPI UnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 776 {
 777     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 778     return ERROR_CALL_NOT_IMPLEMENTED;
 779 }