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