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/debug.h"
  34
  35 #include "advapi32_misc.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  38 WINE_DECLARE_DEBUG_CHANNEL(eventlog);
  39
  40 /******************************************************************************
  41  * BackupEventLogA [ADVAPI32.@]
  42  *
  43  * Saves the event log to a backup file.
  44  *
  45  * PARAMS
  46  *  hEventLog        [I] Handle to event log to backup.
  47  *  lpBackupFileName [I] Name of the backup file.
  48  *
  49  * RETURNS
  50  *  Success: nonzero. File lpBackupFileName will contain the contents of
  51  *           hEvenLog.
  52  *  Failure: zero.
  53  */
  54 BOOL WINAPI BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
  55 {
  56     LPWSTR backupW;
  57     BOOL ret;
  58
  59     backupW = strdupAW(lpBackupFileName);
  60     ret = BackupEventLogW(hEventLog, backupW);
  61     heap_free(backupW);
  62
  63     return ret;
  64 }
  65
  66 /******************************************************************************
  67  * BackupEventLogW [ADVAPI32.@]
  68  *
  69  * See BackupEventLogA.
  70  */
  71 BOOL WINAPI BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
  72 {
  73     FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
  74
  75     if (!lpBackupFileName)
  76     {
  77         SetLastError(ERROR_INVALID_PARAMETER);
  78         return FALSE;
  79     }
  80
  81     if (!hEventLog)
  82     {
  83         SetLastError(ERROR_INVALID_HANDLE);
  84         return FALSE;
  85     }
  86
  87     if (GetFileAttributesW(lpBackupFileName) != INVALID_FILE_ATTRIBUTES)
  88     {
  89         SetLastError(ERROR_ALREADY_EXISTS);
  90         return FALSE;
  91     }
  92
  93     return TRUE;
  94 }
  95
  96 /******************************************************************************
  97  * ClearEventLogA [ADVAPI32.@]
  98  *
  99  * Clears the event log and optionally saves the log to a backup file.
 100  *
 101  * PARAMS
 102  *  hEvenLog         [I] Handle to event log to clear.
 103  *  lpBackupFileName [I] Name of the backup file.
 104  *
 105  * RETURNS
 106  *  Success: nonzero. if lpBackupFileName != NULL, lpBackupFileName will
 107  *           contain the contents of hEvenLog and the log will be cleared.
 108  *  Failure: zero. Fails if the event log is empty or if lpBackupFileName
 109  *           exists.
 110  */
 111 BOOL WINAPI ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
 112 {
 113     LPWSTR backupW;
 114     BOOL ret;
 115
 116     backupW = strdupAW(lpBackupFileName);
 117     ret = ClearEventLogW(hEventLog, backupW);
 118     heap_free(backupW);
 119
 120     return ret;
 121 }
 122
 123 /******************************************************************************
 124  * ClearEventLogW [ADVAPI32.@]
 125  *
 126  * See ClearEventLogA.
 127  */
 128 BOOL WINAPI ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
 129 {
 130     FIXME("(%p,%s) stub\n", hEventLog, debugstr_w(lpBackupFileName));
 131
 132     if (!hEventLog)
 133     {
 134         SetLastError(ERROR_INVALID_HANDLE);
 135         return FALSE;
 136     }
 137
 138     return TRUE;
 139 }
 140
 141 /******************************************************************************
 142  * CloseEventLog [ADVAPI32.@]
 143  *
 144  * Closes a read handle to the event log.
 145  *
 146  * PARAMS
 147  *  hEventLog [I/O] Handle of the event log to close.
 148  *
 149  * RETURNS
 150  *  Success: nonzero
 151  *  Failure: zero
 152  */
 153 BOOL WINAPI CloseEventLog( HANDLE hEventLog )
 154 {
 155     FIXME("(%p) stub\n", hEventLog);
 156
 157     if (!hEventLog)
 158     {
 159         SetLastError(ERROR_INVALID_HANDLE);
 160         return FALSE;
 161     }
 162
 163     return TRUE;
 164 }
 165
 166 /******************************************************************************
 167  * FlushTraceA [ADVAPI32.@]
 168  */
 169 ULONG WINAPI FlushTraceA ( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 170 {
 171     return ControlTraceA( hSession, SessionName, Properties, EVENT_TRACE_CONTROL_FLUSH );
 172 }
 173
 174 /******************************************************************************
 175  * FlushTraceW [ADVAPI32.@]
 176  */
 177 ULONG WINAPI FlushTraceW ( TRACEHANDLE hSession, LPCWSTR SessionName, PEVENT_TRACE_PROPERTIES Properties )
 178 {
 179     return ControlTraceW( hSession, SessionName, Properties, EVENT_TRACE_CONTROL_FLUSH );
 180 }
 181
 182
 183 /******************************************************************************
 184  * DeregisterEventSource [ADVAPI32.@]
 185  *
 186  * Closes a write handle to an event log
 187  *
 188  * PARAMS
 189  *  hEventLog [I/O] Handle of the event log.
 190  *
 191  * RETURNS
 192  *  Success: nonzero
 193  *  Failure: zero
 194  */
 195 BOOL WINAPI DeregisterEventSource( HANDLE hEventLog )
 196 {
 197     FIXME("(%p) stub\n", hEventLog);
 198     return TRUE;
 199 }
 200
 201 /******************************************************************************
 202  * EnableTraceEx [ADVAPI32.@]
 203  */
 204 ULONG WINAPI EnableTraceEx( LPCGUID provider, LPCGUID source, TRACEHANDLE hSession, ULONG enable,
 205                             UCHAR level, ULONGLONG anykeyword, ULONGLONG allkeyword, ULONG enableprop,
 206                             PEVENT_FILTER_DESCRIPTOR filterdesc )
 207 {
 208     FIXME("(%s, %s, %s, %u, %u, %s, %s, %u, %p): stub\n", debugstr_guid(provider),
 209             debugstr_guid(source), wine_dbgstr_longlong(hSession), enable, level,
 210             wine_dbgstr_longlong(anykeyword), wine_dbgstr_longlong(allkeyword),
 211             enableprop, filterdesc);
 212
 213     return ERROR_SUCCESS;
 214 }
 215
 216 /******************************************************************************
 217  * EnableTrace [ADVAPI32.@]
 218  */
 219 ULONG WINAPI EnableTrace( ULONG enable, ULONG flag, ULONG level, LPCGUID guid, TRACEHANDLE hSession )
 220 {
 221     FIXME("(%d, 0x%x, %d, %s, %s): stub\n", enable, flag, level,
 222             debugstr_guid(guid), wine_dbgstr_longlong(hSession));
 223
 224     return ERROR_SUCCESS;
 225 }
 226
 227 /******************************************************************************
 228  * GetEventLogInformation [ADVAPI32.@]
 229  *
 230  * Retrieve some information about an event log.
 231  *
 232  * PARAMS
 233  *  hEventLog      [I]   Handle to an open event log.
 234  *  dwInfoLevel    [I]   Level of information (only EVENTLOG_FULL_INFO)
 235  *  lpBuffer       [I/O] The buffer for the returned information
 236  *  cbBufSize      [I]   The size of the buffer
 237  *  pcbBytesNeeded [O]   The needed bytes to hold the information
 238  *
 239  * RETURNS
 240  *  Success: TRUE. lpBuffer will hold the information and pcbBytesNeeded shows
 241  *           the needed buffer size.
 242  *  Failure: FALSE.
 243  */
 244 BOOL WINAPI GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
 245 {
 246     EVENTLOG_FULL_INFORMATION *efi;
 247
 248     FIXME("(%p, %d, %p, %d, %p) stub\n", hEventLog, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 249
 250     if (dwInfoLevel != EVENTLOG_FULL_INFO)
 251     {
 252         SetLastError(ERROR_INVALID_LEVEL);
 253         return FALSE;
 254     }
 255
 256     if (!hEventLog)
 257     {
 258         SetLastError(ERROR_INVALID_HANDLE);
 259         return FALSE;
 260     }
 261
 262     if (!lpBuffer || !pcbBytesNeeded)
 263     {
 264         /* FIXME: This will be handled properly when eventlog is moved
 265          * to a higher level
 266          */
 267         SetLastError(RPC_X_NULL_REF_POINTER);
 268         return FALSE;
 269     }
 270
 271     *pcbBytesNeeded = sizeof(EVENTLOG_FULL_INFORMATION);
 272     if (cbBufSize < sizeof(EVENTLOG_FULL_INFORMATION))
 273     {
 274         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 275         return FALSE;
 276     }
 277
 278     /* Pretend the log is not full */
 279     efi = (EVENTLOG_FULL_INFORMATION *)lpBuffer;
 280     efi->dwFull = 0;
 281
 282     return TRUE;
 283 }
 284
 285 /******************************************************************************
 286  * GetNumberOfEventLogRecords [ADVAPI32.@]
 287  *
 288  * Retrieves the number of records in an event log.
 289  *
 290  * PARAMS
 291  *  hEventLog       [I] Handle to an open event log.
 292  *  NumberOfRecords [O] Number of records in the log.
 293  *
 294  * RETURNS
 295  *  Success: nonzero. NumberOfRecords will contain the number of records in
 296  *           the log.
 297  *  Failure: zero
 298  */
 299 BOOL WINAPI GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
 300 {
 301     FIXME("(%p,%p) stub\n", hEventLog, NumberOfRecords);
 302
 303     if (!NumberOfRecords)
 304     {
 305         SetLastError(ERROR_INVALID_PARAMETER);
 306         return FALSE;
 307     }
 308
 309     if (!hEventLog)
 310     {
 311         SetLastError(ERROR_INVALID_HANDLE);
 312         return FALSE;
 313     }
 314
 315     *NumberOfRecords = 0;
 316
 317     return TRUE;
 318 }
 319
 320 /******************************************************************************
 321  * GetOldestEventLogRecord [ADVAPI32.@]
 322  *
 323  * Retrieves the absolute record number of the oldest record in an even log.
 324  *
 325  * PARAMS
 326  *  hEventLog    [I] Handle to an open event log.
 327  *  OldestRecord [O] Absolute record number of the oldest record.
 328  *
 329  * RETURNS
 330  *  Success: nonzero. OldestRecord contains the record number of the oldest
 331  *           record in the log.
 332  *  Failure: zero
 333  */
 334 BOOL WINAPI GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
 335 {
 336     FIXME("(%p,%p) stub\n", hEventLog, OldestRecord);
 337
 338     if (!OldestRecord)
 339     {
 340         SetLastError(ERROR_INVALID_PARAMETER);
 341         return FALSE;
 342     }
 343
 344     if (!hEventLog)
 345     {
 346         SetLastError(ERROR_INVALID_HANDLE);
 347         return FALSE;
 348     }
 349
 350     *OldestRecord = 0;
 351
 352     return TRUE;
 353 }
 354
 355 /******************************************************************************
 356  * NotifyChangeEventLog [ADVAPI32.@]
 357  *
 358  * Enables an application to receive notification when an event is written
 359  * to an event log.
 360  *
 361  * PARAMS
 362  *  hEventLog [I] Handle to an event log.
 363  *  hEvent    [I] Handle to a manual-reset event object.
 364  *
 365  * RETURNS
 366  *  Success: nonzero
 367  *  Failure: zero
 368  */
 369 BOOL WINAPI NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
 370 {
 371         FIXME("(%p,%p) stub\n", hEventLog, hEvent);
 372         return TRUE;
 373 }
 374
 375 /******************************************************************************
 376  * OpenBackupEventLogA [ADVAPI32.@]
 377  *
 378  * Opens a handle to a backup event log.
 379  *
 380  * PARAMS
 381  *  lpUNCServerName [I] Universal Naming Convention name of the server on which
 382  *                      this will be performed.
 383  *  lpFileName      [I] Specifies the name of the backup file.
 384  *
 385  * RETURNS
 386  *  Success: Handle to the backup event log.
 387  *  Failure: NULL
 388  */
 389 HANDLE WINAPI OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
 390 {
 391     LPWSTR uncnameW, filenameW;
 392     HANDLE handle;
 393
 394     uncnameW = strdupAW(lpUNCServerName);
 395     filenameW = strdupAW(lpFileName);
 396     handle = OpenBackupEventLogW(uncnameW, filenameW);
 397     heap_free(uncnameW);
 398     heap_free(filenameW);
 399
 400     return handle;
 401 }
 402
 403 /******************************************************************************
 404  * OpenBackupEventLogW [ADVAPI32.@]
 405  *
 406  * See OpenBackupEventLogA.
 407  */
 408 HANDLE WINAPI OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
 409 {
 410     FIXME("(%s,%s) stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpFileName));
 411
 412     if (!lpFileName)
 413     {
 414         SetLastError(ERROR_INVALID_PARAMETER);
 415         return NULL;
 416     }
 417
 418     if (lpUNCServerName && lpUNCServerName[0])
 419     {
 420         FIXME("Remote server not supported\n");
 421         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 422         return NULL;
 423     }
 424
 425     if (GetFileAttributesW(lpFileName) == INVALID_FILE_ATTRIBUTES)
 426     {
 427         SetLastError(ERROR_FILE_NOT_FOUND);
 428         return NULL;
 429     }
 430
 431     return (HANDLE)0xcafe4242;
 432 }
 433
 434 /******************************************************************************
 435  * OpenEventLogA [ADVAPI32.@]
 436  *
 437  * Opens a handle to the specified event log.
 438  *
 439  * PARAMS
 440  *  lpUNCServerName [I] UNC name of the server on which the event log is
 441  *                      opened.
 442  *  lpSourceName    [I] Name of the log.
 443  *
 444  * RETURNS
 445  *  Success: Handle to an event log.
 446  *  Failure: NULL
 447  */
 448 HANDLE WINAPI OpenEventLogA( LPCSTR uncname, LPCSTR source )
 449 {
 450     LPWSTR uncnameW, sourceW;
 451     HANDLE handle;
 452
 453     uncnameW = strdupAW(uncname);
 454     sourceW = strdupAW(source);
 455     handle = OpenEventLogW(uncnameW, sourceW);
 456     heap_free(uncnameW);
 457     heap_free(sourceW);
 458
 459     return handle;
 460 }
 461
 462 /******************************************************************************
 463  * OpenEventLogW [ADVAPI32.@]
 464  *
 465  * See OpenEventLogA.
 466  */
 467 HANDLE WINAPI OpenEventLogW( LPCWSTR uncname, LPCWSTR source )
 468 {
 469     FIXME("(%s,%s) stub\n", debugstr_w(uncname), debugstr_w(source));
 470
 471     if (!source)
 472     {
 473         SetLastError(ERROR_INVALID_PARAMETER);
 474         return NULL;
 475     }
 476
 477     if (uncname && uncname[0])
 478     {
 479         FIXME("Remote server not supported\n");
 480         SetLastError(RPC_S_SERVER_UNAVAILABLE);
 481         return NULL;
 482     }
 483
 484     return (HANDLE)0xcafe4242;
 485 }
 486
 487 /******************************************************************************
 488  * ReadEventLogA [ADVAPI32.@]
 489  *
 490  * Reads a whole number of entries from an event log.
 491  *
 492  * PARAMS
 493  *  hEventLog                [I] Handle of the event log to read.
 494  *  dwReadFlags              [I] see MSDN doc.
 495  *  dwRecordOffset           [I] Log-entry record number to start at.
 496  *  lpBuffer                 [O] Buffer for the data read.
 497  *  nNumberOfBytesToRead     [I] Size of lpBuffer.
 498  *  pnBytesRead              [O] Receives number of bytes read.
 499  *  pnMinNumberOfBytesNeeded [O] Receives number of bytes required for the
 500  *                               next log entry.
 501  *
 502  * RETURNS
 503  *  Success: nonzero
 504  *  Failure: zero
 505  */
 506 BOOL WINAPI ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 507     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 508 {
 509     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 510           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 511
 512     SetLastError(ERROR_HANDLE_EOF);
 513     return FALSE;
 514 }
 515
 516 /******************************************************************************
 517  * ReadEventLogW [ADVAPI32.@]
 518  *
 519  * See ReadEventLogA.
 520  */
 521 BOOL WINAPI ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 522     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 523 {
 524     FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog, dwReadFlags,
 525           dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded);
 526
 527     SetLastError(ERROR_HANDLE_EOF);
 528     return FALSE;
 529 }
 530
 531 /******************************************************************************
 532  * RegisterEventSourceA [ADVAPI32.@]
 533  *
 534  * Returns a registered handle to an event log.
 535  *
 536  * PARAMS
 537  *  lpUNCServerName [I] UNC name of the source server.
 538  *  lpSourceName    [I] Specifies the name of the event source to retrieve.
 539  *
 540  * RETURNS
 541  *  Success: Handle to the event log.
 542  *  Failure: NULL. Returns ERROR_INVALID_HANDLE if lpSourceName specifies the
 543  *           Security event log.
 544  */
 545 HANDLE WINAPI RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
 546 {
 547     UNICODE_STRING lpUNCServerNameW;
 548     UNICODE_STRING lpSourceNameW;
 549     HANDLE ret;
 550
 551     FIXME("(%s,%s): stub\n", debugstr_a(lpUNCServerName), debugstr_a(lpSourceName));
 552
 553     RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW, lpUNCServerName);
 554     RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW, lpSourceName);
 555     ret = RegisterEventSourceW(lpUNCServerNameW.Buffer,lpSourceNameW.Buffer);
 556     RtlFreeUnicodeString (&lpUNCServerNameW);
 557     RtlFreeUnicodeString (&lpSourceNameW);
 558     return ret;
 559 }
 560
 561 /******************************************************************************
 562  * RegisterEventSourceW [ADVAPI32.@]
 563  *
 564  * See RegisterEventSourceA.
 565  */
 566 HANDLE WINAPI RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
 567 {
 568     FIXME("(%s,%s): stub\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
 569     return (HANDLE)0xcafe4242;
 570 }
 571
 572 /******************************************************************************
 573  * ReportEventA [ADVAPI32.@]
 574  *
 575  * Writes an entry at the end of an event log.
 576  *
 577  * PARAMS
 578  *  hEventLog   [I] Handle of an event log.
 579  *  wType       [I] See MSDN doc.
 580  *  wCategory   [I] Event category.
 581  *  dwEventID   [I] Event identifier.
 582  *  lpUserSid   [I] Current user's security identifier.
 583  *  wNumStrings [I] Number of insert strings in lpStrings.
 584  *  dwDataSize  [I] Size of event-specific raw data to write.
 585  *  lpStrings   [I] Buffer containing an array of string to be merged.
 586  *  lpRawData   [I] Buffer containing the binary data.
 587  *
 588  * RETURNS
 589  *  Success: nonzero. Entry was written to the log.
 590  *  Failure: zero.
 591  *
 592  * NOTES
 593  *  The ReportEvent function adds the time, the entry's length, and the
 594  *  offsets before storing the entry in the log. If lpUserSid != NULL, the
 595  *  username is also logged.
 596  */
 597 BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 598     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData)
 599 {
 600     LPWSTR *wideStrArray;
 601     UNICODE_STRING str;
 602     UINT i;
 603     BOOL ret;
 604
 605     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 606           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 607
 608     if (wNumStrings == 0) return TRUE;
 609     if (!lpStrings) return TRUE;
 610
 611     wideStrArray = heap_alloc(sizeof(LPWSTR) * wNumStrings);
 612     for (i = 0; i < wNumStrings; i++)
 613     {
 614         RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
 615         wideStrArray[i] = str.Buffer;
 616     }
 617     ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
 618                        wNumStrings, dwDataSize, (LPCWSTR *)wideStrArray, lpRawData);
 619     for (i = 0; i < wNumStrings; i++)
 620         heap_free( wideStrArray[i] );
 621     heap_free(wideStrArray);
 622     return ret;
 623 }
 624
 625 /******************************************************************************
 626  * ReportEventW [ADVAPI32.@]
 627  *
 628  * See ReportEventA.
 629  */
 630 BOOL WINAPI ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 631     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData )
 632 {
 633     UINT i;
 634
 635     FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog,
 636           wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
 637
 638     /* partial stub */
 639
 640     if (wNumStrings == 0) return TRUE;
 641     if (!lpStrings) return TRUE;
 642
 643     for (i = 0; i < wNumStrings; i++)
 644     {
 645         switch (wType)
 646         {
 647         case EVENTLOG_SUCCESS:
 648             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 649             break;
 650         case EVENTLOG_ERROR_TYPE:
 651             ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 652             break;
 653         case EVENTLOG_WARNING_TYPE:
 654             WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 655             break;
 656         default:
 657             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 658             break;
 659         }
 660     }
 661     return TRUE;
 662 }
 663
 664 /******************************************************************************
 665  * StopTraceA [ADVAPI32.@]
 666  *
 667  * See StopTraceW.
 668  *
 669  */
 670 ULONG WINAPI StopTraceA( TRACEHANDLE session, LPCSTR session_name, PEVENT_TRACE_PROPERTIES properties )
 671 {
 672     FIXME("(%s, %s, %p) stub\n", wine_dbgstr_longlong(session), debugstr_a(session_name), properties);
 673     return ERROR_SUCCESS;
 674 }
 675
 676 /******************************************************************************
 677  * QueryTraceW [ADVAPI32.@]
 678  */
 679 ULONG WINAPI QueryTraceW( TRACEHANDLE handle, LPCWSTR sessionname, PEVENT_TRACE_PROPERTIES properties )
 680 {
 681     FIXME("%s %s %p: stub\n", wine_dbgstr_longlong(handle), debugstr_w(sessionname), properties);
 682     return ERROR_CALL_NOT_IMPLEMENTED;
 683 }
 684
 685 /******************************************************************************
 686  * OpenTraceA [ADVAPI32.@]
 687  */
 688 TRACEHANDLE WINAPI OpenTraceA( PEVENT_TRACE_LOGFILEA logfile )
 689 {
 690     static int once;
 691
 692     if (!once++) FIXME("%p: stub\n", logfile);
 693     SetLastError(ERROR_ACCESS_DENIED);
 694     return INVALID_PROCESSTRACE_HANDLE;
 695 }
 696
 697 /******************************************************************************
 698  * EnumerateTraceGuids [ADVAPI32.@]
 699  */
 700 ULONG WINAPI EnumerateTraceGuids(PTRACE_GUID_PROPERTIES *propertiesarray,
 701                                  ULONG arraycount, PULONG guidcount)
 702 {
 703     FIXME("%p %d %p: stub\n", propertiesarray, arraycount, guidcount);
 704     return ERROR_INVALID_PARAMETER;
 705 }