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         FIXME("(%p,%s) stub\n", hEventLog, debugstr_a(lpBackupFileName));
  68         return TRUE;
  69 }
  70
  71 /******************************************************************************
  72  * BackupEventLogW [ADVAPI32.@]
  73  *
  74  * See BackupEventLogA.
  75  */
  76 BOOL WINAPI BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
  77 {
  78         FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
  79         return TRUE;
  80 }
  81
  82 /******************************************************************************
  83  * ClearEventLogA [ADVAPI32.@]
  84  *
  85  * Clears the event log and/or saves the log to a backup file.
  86  *
  87  * PARAMS
  88  *  hEvenLog         [I] Handle to event log to clear.
  89  *  lpBackupFileName [I] Name of the backup file.
  90  *
  91  * RETURNS
  92  *  Success: nonzero. if lpBackupFileName != NULL, lpBackupFileName will
  93  *           contain the contents of hEvenLog and the log will be cleared.
  94  *  Failure: zero. Fails if the event log is empty or if lpBackupFileName
  95  *           exists.
  96  */
  97 BOOL WINAPI ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
  98 {
  99         FIXME("(%p,%s) stub\n", hEventLog, debugstr_a(lpBackupFileName));
 100         return TRUE;
 101 }
 102
 103 /******************************************************************************
 104  * ClearEventLogW [ADVAPI32.@]
 105  *
 106  * See ClearEventLogA.
 107  */
 108 BOOL WINAPI ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
 109 {
 110         FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
 111         return TRUE;
 112 }
 113
 114 /******************************************************************************
 115  * CloseEventLog [ADVAPI32.@]
 116  *
 117  * Closes a read handle to the event log.
 118  *
 119  * PARAMS
 120  *  hEventLog [I/O] Handle of the event log to close.
 121  *
 122  * RETURNS
 123  *  Success: nonzero
 124  *  Failure: zero
 125  */
 126 BOOL WINAPI CloseEventLog( HANDLE hEventLog )
 127 {
 128         FIXME("(%p) stub\n", hEventLog);
 129         return TRUE;
 130 }
 131
 132 /******************************************************************************
 133  * ControlTraceW [ADVAPI32.@]
 134  *
 135  * Control a givel event trace session
 136  *
 137  */
 138 ULONG WINAPI ControlTraceW( TRACEHANDLE hSession, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 139 {
 140     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_w(SessionName), Properties, control);
 141     return ERROR_SUCCESS;
 142 }
 143
 144 /******************************************************************************
 145  * ControlTraceA [ADVAPI32.@]
 146  *
 147  * See ControlTraceW.
 148  *
 149  */
 150 ULONG WINAPI ControlTraceA( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control )
 151 {
 152     FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_a(SessionName), Properties, control);
 153     return ERROR_SUCCESS;
 154 }
 155
 156 /******************************************************************************
 157  * DeregisterEventSource [ADVAPI32.@]
 158  *
 159  * Closes a write handle to an event log
 160  *
 161  * PARAMS
 162  *  hEventLog [I/O] Handle of the event log.
 163  *
 164  * RETURNS
 165  *  Success: nonzero
 166  *  Failure: zero
 167  */
 168 BOOL WINAPI DeregisterEventSource( HANDLE hEventLog )
 169 {
 170     FIXME("(%p) stub\n", hEventLog);
 171     return TRUE;
 172 }
 173
 174 /******************************************************************************
 175  * EnableTrace [ADVAPI32.@]
 176  */
 177 ULONG WINAPI EnableTrace( ULONG enable, ULONG flag, ULONG level, LPCGUID guid, TRACEHANDLE hSession )
 178 {
 179     FIXME("(%d, 0x%x, %d, %s, %s): stub\n", enable, flag, level,
 180             debugstr_guid(guid), wine_dbgstr_longlong(hSession));
 181
 182     return ERROR_SUCCESS;
 183 }
 184
 185 /******************************************************************************
 186  * GetNumberOfEventLogRecords [ADVAPI32.@]
 187  *
 188  * Retrieves the number of records in an event log.
 189  *
 190  * PARAMS
 191  *  hEventLog       [I] Handle to an open event log.
 192  *  NumberOfRecords [O] Number of records in the log.
 193  *
 194  * RETURNS
 195  *  Success: nonzero. NumberOfRecords will contain the number of records in
 196  *           the log.
 197  *  Failure: zero
 198  */
 199 BOOL WINAPI GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
 200 {
 201     FIXME("(%p,%p) stub\n", hEventLog, NumberOfRecords);
 202
 203     if (!NumberOfRecords) return FALSE;
 204     *NumberOfRecords = 0;
 205
 206     return TRUE;
 207 }
 208
 209 /******************************************************************************
 210  * GetOldestEventLogRecord [ADVAPI32.@]
 211  *
 212  * Retrieves the absolute record number of the oldest record in an even log.
 213  *
 214  * PARAMS
 215  *  hEventLog    [I] Handle to an open event log.
 216  *  OldestRecord [O] Absolute record number of the oldest record.
 217  *
 218  * RETURNS
 219  *  Success: nonzero. OldestRecord contains the record number of the oldest
 220  *           record in the log.
 221  *  Failure: zero
 222  */
 223 BOOL WINAPI GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
 224 {
 225     FIXME("(%p,%p) stub\n", hEventLog, OldestRecord);
 226
 227     if (!OldestRecord) return FALSE;
 228     *OldestRecord = 0;
 229
 230     return TRUE;
 231 }
 232
 233 /******************************************************************************
 234  * NotifyChangeEventLog [ADVAPI32.@]
 235  *
 236  * Enables an application to receive notification when an event is written
 237  * to an event log.
 238  *
 239  * PARAMS
 240  *  hEventLog [I] Handle to an event log.
 241  *  hEvent    [I] Handle to a manual-reset event object.
 242  *
 243  * RETURNS
 244  *  Success: nonzero
 245  *  Failure: zero
 246  */
 247 BOOL WINAPI NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
 248 {
 249         FIXME("(%p,%p) stub\n", hEventLog, hEvent);
 250         return TRUE;
 251 }
 252
 253 /******************************************************************************
 254  * OpenBackupEventLogA [ADVAPI32.@]
 255  *
 256  * Opens a handle to a backup event log.
 257  *
 258  * PARAMS
 259  *  lpUNCServerName [I] Universal Naming Convention name of the server on which
 260  *                      this will be performed.
 261  *  lpFileName      [I] Specifies the name of the backup file.
 262  *
 263  * RETURNS
 264  *  Success: Handle to the backup event log.
 265  *  Failure: NULL
 266  */
 267 HANDLE WINAPI OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
 268 {
 269         FIXME("(%s,%s) stub\n", debugstr_a(lpUNCServerName), debugstr_a(lpFileName));
 270         return (HANDLE)0xcafe4242;
 271 }
 272
 273 /******************************************************************************
 274  * OpenBackupEventLogW [ADVAPI32.@]
 275  *
 276  * See OpenBackupEventLogA.
 277  */
 278 HANDLE WINAPI OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
 279 {
 280         FIXME("(%s,%s) stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpFileName));
 281         return (HANDLE)0xcafe4242;
 282 }
 283
 284 /******************************************************************************
 285  * OpenEventLogA [ADVAPI32.@]
 286  *
 287  * Opens a handle to the specified event log.
 288  *
 289  * PARAMS
 290  *  lpUNCServerName [I] UNC name of the server on which the event log is
 291  *                      opened.
 292  *  lpSourceName    [I] Name of the log.
 293  *
 294  * RETURNS
 295  *  Success: Handle to an event log.
 296  *  Failure: NULL
 297  */
 298 HANDLE WINAPI OpenEventLogA( LPCSTR uncname, LPCSTR source )
 299 {
 300     LPWSTR uncnameW, sourceW;
 301     HANDLE handle;
 302
 303     uncnameW = SERV_dup(uncname);
 304     sourceW = SERV_dup(source);
 305     handle = OpenEventLogW(uncnameW, sourceW);
 306     HeapFree(GetProcessHeap(), 0, uncnameW);
 307     HeapFree(GetProcessHeap(), 0, sourceW);
 308
 309     return handle;
 310 }
 311
 312 /******************************************************************************
 313  * OpenEventLogW [ADVAPI32.@]
 314  *
 315  * See OpenEventLogA.
 316  */
 317 HANDLE WINAPI OpenEventLogW( LPCWSTR uncname, LPCWSTR source )
 318 {
 319     FIXME("(%s,%s) stub\n", debugstr_w(uncname), debugstr_w(source));
 320
 321     if (!source)
 322     {
 323         SetLastError(ERROR_INVALID_PARAMETER);
 324         return NULL;
 325     }
 326
 327     if (uncname && uncname[0])
 328     {
 329         FIXME("Remote server not supported\n");
 330         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 331         return NULL;
 332     }
 333
 334     return (HANDLE)0xcafe4242;
 335 }
 336
 337 /******************************************************************************
 338  * QueryAllTracesW [ADVAPI32.@]
 339  *
 340  * Query informations for started event trace sessions
 341  *
 342  */
 343 ULONG WINAPI QueryAllTracesW( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 344 {
 345     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 346
 347     if (psessioncount) *psessioncount = 0;
 348     return ERROR_SUCCESS;
 349 }
 350
 351 /******************************************************************************
 352  * QueryAllTracesA [ADVAPI32.@]
 353  *
 354  * See QueryAllTracesW.
 355  */
 356 ULONG WINAPI QueryAllTracesA( PEVENT_TRACE_PROPERTIES * parray, ULONG arraycount, PULONG psessioncount )
 357 {
 358     FIXME("(%p, %d, %p) stub\n", parray, arraycount, psessioncount);
 359
 360     if (psessioncount) *psessioncount = 0;
 361     return ERROR_SUCCESS;
 362 }
 363
 364 /******************************************************************************
 365  * ReadEventLogA [ADVAPI32.@]
 366  *
 367  * Reads a whole number of entries from an event log.
 368  *
 369  * PARAMS
 370  *  hEventLog                [I] Handle of the event log to read.
 371  *  dwReadFlags              [I] see MSDN doc.
 372  *  dwRecordOffset           [I] Log-entry record number to start at.
 373  *  lpBuffer                 [O] Buffer for the data read.
 374  *  nNumberOfBytesToRead     [I] Size of lpBuffer.
 375  *  pnBytesRead              [O] Receives number of bytes read.
 376  *  pnMinNumberOfBytesNeeded [O] Receives number of bytes required for the
 377  *                               next log entry.
 378  *
 379  * RETURNS
 380  *  Success: nonzero
 381  *  Failure: zero
 382  */
 383 BOOL WINAPI ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 384     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 385 {
 386     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 387           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 388     return FALSE;
 389 }
 390
 391 /******************************************************************************
 392  * ReadEventLogW [ADVAPI32.@]
 393  *
 394  * See ReadEventLogA.
 395  */
 396 BOOL WINAPI ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 397     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 398 {
 399     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 400           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 401     return FALSE;
 402 }
 403
 404 /******************************************************************************
 405  * RegisterEventSourceA [ADVAPI32.@]
 406  *
 407  * Returns a registered handle to an event log.
 408  *
 409  * PARAMS
 410  *  lpUNCServerName [I] UNC name of the source server.
 411  *  lpSourceName    [I] Specifies the name of the event source to retrieve.
 412  *
 413  * RETURNS
 414  *  Success: Handle to the event log.
 415  *  Failure: NULL. Returns ERROR_INVALID_HANDLE if lpSourceName specifies the
 416  *           Security event log.
 417  */
 418 HANDLE WINAPI RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
 419 {
 420     UNICODE_STRING lpUNCServerNameW;
 421     UNICODE_STRING lpSourceNameW;
 422     HANDLE ret;
 423
 424     FIXME("(%s,%s): stub\n", debugstr_a(lpUNCServerName), debugstr_a(lpSourceName));
 425
 426     RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW, lpUNCServerName);
 427     RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW, lpSourceName);
 428     ret = RegisterEventSourceW(lpUNCServerNameW.Buffer,lpSourceNameW.Buffer);
 429     RtlFreeUnicodeString (&lpUNCServerNameW);
 430     RtlFreeUnicodeString (&lpSourceNameW);
 431     return ret;
 432 }
 433
 434 /******************************************************************************
 435  * RegisterEventSourceW [ADVAPI32.@]
 436  *
 437  * See RegisterEventSourceA.
 438  */
 439 HANDLE WINAPI RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
 440 {
 441     FIXME("(%s,%s): stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
 442     return (HANDLE)0xcafe4242;
 443 }
 444
 445 /******************************************************************************
 446  * ReportEventA [ADVAPI32.@]
 447  *
 448  * Writes an entry at the end of an event log.
 449  *
 450  * PARAMS
 451  *  hEventLog   [I] Handle of an event log.
 452  *  wType       [I] See MSDN doc.
 453  *  wCategory   [I] Event category.
 454  *  dwEventID   [I] Event identifier.
 455  *  lpUserSid   [I] Current user's security identifier.
 456  *  wNumStrings [I] Number of insert strings in lpStrings.
 457  *  dwDataSize  [I] Size of event-specific raw data to write.
 458  *  lpStrings   [I] Buffer containing an array of string to be merged.
 459  *  lpRawData   [I] Buffer containing the binary data.
 460  *
 461  * RETURNS
 462  *  Success: nonzero. Entry was written to the log.
 463  *  Failure: zero.
 464  *
 465  * NOTES
 466  *  The ReportEvent function adds the time, the entry's length, and the
 467  *  offsets before storing the entry in the log. If lpUserSid != NULL, the
 468  *  username is also logged.
 469  */
 470 BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 471     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData)
 472 {
 473     LPWSTR *wideStrArray;
 474     UNICODE_STRING str;
 475     int i;
 476     BOOL ret;
 477
 478     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 479           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 480
 481     if (wNumStrings == 0) return TRUE;
 482     if (!lpStrings) return TRUE;
 483
 484     wideStrArray = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWSTR) * wNumStrings);
 485     for (i = 0; i < wNumStrings; i++)
 486     {
 487         RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
 488         wideStrArray[i] = str.Buffer;
 489     }
 490     ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
 491                        wNumStrings, dwDataSize, (LPCWSTR *)wideStrArray, lpRawData);
 492     for (i = 0; i < wNumStrings; i++)
 493     {
 494         HeapFree( GetProcessHeap(), 0, wideStrArray[i] );
 495     }
 496     HeapFree(GetProcessHeap(), 0, wideStrArray);
 497     return ret;
 498 }
 499
 500 /******************************************************************************
 501  * ReportEventW [ADVAPI32.@]
 502  *
 503  * See ReportEventA.
 504  */
 505 BOOL WINAPI ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 506     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData )
 507 {
 508     int i;
 509
 510     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 511           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 512
 513     /* partial stub */
 514
 515     if (wNumStrings == 0) return TRUE;
 516     if (!lpStrings) return TRUE;
 517
 518     for (i = 0; i < wNumStrings; i++)
 519     {
 520         switch (wType)
 521         {
 522         case EVENTLOG_SUCCESS:
 523             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 524             break;
 525         case EVENTLOG_ERROR_TYPE:
 526             ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 527             break;
 528         case EVENTLOG_WARNING_TYPE:
 529             WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 530             break;
 531         default:
 532             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 533             break;
 534         }
 535     }
 536     return TRUE;
 537 }
 538
 539 /******************************************************************************
 540  * RegisterTraceGuidsW [ADVAPI32.@]
 541  *
 542  * Register an event trace provider and the event trace classes that it uses
 543  * to generate events.
 544  *
 545  * PARAMS
 546  *  RequestAddress     [I]   ControlCallback function
 547  *  RequestContext     [I]   Optional provider-defined context
 548  *  ControlGuid        [I]   GUID of the registering provider
 549  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 550  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 551  *  MofImagePath       [I]   not supported, set to NULL
 552  *  MofResourceNmae    [I]   not supported, set to NULL
 553  *  RegistrationHandle [O]   Provider's registration handle
 554  *
 555  * RETURNS
 556  *  Success: ERROR_SUCCESS
 557  *  Failure: System error code
 558  *
 559  * FIXME
 560  *  Stub.
 561  */
 562 ULONG WINAPI RegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 563                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 564                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCWSTR MofImagePath,
 565                 LPCWSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 566 {
 567     FIXME("%p %p %p %u %p %s %s %p\n", RequestAddress, RequestContext,
 568           ControlGuid, GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 569           debugstr_w(MofResourceName), RegistrationHandle);
 570     return ERROR_CALL_NOT_IMPLEMENTED;
 571 }
 572
 573 /******************************************************************************
 574  * RegisterTraceGuidsA [ADVAPI32.@]
 575  *
 576  * See RegisterTraceGuidsW.
 577  *
 578  * FIXME
 579  *  Stub.
 580  */
 581 ULONG WINAPI RegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 582                 PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount,
 583                 PTRACE_GUID_REGISTRATION TraceGuidReg, LPCSTR MofImagePath,
 584                 LPCSTR MofResourceName, PTRACEHANDLE RegistrationHandle )
 585 {
 586     FIXME("%p %p %p %u %p %s %s %p\n", RequestAddress, RequestContext,
 587           ControlGuid, GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 588           debugstr_a(MofResourceName), RegistrationHandle);
 589     return ERROR_CALL_NOT_IMPLEMENTED;
 590 }
 591
 592 /******************************************************************************
 593  * StartTraceW [ADVAPI32.@]
 594  *
 595  * Register and start an event trace session
 596  *
 597  */
 598 ULONG WINAPI StartTraceW( PTRACEHANDLE pSessionHandle, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 599 {
 600     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_w(SessionName), Properties);
 601     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 602     return ERROR_SUCCESS;
 603 }
 604
 605 /******************************************************************************
 606  * StartTraceA [ADVAPI32.@]
 607  *
 608  * See StartTraceW.
 609  *
 610  */
 611 ULONG WINAPI StartTraceA( PTRACEHANDLE pSessionHandle, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 612 {
 613     FIXME("(%p, %s, %p) stub\n", pSessionHandle, debugstr_a(SessionName), Properties);
 614     if (pSessionHandle) *pSessionHandle = 0xcafe4242;
 615     return ERROR_SUCCESS;
 616 }
 617
 618 /******************************************************************************
 619  * TraceEvent [ADVAPI32.@]
 620  */
 621 ULONG WINAPI TraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 622 {
 623     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 624     return ERROR_CALL_NOT_IMPLEMENTED;
 625 }
 626
 627 /******************************************************************************
 628  * UnregisterTraceGuids [ADVAPI32.@]
 629  *
 630  * See RegisterTraceGuids
 631  *
 632  * FIXME
 633  *  Stub.
 634  */
 635 ULONG WINAPI UnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 636 {
 637     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 638     return ERROR_CALL_NOT_IMPLEMENTED;
 639 }