2 * Win32 advapi functions
4 * Copyright 1995 Sven Verdoolaege
5 * Copyright 1998 Juergen Schmied
6 * Copyright 2003 Mike Hearn
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.
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.
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
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
36 #include "advapi32_misc.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(advapi
);
39 WINE_DECLARE_DEBUG_CHANNEL(eventlog
);
41 /******************************************************************************
42 * BackupEventLogA [ADVAPI32.@]
44 * Saves the event log to a backup file.
47 * hEventLog [I] Handle to event log to backup.
48 * lpBackupFileName [I] Name of the backup file.
51 * Success: nonzero. File lpBackupFileName will contain the contents of
55 BOOL WINAPI
BackupEventLogA( HANDLE hEventLog
, LPCSTR lpBackupFileName
)
60 backupW
= SERV_dup(lpBackupFileName
);
61 ret
= BackupEventLogW(hEventLog
, backupW
);
67 /******************************************************************************
68 * BackupEventLogW [ADVAPI32.@]
70 * See BackupEventLogA.
72 BOOL WINAPI
BackupEventLogW( HANDLE hEventLog
, LPCWSTR lpBackupFileName
)
74 FIXME("(%p,%s) stub\n", hEventLog
, debugstr_w(lpBackupFileName
));
76 if (!lpBackupFileName
)
78 SetLastError(ERROR_INVALID_PARAMETER
);
84 SetLastError(ERROR_INVALID_HANDLE
);
88 if (GetFileAttributesW(lpBackupFileName
) != INVALID_FILE_ATTRIBUTES
)
90 SetLastError(ERROR_ALREADY_EXISTS
);
97 /******************************************************************************
98 * ClearEventLogA [ADVAPI32.@]
100 * Clears the event log and optionally saves the log to a backup file.
103 * hEvenLog [I] Handle to event log to clear.
104 * lpBackupFileName [I] Name of the backup file.
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
112 BOOL WINAPI
ClearEventLogA( HANDLE hEventLog
, LPCSTR lpBackupFileName
)
117 backupW
= SERV_dup(lpBackupFileName
);
118 ret
= ClearEventLogW(hEventLog
, backupW
);
124 /******************************************************************************
125 * ClearEventLogW [ADVAPI32.@]
127 * See ClearEventLogA.
129 BOOL WINAPI
ClearEventLogW( HANDLE hEventLog
, LPCWSTR lpBackupFileName
)
131 FIXME("(%p,%s) stub\n", hEventLog
, debugstr_w(lpBackupFileName
));
135 SetLastError(ERROR_INVALID_HANDLE
);
142 /******************************************************************************
143 * CloseEventLog [ADVAPI32.@]
145 * Closes a read handle to the event log.
148 * hEventLog [I/O] Handle of the event log to close.
154 BOOL WINAPI
CloseEventLog( HANDLE hEventLog
)
156 FIXME("(%p) stub\n", hEventLog
);
160 SetLastError(ERROR_INVALID_HANDLE
);
167 /******************************************************************************
168 * ControlTraceW [ADVAPI32.@]
170 * Control a givel event trace session
173 ULONG WINAPI
ControlTraceW( TRACEHANDLE hSession
, LPCWSTR SessionName
, PEVENT_TRACE_PROPERTIES Properties
, ULONG control
)
175 FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession
), debugstr_w(SessionName
), Properties
, control
);
176 return ERROR_SUCCESS
;
179 /******************************************************************************
180 * ControlTraceA [ADVAPI32.@]
185 ULONG WINAPI
ControlTraceA( TRACEHANDLE hSession
, LPCSTR SessionName
, PEVENT_TRACE_PROPERTIES Properties
, ULONG control
)
187 FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession
), debugstr_a(SessionName
), Properties
, control
);
188 return ERROR_SUCCESS
;
191 /******************************************************************************
192 * FlushTraceA [ADVAPI32.@]
194 ULONG WINAPI
FlushTraceA ( TRACEHANDLE hSession
, LPCSTR SessionName
, PEVENT_TRACE_PROPERTIES Properties
)
196 return ControlTraceA( hSession
, SessionName
, Properties
, EVENT_TRACE_CONTROL_FLUSH
);
199 /******************************************************************************
200 * FlushTraceW [ADVAPI32.@]
202 ULONG WINAPI
FlushTraceW ( TRACEHANDLE hSession
, LPCWSTR SessionName
, PEVENT_TRACE_PROPERTIES Properties
)
204 return ControlTraceW( hSession
, SessionName
, Properties
, EVENT_TRACE_CONTROL_FLUSH
);
208 /******************************************************************************
209 * DeregisterEventSource [ADVAPI32.@]
211 * Closes a write handle to an event log
214 * hEventLog [I/O] Handle of the event log.
220 BOOL WINAPI
DeregisterEventSource( HANDLE hEventLog
)
222 FIXME("(%p) stub\n", hEventLog
);
226 /******************************************************************************
227 * EnableTraceEx [ADVAPI32.@]
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
)
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
);
238 return ERROR_SUCCESS
;
241 /******************************************************************************
242 * EnableTrace [ADVAPI32.@]
244 ULONG WINAPI
EnableTrace( ULONG enable
, ULONG flag
, ULONG level
, LPCGUID guid
, TRACEHANDLE hSession
)
246 FIXME("(%d, 0x%x, %d, %s, %s): stub\n", enable
, flag
, level
,
247 debugstr_guid(guid
), wine_dbgstr_longlong(hSession
));
249 return ERROR_SUCCESS
;
252 /******************************************************************************
253 * GetEventLogInformation [ADVAPI32.@]
255 * Retrieve some information about an event log.
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
265 * Success: TRUE. lpBuffer will hold the information and pcbBytesNeeded shows
266 * the needed buffer size.
269 BOOL WINAPI
GetEventLogInformation( HANDLE hEventLog
, DWORD dwInfoLevel
, LPVOID lpBuffer
, DWORD cbBufSize
, LPDWORD pcbBytesNeeded
)
271 EVENTLOG_FULL_INFORMATION
*efi
;
273 FIXME("(%p, %d, %p, %d, %p) stub\n", hEventLog
, dwInfoLevel
, lpBuffer
, cbBufSize
, pcbBytesNeeded
);
275 if (dwInfoLevel
!= EVENTLOG_FULL_INFO
)
277 SetLastError(ERROR_INVALID_LEVEL
);
283 SetLastError(ERROR_INVALID_HANDLE
);
287 if (!lpBuffer
|| !pcbBytesNeeded
)
289 /* FIXME: This will be handled properly when eventlog is moved
292 SetLastError(RPC_X_NULL_REF_POINTER
);
296 *pcbBytesNeeded
= sizeof(EVENTLOG_FULL_INFORMATION
);
297 if (cbBufSize
< sizeof(EVENTLOG_FULL_INFORMATION
))
299 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
303 /* Pretend the log is not full */
304 efi
= (EVENTLOG_FULL_INFORMATION
*)lpBuffer
;
310 /******************************************************************************
311 * GetNumberOfEventLogRecords [ADVAPI32.@]
313 * Retrieves the number of records in an event log.
316 * hEventLog [I] Handle to an open event log.
317 * NumberOfRecords [O] Number of records in the log.
320 * Success: nonzero. NumberOfRecords will contain the number of records in
324 BOOL WINAPI
GetNumberOfEventLogRecords( HANDLE hEventLog
, PDWORD NumberOfRecords
)
326 FIXME("(%p,%p) stub\n", hEventLog
, NumberOfRecords
);
328 if (!NumberOfRecords
)
330 SetLastError(ERROR_INVALID_PARAMETER
);
336 SetLastError(ERROR_INVALID_HANDLE
);
340 *NumberOfRecords
= 0;
345 /******************************************************************************
346 * GetOldestEventLogRecord [ADVAPI32.@]
348 * Retrieves the absolute record number of the oldest record in an even log.
351 * hEventLog [I] Handle to an open event log.
352 * OldestRecord [O] Absolute record number of the oldest record.
355 * Success: nonzero. OldestRecord contains the record number of the oldest
359 BOOL WINAPI
GetOldestEventLogRecord( HANDLE hEventLog
, PDWORD OldestRecord
)
361 FIXME("(%p,%p) stub\n", hEventLog
, OldestRecord
);
365 SetLastError(ERROR_INVALID_PARAMETER
);
371 SetLastError(ERROR_INVALID_HANDLE
);
380 /******************************************************************************
381 * GetTraceEnableFlags [ADVAPI32.@]
383 ULONG WINAPI
GetTraceEnableFlags( TRACEHANDLE handle
)
385 FIXME("(%s) stub\n", wine_dbgstr_longlong(handle
));
389 /******************************************************************************
390 * GetTraceEnableLevel [ADVAPI32.@]
392 UCHAR WINAPI
GetTraceEnableLevel( TRACEHANDLE handle
)
394 FIXME("(%s) stub\n", wine_dbgstr_longlong(handle
));
395 return TRACE_LEVEL_VERBOSE
;
398 /******************************************************************************
399 * GetTraceLoggerHandle [ADVAPI32.@]
401 TRACEHANDLE WINAPI
GetTraceLoggerHandle( PVOID buf
)
403 FIXME("(%p) stub\n", buf
);
404 SetLastError(ERROR_ACCESS_DENIED
);
405 return INVALID_PROCESSTRACE_HANDLE
;
408 /******************************************************************************
409 * NotifyChangeEventLog [ADVAPI32.@]
411 * Enables an application to receive notification when an event is written
415 * hEventLog [I] Handle to an event log.
416 * hEvent [I] Handle to a manual-reset event object.
422 BOOL WINAPI
NotifyChangeEventLog( HANDLE hEventLog
, HANDLE hEvent
)
424 FIXME("(%p,%p) stub\n", hEventLog
, hEvent
);
428 /******************************************************************************
429 * OpenBackupEventLogA [ADVAPI32.@]
431 * Opens a handle to a backup event log.
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.
439 * Success: Handle to the backup event log.
442 HANDLE WINAPI
OpenBackupEventLogA( LPCSTR lpUNCServerName
, LPCSTR lpFileName
)
444 LPWSTR uncnameW
, filenameW
;
447 uncnameW
= SERV_dup(lpUNCServerName
);
448 filenameW
= SERV_dup(lpFileName
);
449 handle
= OpenBackupEventLogW(uncnameW
, filenameW
);
451 heap_free(filenameW
);
456 /******************************************************************************
457 * OpenBackupEventLogW [ADVAPI32.@]
459 * See OpenBackupEventLogA.
461 HANDLE WINAPI
OpenBackupEventLogW( LPCWSTR lpUNCServerName
, LPCWSTR lpFileName
)
463 FIXME("(%s,%s) stub\n", debugstr_w(lpUNCServerName
), debugstr_w(lpFileName
));
467 SetLastError(ERROR_INVALID_PARAMETER
);
471 if (lpUNCServerName
&& lpUNCServerName
[0])
473 FIXME("Remote server not supported\n");
474 SetLastError(RPC_S_SERVER_UNAVAILABLE
);
478 if (GetFileAttributesW(lpFileName
) == INVALID_FILE_ATTRIBUTES
)
480 SetLastError(ERROR_FILE_NOT_FOUND
);
484 return (HANDLE
)0xcafe4242;
487 /******************************************************************************
488 * OpenEventLogA [ADVAPI32.@]
490 * Opens a handle to the specified event log.
493 * lpUNCServerName [I] UNC name of the server on which the event log is
495 * lpSourceName [I] Name of the log.
498 * Success: Handle to an event log.
501 HANDLE WINAPI
OpenEventLogA( LPCSTR uncname
, LPCSTR source
)
503 LPWSTR uncnameW
, sourceW
;
506 uncnameW
= SERV_dup(uncname
);
507 sourceW
= SERV_dup(source
);
508 handle
= OpenEventLogW(uncnameW
, sourceW
);
515 /******************************************************************************
516 * OpenEventLogW [ADVAPI32.@]
520 HANDLE WINAPI
OpenEventLogW( LPCWSTR uncname
, LPCWSTR source
)
522 FIXME("(%s,%s) stub\n", debugstr_w(uncname
), debugstr_w(source
));
526 SetLastError(ERROR_INVALID_PARAMETER
);
530 if (uncname
&& uncname
[0])
532 FIXME("Remote server not supported\n");
533 SetLastError(RPC_S_SERVER_UNAVAILABLE
);
537 return (HANDLE
)0xcafe4242;
540 /******************************************************************************
541 * QueryAllTracesW [ADVAPI32.@]
543 * Query information for started event trace sessions
546 ULONG WINAPI
QueryAllTracesW( PEVENT_TRACE_PROPERTIES
* parray
, ULONG arraycount
, PULONG psessioncount
)
548 FIXME("(%p, %d, %p) stub\n", parray
, arraycount
, psessioncount
);
550 if (psessioncount
) *psessioncount
= 0;
551 return ERROR_SUCCESS
;
554 /******************************************************************************
555 * QueryAllTracesA [ADVAPI32.@]
557 * See QueryAllTracesW.
559 ULONG WINAPI
QueryAllTracesA( PEVENT_TRACE_PROPERTIES
* parray
, ULONG arraycount
, PULONG psessioncount
)
561 FIXME("(%p, %d, %p) stub\n", parray
, arraycount
, psessioncount
);
563 if (psessioncount
) *psessioncount
= 0;
564 return ERROR_SUCCESS
;
567 /******************************************************************************
568 * ReadEventLogA [ADVAPI32.@]
570 * Reads a whole number of entries from an event log.
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
586 BOOL WINAPI
ReadEventLogA( HANDLE hEventLog
, DWORD dwReadFlags
, DWORD dwRecordOffset
,
587 LPVOID lpBuffer
, DWORD nNumberOfBytesToRead
, DWORD
*pnBytesRead
, DWORD
*pnMinNumberOfBytesNeeded
)
589 FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog
, dwReadFlags
,
590 dwRecordOffset
, lpBuffer
, nNumberOfBytesToRead
, pnBytesRead
, pnMinNumberOfBytesNeeded
);
592 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
596 /******************************************************************************
597 * ReadEventLogW [ADVAPI32.@]
601 BOOL WINAPI
ReadEventLogW( HANDLE hEventLog
, DWORD dwReadFlags
, DWORD dwRecordOffset
,
602 LPVOID lpBuffer
, DWORD nNumberOfBytesToRead
, DWORD
*pnBytesRead
, DWORD
*pnMinNumberOfBytesNeeded
)
604 FIXME("(%p,0x%08x,0x%08x,%p,0x%08x,%p,%p) stub\n", hEventLog
, dwReadFlags
,
605 dwRecordOffset
, lpBuffer
, nNumberOfBytesToRead
, pnBytesRead
, pnMinNumberOfBytesNeeded
);
607 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
611 /******************************************************************************
612 * RegisterEventSourceA [ADVAPI32.@]
614 * Returns a registered handle to an event log.
617 * lpUNCServerName [I] UNC name of the source server.
618 * lpSourceName [I] Specifies the name of the event source to retrieve.
621 * Success: Handle to the event log.
622 * Failure: NULL. Returns ERROR_INVALID_HANDLE if lpSourceName specifies the
623 * Security event log.
625 HANDLE WINAPI
RegisterEventSourceA( LPCSTR lpUNCServerName
, LPCSTR lpSourceName
)
627 UNICODE_STRING lpUNCServerNameW
;
628 UNICODE_STRING lpSourceNameW
;
631 FIXME("(%s,%s): stub\n", debugstr_a(lpUNCServerName
), debugstr_a(lpSourceName
));
633 RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW
, lpUNCServerName
);
634 RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW
, lpSourceName
);
635 ret
= RegisterEventSourceW(lpUNCServerNameW
.Buffer
,lpSourceNameW
.Buffer
);
636 RtlFreeUnicodeString (&lpUNCServerNameW
);
637 RtlFreeUnicodeString (&lpSourceNameW
);
641 /******************************************************************************
642 * RegisterEventSourceW [ADVAPI32.@]
644 * See RegisterEventSourceA.
646 HANDLE WINAPI
RegisterEventSourceW( LPCWSTR lpUNCServerName
, LPCWSTR lpSourceName
)
648 FIXME("(%s,%s): stub\n", debugstr_w(lpUNCServerName
), debugstr_w(lpSourceName
));
649 return (HANDLE
)0xcafe4242;
652 /******************************************************************************
653 * ReportEventA [ADVAPI32.@]
655 * Writes an entry at the end of an event log.
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.
669 * Success: nonzero. Entry was written to the log.
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.
677 BOOL WINAPI
ReportEventA ( HANDLE hEventLog
, WORD wType
, WORD wCategory
, DWORD dwEventID
,
678 PSID lpUserSid
, WORD wNumStrings
, DWORD dwDataSize
, LPCSTR
*lpStrings
, LPVOID lpRawData
)
680 LPWSTR
*wideStrArray
;
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
);
688 if (wNumStrings
== 0) return TRUE
;
689 if (!lpStrings
) return TRUE
;
691 wideStrArray
= heap_alloc(sizeof(LPWSTR
) * wNumStrings
);
692 for (i
= 0; i
< wNumStrings
; i
++)
694 RtlCreateUnicodeStringFromAsciiz(&str
, lpStrings
[i
]);
695 wideStrArray
[i
] = str
.Buffer
;
697 ret
= ReportEventW(hEventLog
, wType
, wCategory
, dwEventID
, lpUserSid
,
698 wNumStrings
, dwDataSize
, (LPCWSTR
*)wideStrArray
, lpRawData
);
699 for (i
= 0; i
< wNumStrings
; i
++)
700 heap_free( wideStrArray
[i
] );
701 heap_free(wideStrArray
);
705 /******************************************************************************
706 * ReportEventW [ADVAPI32.@]
710 BOOL WINAPI
ReportEventW( HANDLE hEventLog
, WORD wType
, WORD wCategory
, DWORD dwEventID
,
711 PSID lpUserSid
, WORD wNumStrings
, DWORD dwDataSize
, LPCWSTR
*lpStrings
, LPVOID lpRawData
)
715 FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog
,
716 wType
, wCategory
, dwEventID
, lpUserSid
, wNumStrings
, dwDataSize
, lpStrings
, lpRawData
);
720 if (wNumStrings
== 0) return TRUE
;
721 if (!lpStrings
) return TRUE
;
723 for (i
= 0; i
< wNumStrings
; i
++)
727 case EVENTLOG_SUCCESS
:
728 TRACE_(eventlog
)("%s\n", debugstr_w(lpStrings
[i
]));
730 case EVENTLOG_ERROR_TYPE
:
731 ERR_(eventlog
)("%s\n", debugstr_w(lpStrings
[i
]));
733 case EVENTLOG_WARNING_TYPE
:
734 WARN_(eventlog
)("%s\n", debugstr_w(lpStrings
[i
]));
737 TRACE_(eventlog
)("%s\n", debugstr_w(lpStrings
[i
]));
744 /******************************************************************************
745 * StartTraceW [ADVAPI32.@]
747 * Register and start an event trace session
750 ULONG WINAPI
StartTraceW( PTRACEHANDLE pSessionHandle
, LPCWSTR SessionName
, PEVENT_TRACE_PROPERTIES Properties
)
752 FIXME("(%p, %s, %p) stub\n", pSessionHandle
, debugstr_w(SessionName
), Properties
);
753 if (pSessionHandle
) *pSessionHandle
= 0xcafe4242;
754 return ERROR_SUCCESS
;
757 /******************************************************************************
758 * StartTraceA [ADVAPI32.@]
763 ULONG WINAPI
StartTraceA( PTRACEHANDLE pSessionHandle
, LPCSTR SessionName
, PEVENT_TRACE_PROPERTIES Properties
)
765 FIXME("(%p, %s, %p) stub\n", pSessionHandle
, debugstr_a(SessionName
), Properties
);
766 if (pSessionHandle
) *pSessionHandle
= 0xcafe4242;
767 return ERROR_SUCCESS
;
770 /******************************************************************************
771 * StopTraceW [ADVAPI32.@]
773 * Stop an event trace session
776 ULONG WINAPI
StopTraceW( TRACEHANDLE session
, LPCWSTR session_name
, PEVENT_TRACE_PROPERTIES properties
)
778 FIXME("(%s, %s, %p) stub\n", wine_dbgstr_longlong(session
), debugstr_w(session_name
), properties
);
779 return ERROR_SUCCESS
;
782 /******************************************************************************
783 * StopTraceA [ADVAPI32.@]
788 ULONG WINAPI
StopTraceA( TRACEHANDLE session
, LPCSTR session_name
, PEVENT_TRACE_PROPERTIES properties
)
790 FIXME("(%s, %s, %p) stub\n", wine_dbgstr_longlong(session
), debugstr_a(session_name
), properties
);
791 return ERROR_SUCCESS
;
794 /******************************************************************************
795 * TraceEvent [ADVAPI32.@]
797 ULONG WINAPI
TraceEvent( TRACEHANDLE SessionHandle
, PEVENT_TRACE_HEADER EventTrace
)
799 FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle
), EventTrace
);
800 return ERROR_CALL_NOT_IMPLEMENTED
;
803 /******************************************************************************
804 * UnregisterTraceGuids [ADVAPI32.@]
806 * See RegisterTraceGuids
811 ULONG WINAPI
UnregisterTraceGuids( TRACEHANDLE RegistrationHandle
)
813 FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle
));
814 return ERROR_CALL_NOT_IMPLEMENTED
;
817 /******************************************************************************
818 * EventRegister [ADVAPI32.@]
820 ULONG WINAPI
EventRegister( LPCGUID provider
, PENABLECALLBACK callback
, PVOID context
, PREGHANDLE handle
)
822 FIXME("%s, %p, %p, %p\n", debugstr_guid(provider
), callback
, context
, handle
);
824 *handle
= 0xdeadbeef;
825 return ERROR_SUCCESS
;
828 /******************************************************************************
829 * EventUnregister [ADVAPI32.@]
831 ULONG WINAPI
EventUnregister( REGHANDLE handle
)
833 FIXME("%s: stub\n", wine_dbgstr_longlong(handle
));
834 return ERROR_SUCCESS
;
837 /******************************************************************************
838 * EventEnabled [ADVAPI32.@]
841 BOOLEAN WINAPI
EventEnabled( REGHANDLE handle
, PCEVENT_DESCRIPTOR descriptor
)
843 FIXME("(%s, %p): stub\n", wine_dbgstr_longlong(handle
), descriptor
);
847 /******************************************************************************
848 * EventProviderEnabled [ADVAPI32.@]
851 BOOLEAN WINAPI
EventProviderEnabled( REGHANDLE handle
, UCHAR level
, ULONGLONG keyword
)
853 FIXME("%s, %u, %s: stub\n", wine_dbgstr_longlong(handle
), level
, wine_dbgstr_longlong(keyword
));
857 /******************************************************************************
858 * EventActivityIdControl [ADVAPI32.@]
861 ULONG WINAPI
EventActivityIdControl(ULONG code
, GUID
*guid
)
863 FIXME("0x%x, %p: stub\n", code
, guid
);
864 return ERROR_SUCCESS
;
867 /******************************************************************************
868 * EventWrite [ADVAPI32.@]
870 ULONG WINAPI
EventWrite( REGHANDLE handle
, PCEVENT_DESCRIPTOR descriptor
, ULONG count
,
871 PEVENT_DATA_DESCRIPTOR data
)
873 FIXME("%s, %p, %u, %p: stub\n", wine_dbgstr_longlong(handle
), descriptor
, count
, data
);
874 return ERROR_SUCCESS
;
877 /******************************************************************************
878 * EventSetInformation [ADVAPI32.@]
880 ULONG WINAPI
EventSetInformation( REGHANDLE handle
, EVENT_INFO_CLASS
class, PVOID info
,
883 FIXME("%u, %p, %u\n", class, info
, length
);
884 return ERROR_SUCCESS
;
887 /******************************************************************************
888 * QueryTraceW [ADVAPI32.@]
890 ULONG WINAPI
QueryTraceW( TRACEHANDLE handle
, LPCWSTR sessionname
, PEVENT_TRACE_PROPERTIES properties
)
892 FIXME("%s %s %p: stub\n", wine_dbgstr_longlong(handle
), debugstr_w(sessionname
), properties
);
893 return ERROR_CALL_NOT_IMPLEMENTED
;
896 /******************************************************************************
897 * OpenTraceA [ADVAPI32.@]
899 TRACEHANDLE WINAPI
OpenTraceA( PEVENT_TRACE_LOGFILEA logfile
)
901 FIXME("%p: stub\n", logfile
);
902 SetLastError(ERROR_ACCESS_DENIED
);
903 return INVALID_PROCESSTRACE_HANDLE
;
906 /******************************************************************************
907 * OpenTraceW [ADVAPI32.@]
909 TRACEHANDLE WINAPI
OpenTraceW( PEVENT_TRACE_LOGFILEW logfile
)
911 FIXME("%p: stub\n", logfile
);
912 SetLastError(ERROR_ACCESS_DENIED
);
913 return INVALID_PROCESSTRACE_HANDLE
;
916 /******************************************************************************
917 * ProcessTrace [ADVAPI32.@]
919 ULONG WINAPI
ProcessTrace( PTRACEHANDLE HandleArray
, ULONG HandleCount
, LPFILETIME StartTime
, LPFILETIME EndTime
)
921 FIXME("%p %u %p %p: stub\n", HandleArray
, HandleCount
, StartTime
, EndTime
);
922 return ERROR_CALL_NOT_IMPLEMENTED
;
925 /******************************************************************************
926 * TraceMessage [ADVAPI32.@]
928 ULONG WINAPIV
TraceMessage( TRACEHANDLE handle
, ULONG flags
, LPGUID guid
, USHORT number
, ... )
933 __ms_va_start( valist
, number
);
934 ret
= TraceMessageVa( handle
, flags
, guid
, number
, valist
);
935 __ms_va_end( valist
);
939 /******************************************************************************
940 * TraceMessageVa [ADVAPI32.@]
942 ULONG WINAPI
TraceMessageVa( TRACEHANDLE handle
, ULONG flags
, LPGUID guid
, USHORT number
,
945 FIXME("(%s %x %s %d) : stub\n", wine_dbgstr_longlong(handle
), flags
, debugstr_guid(guid
), number
);
946 return ERROR_SUCCESS
;
949 /******************************************************************************
950 * CloseTrace [ADVAPI32.@]
952 ULONG WINAPI
CloseTrace( TRACEHANDLE handle
)
954 FIXME("%s: stub\n", wine_dbgstr_longlong(handle
));
955 return ERROR_INVALID_HANDLE
;
958 /******************************************************************************
959 * EnumerateTraceGuids [ADVAPI32.@]
961 ULONG WINAPI
EnumerateTraceGuids(PTRACE_GUID_PROPERTIES
*propertiesarray
,
962 ULONG arraycount
, PULONG guidcount
)
964 FIXME("%p %d %p: stub\n", propertiesarray
, arraycount
, guidcount
);
965 return ERROR_INVALID_PARAMETER
;
968 /******************************************************************************
969 * WmiOpenBlock [ADVAPI32.@]
971 NTSTATUS WINAPI
WmiOpenBlock(GUID
*guid
, ULONG access
, PVOID
*datablock
)
973 FIXME("%s %d %p: stub\n", debugstr_guid(guid
), access
, datablock
);
974 return ERROR_SUCCESS
;