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 #include "evntprov.h"
  32
  33 #include "wine/unicode.h"
  34 #include "wine/debug.h"
  35
  36 #include "advapi32_misc.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  39 WINE_DECLARE_DEBUG_CHANNEL(eventlog);
  40
  41 /******************************************************************************
  42  * BackupEventLogA [ADVAPI32.@]
  43  *
  44  * Saves the event log to a backup file.
  45  *
  46  * PARAMS
  47  *  hEventLog        [I] Handle to event log to backup.
  48  *  lpBackupFileName [I] Name of the backup file.
  49  *
  50  * RETURNS
  51  *  Success: nonzero. File lpBackupFileName will contain the contents of
  52  *           hEvenLog.
  53  *  Failure: zero.
  54  */
  55 BOOL WINAPI BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
  56 {
  57     LPWSTR backupW;
  58     BOOL ret;
  59
  60     backupW = SERV_dup(lpBackupFileName);
  61     ret = BackupEventLogW(hEventLog, backupW);
  62     HeapFree(GetProcessHeap(), 0, backupW);
  63
  64     return ret;
  65 }
  66
  67 /******************************************************************************
  68  * BackupEventLogW [ADVAPI32.@]
  69  *
  70  * See BackupEventLogA.
  71  */
  72 BOOL WINAPI BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
  73 {
  74     FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
  75
  76     if (!lpBackupFileName)
  77     {
  78         SetLastError(ERROR_INVALID_PARAMETER);
  79         return FALSE;
  80     }
  81
  82     if (!hEventLog)
  83     {
  84         SetLastError(ERROR_INVALID_HANDLE);
  85         return FALSE;
  86     }
  87
  88     if (GetFileAttributesW(lpBackupFileName) != INVALID_FILE_ATTRIBUTES)
  89     {
  90         SetLastError(ERROR_ALREADY_EXISTS);
  91         return FALSE;
  92     }
  93
  94     return TRUE;
  95 }
  96
  97 /******************************************************************************
  98  * ClearEventLogA [ADVAPI32.@]
  99  *
 100  * Clears the event log and optionally saves the log to a backup file.
 101  *
 102  * PARAMS
 103  *  hEvenLog         [I] Handle to event log to clear.
 104  *  lpBackupFileName [I] Name of the backup file.
 105  *
 106  * RETURNS
 107  *  Success: nonzero. if lpBackupFileName != NULL, lpBackupFileName will
 108  *           contain the contents of hEvenLog and the log will be cleared.
 109  *  Failure: zero. Fails if the event log is empty or if lpBackupFileName
 110  *           exists.
 111  */
 112 BOOL WINAPI ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
 113 {
 114     LPWSTR backupW;
 115     BOOL ret;
 116
 117     backupW = SERV_dup(lpBackupFileName);
 118     ret = ClearEventLogW(hEventLog, backupW);
 119     HeapFree(GetProcessHeap(), 0, backupW);
 120
 121     return ret;
 122 }
 123
 124 /******************************************************************************
 125  * ClearEventLogW [ADVAPI32.@]
 126  *
 127  * See ClearEventLogA.
 128  */
 129 BOOL WINAPI ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
 130 {
 131     FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
 132
 133     if (!hEventLog)
 134     {
 135         SetLastError(ERROR_INVALID_HANDLE);
 136         return FALSE;
 137     }
 138
 139     return TRUE;
 140 }
 141
 142 /******************************************************************************
 143  * CloseEventLog [ADVAPI32.@]
 144  *
 145  * Closes a read handle to the event log.
 146  *
 147  * PARAMS
 148  *  hEventLog [I/O] Handle of the event log to close.
 149  *
 150  * RETURNS
 151  *  Success: nonzero
 152  *  Failure: zero
 153  */
 154 BOOL WINAPI CloseEventLog( HANDLE hEventLog )
 155 {
 156     FIXME("(%p) stub\n", hEventLog);
 157
 158     if (!hEventLog)
 159     {
 160         SetLastError(ERROR_INVALID_HANDLE);
 161         return FALSE;
 162     }
 163
 164     return TRUE;
 165 }
 166
 167 /******************************************************************************
 168  * ControlTraceW [ADVAPI32.@]
 169  *
 170  * Control a givel event trace session
 171  *
 172  */
 173 ULONG WINAPI ControlTraceW( TRACEHANDLE hSession, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 174 {
 175     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_w(SessionName), Properties, control);
 176     return ERROR_SUCCESS;
 177 }
 178
 179 /******************************************************************************
 180  * ControlTraceA [ADVAPI32.@]
 181  *
 182  * See ControlTraceW.
 183  *
 184  */
 185 ULONG WINAPI ControlTraceA( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 186 {
 187     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_a(SessionName), Properties, control);
 188     return ERROR_SUCCESS;
 189 }
 190
 191 /******************************************************************************
 192  * FlushTraceA [ADVAPI32.@]
 193  */
 194 ULONG WINAPI FlushTraceA ( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 195 {
 196     return ControlTraceA( hSession, SessionName, Properties, EVENT_TRACE_CONTROL_FLUSH );
 197 }
 198
 199 /******************************************************************************
 200  * FlushTraceW [ADVAPI32.@]
 201  */
 202 ULONG WINAPI FlushTraceW ( TRACEHANDLE hSession, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 203 {
 204     return ControlTraceW( hSession, SessionName, Properties, EVENT_TRACE_CONTROL_FLUSH );
 205 }
 206
 207
 208 /******************************************************************************
 209  * DeregisterEventSource [ADVAPI32.@]
 210  *
 211  * Closes a write handle to an event log
 212  *
 213  * PARAMS
 214  *  hEventLog [I/O] Handle of the event log.
 215  *
 216  * RETURNS
 217  *  Success: nonzero
 218  *  Failure: zero
 219  */
 220 BOOL WINAPI DeregisterEventSource( HANDLE hEventLog )
 221 {
 222     FIXME("(%p) stub\n", hEventLog);
 223     return TRUE;
 224 }
 225
 226 /******************************************************************************
 227  * EnableTraceEx [ADVAPI32.@]
 228  */
 229 ULONG WINAPI EnableTraceEx( LPCGUID provider, LPCGUID source, TRACEHANDLE hSession, ULONG enable,
 230                             UCHAR level, ULONGLONG anykeyword, ULONGLONG allkeyword, ULONG enableprop,
 231                             PEVENT_FILTER_DESCRIPTOR filterdesc )
 232 {
 233     FIXME("(%s, %s, %s, %d, %c, %s, %s, %d, %p): stub\n", debugstr_guid(provider),
 234             debugstr_guid(source), wine_dbgstr_longlong(hSession), enable, level,
 235             wine_dbgstr_longlong(anykeyword), wine_dbgstr_longlong(allkeyword),
 236             enableprop, filterdesc);
 237
 238     return ERROR_SUCCESS;
 239 }
 240
 241 /******************************************************************************
 242  * EnableTrace [ADVAPI32.@]
 243  */
 244 ULONG WINAPI EnableTrace( ULONG enable, ULONG flag, ULONG level, LPCGUID guid, TRACEHANDLE hSession )
 245 {
 246     FIXME("(%d, 0x%x, %d, %s, %s): stub\n", enable, flag, level,
 247             debugstr_guid(guid), wine_dbgstr_longlong(hSession));
 248
 249     return ERROR_SUCCESS;
 250 }
 251
 252 /******************************************************************************
 253  * GetEventLogInformation [ADVAPI32.@]
 254  *
 255  * Retrieve some information about an event log.
 256  *
 257  * PARAMS
 258  *  hEventLog      [I]   Handle to an open event log.
 259  *  dwInfoLevel    [I]   Level of information (only EVENTLOG_FULL_INFO)
 260  *  lpBuffer       [I/O] The buffer for the returned information
 261  *  cbBufSize      [I]   The size of the buffer
 262  *  pcbBytesNeeded [O]   The needed bytes to hold the information
 263  *
 264  * RETURNS
 265  *  Success: TRUE. lpBuffer will hold the information and pcbBytesNeeded shows
 266  *           the needed buffer size.
 267  *  Failure: FALSE.
 268  */
 269 BOOL WINAPI GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
 270 {
 271     EVENTLOG_FULL_INFORMATION *efi;
 272
 273     FIXME("(%p, %d, %p, %d, %p) stub\n", hEventLog, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 274
 275     if (dwInfoLevel != EVENTLOG_FULL_INFO)
 276     {
 277         SetLastError(ERROR_INVALID_LEVEL);
 278         return FALSE;
 279     }
 280
 281     if (!hEventLog)
 282     {
 283         SetLastError(ERROR_INVALID_HANDLE);
 284         return FALSE;
 285     }
 286
 287     if (!lpBuffer || !pcbBytesNeeded)
 288     {
 289         /* FIXME: This will be handled properly when eventlog is moved
 290          * to a higher level
 291          */
 292         SetLastError(RPC_X_NULL_REF_POINTER);
 293         return FALSE;
 294     }
 295
 296     *pcbBytesNeeded = sizeof(EVENTLOG_FULL_INFORMATION);
 297     if (cbBufSize < sizeof(EVENTLOG_FULL_INFORMATION))
 298     {
 299         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 300         return FALSE;
 301     }
 302
 303     /* Pretend the log is not full */
 304     efi = (EVENTLOG_FULL_INFORMATION *)lpBuffer;
 305     efi->dwFull = 0;
 306
 307     return TRUE;
 308 }
 309
 310 /******************************************************************************
 311  * GetNumberOfEventLogRecords [ADVAPI32.@]
 312  *
 313  * Retrieves the number of records in an event log.
 314  *
 315  * PARAMS
 316  *  hEventLog       [I] Handle to an open event log.
 317  *  NumberOfRecords [O] Number of records in the log.
 318  *
 319  * RETURNS
 320  *  Success: nonzero. NumberOfRecords will contain the number of records in
 321  *           the log.
 322  *  Failure: zero
 323  */
 324 BOOL WINAPI GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
 325 {
 326     FIXME("(%p,%p) stub\n", hEventLog, NumberOfRecords);
 327
 328     if (!NumberOfRecords)
 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     *NumberOfRecords = 0;
 341
 342     return TRUE;
 343 }
 344
 345 /******************************************************************************
 346  * GetOldestEventLogRecord [ADVAPI32.@]
 347  *
 348  * Retrieves the absolute record number of the oldest record in an even log.
 349  *
 350  * PARAMS
 351  *  hEventLog    [I] Handle to an open event log.
 352  *  OldestRecord [O] Absolute record number of the oldest record.
 353  *
 354  * RETURNS
 355  *  Success: nonzero. OldestRecord contains the record number of the oldest
 356  *           record in the log.
 357  *  Failure: zero
 358  */
 359 BOOL WINAPI GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
 360 {
 361     FIXME("(%p,%p) stub\n", hEventLog, OldestRecord);
 362
 363     if (!OldestRecord)
 364     {
 365         SetLastError(ERROR_INVALID_PARAMETER);
 366         return FALSE;
 367     }
 368
 369     if (!hEventLog)
 370     {
 371         SetLastError(ERROR_INVALID_HANDLE);
 372         return FALSE;
 373     }
 374
 375     *OldestRecord = 0;
 376
 377     return TRUE;
 378 }
 379
 380 /******************************************************************************
 381  * GetTraceEnableFlags [ADVAPI32.@]
 382  */
 383 ULONG WINAPI GetTraceEnableFlags( TRACEHANDLE handle )
 384 {
 385     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 386     return 0;
 387 }
 388
 389 /******************************************************************************
 390  * GetTraceEnableLevel [ADVAPI32.@]
 391  */
 392 UCHAR WINAPI GetTraceEnableLevel( TRACEHANDLE handle )
 393 {
 394     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 395     return TRACE_LEVEL_VERBOSE;
 396 }
 397
 398 /******************************************************************************
 399  * GetTraceLoggerHandle [ADVAPI32.@]
 400  */
 401 TRACEHANDLE WINAPI GetTraceLoggerHandle( PVOID buf )
 402 {
 403     FIXME("(%p) stub\n", buf);
 404     SetLastError(ERROR_ACCESS_DENIED);
 405     return INVALID_PROCESSTRACE_HANDLE;
 406 }
 407
 408 /******************************************************************************
 409  * NotifyChangeEventLog [ADVAPI32.@]
 410  *
 411  * Enables an application to receive notification when an event is written
 412  * to an event log.
 413  *
 414  * PARAMS
 415  *  hEventLog [I] Handle to an event log.
 416  *  hEvent    [I] Handle to a manual-reset event object.
 417  *
 418  * RETURNS
 419  *  Success: nonzero
 420  *  Failure: zero
 421  */
 422 BOOL WINAPI NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
 423 {
 424         FIXME("(%p,%p) stub\n", hEventLog, hEvent);
 425         return TRUE;
 426 }
 427
 428 /******************************************************************************
 429  * OpenBackupEventLogA [ADVAPI32.@]
 430  *
 431  * Opens a handle to a backup event log.
 432  *
 433  * PARAMS
 434  *  lpUNCServerName [I] Universal Naming Convention name of the server on which
 435  *                      this will be performed.
 436  *  lpFileName      [I] Specifies the name of the backup file.
 437  *
 438  * RETURNS
 439  *  Success: Handle to the backup event log.
 440  *  Failure: NULL
 441  */
 442 HANDLE WINAPI OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
 443 {
 444     LPWSTR uncnameW, filenameW;
 445     HANDLE handle;
 446
 447     uncnameW = SERV_dup(lpUNCServerName);
 448     filenameW = SERV_dup(lpFileName);
 449     handle = OpenBackupEventLogW(uncnameW, filenameW);
 450     HeapFree(GetProcessHeap(), 0, uncnameW);
 451     HeapFree(GetProcessHeap(), 0, filenameW);
 452
 453     return handle;
 454 }
 455
 456 /******************************************************************************
 457  * OpenBackupEventLogW [ADVAPI32.@]
 458  *
 459  * See OpenBackupEventLogA.
 460  */
 461 HANDLE WINAPI OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
 462 {
 463     FIXME("(%s,%s) stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpFileName));
 464
 465     if (!lpFileName)
 466     {
 467         SetLastError(ERROR_INVALID_PARAMETER);
 468         return NULL;
 469     }
 470
 471     if (lpUNCServerName && lpUNCServerName[0])
 472     {
 473         FIXME("Remote server not supported\n");
 474         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 475         return NULL;
 476     }
 477
 478     if (GetFileAttributesW(lpFileName) == INVALID_FILE_ATTRIBUTES)
 479     {
 480         SetLastError(ERROR_FILE_NOT_FOUND);
 481         return NULL;
 482     }
 483
 484     return (HANDLE)0xcafe4242;
 485 }
 486
 487 /******************************************************************************
 488  * OpenEventLogA [ADVAPI32.@]
 489  *
 490  * Opens a handle to the specified event log.
 491  *
 492  * PARAMS
 493  *  lpUNCServerName [I] UNC name of the server on which the event log is
 494  *                      opened.
 495  *  lpSourceName    [I] Name of the log.
 496  *
 497  * RETURNS
 498  *  Success: Handle to an event log.
 499  *  Failure: NULL
 500  */
 501 HANDLE WINAPI OpenEventLogA( LPCSTR uncname, LPCSTR source )
 502 {
 503     LPWSTR uncnameW, sourceW;
 504     HANDLE handle;
 505
 506     uncnameW = SERV_dup(uncname);
 507     sourceW = SERV_dup(source);
 508     handle = OpenEventLogW(uncnameW, sourceW);
 509     HeapFree(GetProcessHeap(), 0, uncnameW);
 510     HeapFree(GetProcessHeap(), 0, sourceW);
 511
 512     return handle;
 513 }
 514
 515 /******************************************************************************
 516  * OpenEventLogW [ADVAPI32.@]
 517  *
 518  * See OpenEventLogA.
 519  */
 520 HANDLE WINAPI OpenEventLogW( LPCWSTR uncname, LPCWSTR source )
 521 {
 522     FIXME("(%s,%s) stub\n", debugstr_w(uncname), debugstr_w(source));
 523
 524     if (!source)
 525     {
 526         SetLastError(ERROR_INVALID_PARAMETER);
 527         return NULL;
 528     }
 529
 530     if (uncname && uncname[0])
 531     {
 532         FIXME("Remote server not supported\n");
 533         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 534         return NULL;
 535     }
 536
 537     return (HANDLE)0xcafe4242;
 538 }
 539
 540 /******************************************************************************
 541  * QueryAllTracesW [ADVAPI32.@]
 542  *
 543  * Query information for started event trace sessions
 544  *
 545  */
 546 ULONG WINAPI QueryAllTracesW( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 547 {
 548     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 549
 550     if (psessioncount) *psessioncount = 0;
 551     return ERROR_SUCCESS;
 552 }
 553
 554 /******************************************************************************
 555  * QueryAllTracesA [ADVAPI32.@]
 556  *
 557  * See QueryAllTracesW.
 558  */
 559 ULONG WINAPI QueryAllTracesA( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 560 {
 561     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 562
 563     if (psessioncount) *psessioncount = 0;
 564     return ERROR_SUCCESS;
 565 }
 566
 567 /******************************************************************************
 568  * ReadEventLogA [ADVAPI32.@]
 569  *
 570  * Reads a whole number of entries from an event log.
 571  *
 572  * PARAMS
 573  *  hEventLog                [I] Handle of the event log to read.
 574  *  dwReadFlags              [I] see MSDN doc.
 575  *  dwRecordOffset           [I] Log-entry record number to start at.
 576  *  lpBuffer                 [O] Buffer for the data read.
 577  *  nNumberOfBytesToRead     [I] Size of lpBuffer.
 578  *  pnBytesRead              [O] Receives number of bytes read.
 579  *  pnMinNumberOfBytesNeeded [O] Receives number of bytes required for the
 580  *                               next log entry.
 581  *
 582  * RETURNS
 583  *  Success: nonzero
 584  *  Failure: zero
 585  */
 586 BOOL WINAPI ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 587     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 588 {
 589     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 590           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 591
 592     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 593     return FALSE;
 594 }
 595
 596 /******************************************************************************
 597  * ReadEventLogW [ADVAPI32.@]
 598  *
 599  * See ReadEventLogA.
 600  */
 601 BOOL WINAPI ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 602     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 603 {
 604     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 605           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 606
 607     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 608     return FALSE;
 609 }
 610
 611 /******************************************************************************
 612  * RegisterEventSourceA [ADVAPI32.@]
 613  *
 614  * Returns a registered handle to an event log.
 615  *
 616  * PARAMS
 617  *  lpUNCServerName [I] UNC name of the source server.
 618  *  lpSourceName    [I] Specifies the name of the event source to retrieve.
 619  *
 620  * RETURNS
 621  *  Success: Handle to the event log.
 622  *  Failure: NULL. Returns ERROR_INVALID_HANDLE if lpSourceName specifies the
 623  *           Security event log.
 624  */
 625 HANDLE WINAPI RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
 626 {
 627     UNICODE_STRING lpUNCServerNameW;
 628     UNICODE_STRING lpSourceNameW;
 629     HANDLE ret;
 630
 631     FIXME("(%s,%s): stub\n", debugstr_a(lpUNCServerName), debugstr_a(lpSourceName));
 632
 633     RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW, lpUNCServerName);
 634     RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW, lpSourceName);
 635     ret = RegisterEventSourceW(lpUNCServerNameW.Buffer,lpSourceNameW.Buffer);
 636     RtlFreeUnicodeString (&lpUNCServerNameW);
 637     RtlFreeUnicodeString (&lpSourceNameW);
 638     return ret;
 639 }
 640
 641 /******************************************************************************
 642  * RegisterEventSourceW [ADVAPI32.@]
 643  *
 644  * See RegisterEventSourceA.
 645  */
 646 HANDLE WINAPI RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
 647 {
 648     FIXME("(%s,%s): stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
 649     return (HANDLE)0xcafe4242;
 650 }
 651
 652 /******************************************************************************
 653  * ReportEventA [ADVAPI32.@]
 654  *
 655  * Writes an entry at the end of an event log.
 656  *
 657  * PARAMS
 658  *  hEventLog   [I] Handle of an event log.
 659  *  wType       [I] See MSDN doc.
 660  *  wCategory   [I] Event category.
 661  *  dwEventID   [I] Event identifier.
 662  *  lpUserSid   [I] Current user's security identifier.
 663  *  wNumStrings [I] Number of insert strings in lpStrings.
 664  *  dwDataSize  [I] Size of event-specific raw data to write.
 665  *  lpStrings   [I] Buffer containing an array of string to be merged.
 666  *  lpRawData   [I] Buffer containing the binary data.
 667  *
 668  * RETURNS
 669  *  Success: nonzero. Entry was written to the log.
 670  *  Failure: zero.
 671  *
 672  * NOTES
 673  *  The ReportEvent function adds the time, the entry's length, and the
 674  *  offsets before storing the entry in the log. If lpUserSid != NULL, the
 675  *  username is also logged.
 676  */
 677 BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 678     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData)
 679 {
 680     LPWSTR *wideStrArray;
 681     UNICODE_STRING str;
 682     UINT i;
 683     BOOL ret;
 684
 685     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 686           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 687
 688     if (wNumStrings == 0) return TRUE;
 689     if (!lpStrings) return TRUE;
 690
 691     wideStrArray = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWSTR) * wNumStrings);
 692     for (i = 0; i < wNumStrings; i++)
 693     {
 694         RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
 695         wideStrArray[i] = str.Buffer;
 696     }
 697     ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
 698                        wNumStrings, dwDataSize, (LPCWSTR *)wideStrArray, lpRawData);
 699     for (i = 0; i < wNumStrings; i++)
 700     {
 701         HeapFree( GetProcessHeap(), 0, wideStrArray[i] );
 702     }
 703     HeapFree(GetProcessHeap(), 0, wideStrArray);
 704     return ret;
 705 }
 706
 707 /******************************************************************************
 708  * ReportEventW [ADVAPI32.@]
 709  *
 710  * See ReportEventA.
 711  */
 712 BOOL WINAPI ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 713     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData )
 714 {
 715     UINT i;
 716
 717     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 718           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 719
 720     /* partial stub */
 721
 722     if (wNumStrings == 0) return TRUE;
 723     if (!lpStrings) return TRUE;
 724
 725     for (i = 0; i < wNumStrings; i++)
 726     {
 727         switch (wType)
 728         {
 729         case EVENTLOG_SUCCESS:
 730             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 731             break;
 732         case EVENTLOG_ERROR_TYPE:
 733             ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 734             break;
 735         case EVENTLOG_WARNING_TYPE:
 736             WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 737             break;
 738         default:
 739             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 740             break;
 741         }
 742     }
 743     return TRUE;
 744 }
 745
 746 /******************************************************************************
 747  * RegisterTraceGuidsW [ADVAPI32.@]
 748  *
 749  * Register an event trace provider and the event trace classes that it uses
 750  * to generate events.
 751  *
 752  * PARAMS
 753  *  RequestAddress     [I]   ControlCallback function
 754  *  RequestContext     [I]   Optional provider-defined context
 755  *  ControlGuid        [I]   GUID of the registering provider
 756  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 757  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 758  *  MofImagePath       [I]   not supported, set to NULL
 759  *  MofResourceName    [I]   not supported, set to NULL
 760  *  RegistrationHandle [O]   Provider's registration handle
 761  *
 762  * RETURNS
 763  *  Success: ERROR_SUCCESS
 764  *  Failure: System error code
 765  *
 766  * FIXME
 767  *  Stub.
 768  */
 769 ULONG WINAPI RegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 770                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 771                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCWSTR MofImagePath,
 772                 LPCWSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 773 {
 774     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 775           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 776           debugstr_w(MofResourceName), RegistrationHandle);
 777     return ERROR_SUCCESS;
 778 }
 779
 780 /******************************************************************************
 781  * RegisterTraceGuidsA [ADVAPI32.@]
 782  *
 783  * See RegisterTraceGuidsW.
 784  *
 785  * FIXME
 786  *  Stub.
 787  */
 788 ULONG WINAPI RegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 789                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 790                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCSTR MofImagePath,
 791                 LPCSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 792 {
 793     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 794           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 795           debugstr_a(MofResourceName), RegistrationHandle);
 796     return ERROR_SUCCESS;
 797 }
 798
 799 /******************************************************************************
 800  * StartTraceW [ADVAPI32.@]
 801  *
 802  * Register and start an event trace session
 803  *
 804  */
 805 ULONG WINAPI StartTraceW( PTRACEHANDLE pSessionHandle, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 806 {
 807     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_w(SessionName), Properties);
 808     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 809     return ERROR_SUCCESS;
 810 }
 811
 812 /******************************************************************************
 813  * StartTraceA [ADVAPI32.@]
 814  *
 815  * See StartTraceW.
 816  *
 817  */
 818 ULONG WINAPI StartTraceA( PTRACEHANDLE pSessionHandle, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 819 {
 820     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_a(SessionName), Properties);
 821     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 822     return ERROR_SUCCESS;
 823 }
 824
 825 /******************************************************************************
 826  * StopTraceW [ADVAPI32.@]
 827  *
 828  * Stop an event trace session
 829  *
 830  */
 831 ULONG WINAPI StopTraceW( TRACEHANDLE session, LPCWSTR session_name, PEVENT_TRACE_PROPERTIES properties )
 832 {
 833     FIXME("(%s, %s, %p) stub\n", wine_dbgstr_longlong(session), debugstr_w(session_name), properties);
 834     return ERROR_SUCCESS;
 835 }
 836
 837 /******************************************************************************
 838  * StopTraceA [ADVAPI32.@]
 839  *
 840  * See StopTraceW.
 841  *
 842  */
 843 ULONG WINAPI StopTraceA( TRACEHANDLE session, LPCSTR session_name, PEVENT_TRACE_PROPERTIES properties )
 844 {
 845     FIXME("(%s, %s, %p) stub\n", wine_dbgstr_longlong(session), debugstr_a(session_name), properties);
 846     return ERROR_SUCCESS;
 847 }
 848
 849 /******************************************************************************
 850  * TraceEvent [ADVAPI32.@]
 851  */
 852 ULONG WINAPI TraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 853 {
 854     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 855     return ERROR_CALL_NOT_IMPLEMENTED;
 856 }
 857
 858 /******************************************************************************
 859  * UnregisterTraceGuids [ADVAPI32.@]
 860  *
 861  * See RegisterTraceGuids
 862  *
 863  * FIXME
 864  *  Stub.
 865  */
 866 ULONG WINAPI UnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 867 {
 868     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 869     return ERROR_CALL_NOT_IMPLEMENTED;
 870 }
 871
 872 /******************************************************************************
 873  * EventRegister [ADVAPI32.@]
 874  */
 875 ULONG WINAPI EventRegister( LPCGUID provider, PENABLECALLBACK callback, PVOID context, PREGHANDLE handle )
 876 {
 877     FIXME("%s, %p, %p, %p\n", debugstr_guid(provider), callback, context, handle);
 878
 879     *handle = 0xdeadbeef;
 880     return ERROR_SUCCESS;
 881 }
 882
 883 /******************************************************************************
 884  * EventUnregister [ADVAPI32.@]
 885  */
 886 ULONG WINAPI EventUnregister( REGHANDLE handle )
 887 {
 888     FIXME("%s: stub\n", wine_dbgstr_longlong(handle));
 889     return ERROR_SUCCESS;
 890 }
 891
 892 /******************************************************************************
 893  * EventEnabled [ADVAPI32.@]
 894  *
 895  */
 896 BOOLEAN WINAPI EventEnabled( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor )
 897 {
 898     FIXME("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor);
 899     return FALSE;
 900 }
 901
 902 /******************************************************************************
 903  * EventProviderEnabled [ADVAPI32.@]
 904  *
 905  */
 906 BOOLEAN WINAPI EventProviderEnabled( REGHANDLE handle, UCHAR level, ULONGLONG keyword )
 907 {
 908     FIXME("%s, %u, %s: stub\n", wine_dbgstr_longlong(handle), level, wine_dbgstr_longlong(keyword));
 909     return FALSE;
 910 }
 911
 912 /******************************************************************************
 913  * EventWrite [ADVAPI32.@]
 914  */
 915 ULONG WINAPI EventWrite( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor, ULONG count,
 916                          PEVENT_DATA_DESCRIPTOR data )
 917 {
 918     FIXME("%s, %p, %u, %p: stub\n", wine_dbgstr_longlong(handle), descriptor, count, data);
 919     return ERROR_SUCCESS;
 920 }
 921
 922 /******************************************************************************
 923  * QueryTraceW [ADVAPI32.@]
 924  */
 925 ULONG WINAPI QueryTraceW( TRACEHANDLE handle, LPCWSTR sessionname, PEVENT_TRACE_PROPERTIES properties )
 926 {
 927     FIXME("%s %s %p: stub\n", wine_dbgstr_longlong(handle), debugstr_w(sessionname), properties);
 928     return ERROR_CALL_NOT_IMPLEMENTED;
 929 }
 930
 931 /******************************************************************************
 932  * OpenTraceA [ADVAPI32.@]
 933  */
 934 TRACEHANDLE WINAPI OpenTraceA( PEVENT_TRACE_LOGFILEA logfile )
 935 {
 936     FIXME("%p: stub\n", logfile);
 937     SetLastError(ERROR_ACCESS_DENIED);
 938     return INVALID_PROCESSTRACE_HANDLE;
 939 }
 940
 941 /******************************************************************************
 942  * OpenTraceW [ADVAPI32.@]
 943  */
 944 TRACEHANDLE WINAPI OpenTraceW( PEVENT_TRACE_LOGFILEW logfile )
 945 {
 946     FIXME("%p: stub\n", logfile);
 947     SetLastError(ERROR_ACCESS_DENIED);
 948     return INVALID_PROCESSTRACE_HANDLE;
 949 }
 950
 951 /******************************************************************************
 952  * ProcessTrace [ADVAPI32.@]
 953  */
 954 ULONG WINAPI ProcessTrace( PTRACEHANDLE HandleArray, ULONG HandleCount, LPFILETIME StartTime, LPFILETIME EndTime)
 955 {
 956     FIXME("%p %u %p %p: stub\n", HandleArray, HandleCount, StartTime, EndTime);
 957     return ERROR_CALL_NOT_IMPLEMENTED;
 958 }
 959
 960 /******************************************************************************
 961  * TraceMessage [ADVAPI32.@]
 962  */
 963 ULONG WINAPIV TraceMessage( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number, ... )
 964 {
 965     __ms_va_list valist;
 966     ULONG ret;
 967
 968     __ms_va_start( valist, number );
 969     ret = TraceMessageVa( handle, flags, guid, number, valist );
 970     __ms_va_end( valist );
 971     return ret;
 972 }
 973
 974 /******************************************************************************
 975  * TraceMessageVa [ADVAPI32.@]
 976  */
 977 ULONG WINAPI TraceMessageVa( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number,
 978                             __ms_va_list args )
 979 {
 980     FIXME("(%s %x %s %d) : stub\n", wine_dbgstr_longlong(handle), flags, debugstr_guid(guid), number);
 981     return ERROR_SUCCESS;
 982 }
 983
 984 /******************************************************************************
 985  * CloseTrace [ADVAPI32.@]
 986  */
 987 ULONG WINAPI CloseTrace( TRACEHANDLE handle )
 988 {
 989     FIXME("%s: stub\n", wine_dbgstr_longlong(handle));
 990     return ERROR_INVALID_HANDLE;
 991 }
 992
 993 /******************************************************************************
 994  * EnumerateTraceGuids [ADVAPI32.@]
 995  */
 996 ULONG WINAPI EnumerateTraceGuids(PTRACE_GUID_PROPERTIES *propertiesarray,
 997                                  ULONG arraycount, PULONG guidcount)
 998 {
 999     FIXME("%p %d %p: stub\n", propertiesarray, arraycount, guidcount);
1000     return ERROR_INVALID_PARAMETER;
1001 }