FreeRDP
Loading...
Searching...
No Matches
include/winpr/synch.h
1
22#ifndef WINPR_SYNCH_H
23#define WINPR_SYNCH_H
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28
29#include <winpr/platform.h>
30#include <winpr/winpr.h>
31#include <winpr/wtypes.h>
32#include <winpr/error.h>
33#include <winpr/handle.h>
34
35#include <winpr/nt.h>
36
37#ifdef __cplusplus
38extern "C"
39{
40#endif
41
42#ifndef _WIN32
43
44/* Mutex */
45#define CREATE_MUTEX_INITIAL_OWNER 0x00000001
46
47 WINPR_ATTR_MALLOC(CloseHandle, 1)
48 WINPR_API HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner,
49 LPCSTR lpName);
50
51 WINPR_ATTR_MALLOC(CloseHandle, 1)
52 WINPR_API HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner,
53 LPCWSTR lpName);
54
55 WINPR_ATTR_MALLOC(CloseHandle, 1)
56 WINPR_API HANDLE CreateMutexExA(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCSTR lpName,
57 DWORD dwFlags, DWORD dwDesiredAccess);
58
59 WINPR_ATTR_MALLOC(CloseHandle, 1)
60 WINPR_API HANDLE CreateMutexExW(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCWSTR lpName,
61 DWORD dwFlags, DWORD dwDesiredAccess);
62
63 WINPR_ATTR_MALLOC(CloseHandle, 1)
64 WINPR_API HANDLE OpenMutexA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
65
66 WINPR_ATTR_MALLOC(CloseHandle, 1)
67 WINPR_API HANDLE OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
68
69 WINPR_API BOOL ReleaseMutex(HANDLE hMutex);
70
71#ifdef UNICODE
72#define CreateMutex CreateMutexW
73#define CreateMutexEx CreateMutexExW
74#define OpenMutex OpenMutexW
75#else
76#define CreateMutex CreateMutexA
77#define CreateMutexEx CreateMutexExA
78#define OpenMutex OpenMutexA
79#endif
80
81 /* Semaphore */
82
83 WINPR_ATTR_MALLOC(CloseHandle, 1)
84 WINPR_API HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
85 LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName);
86
87 WINPR_ATTR_MALLOC(CloseHandle, 1)
88 WINPR_API HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
89 LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName);
90
91 WINPR_ATTR_MALLOC(CloseHandle, 1)
92 WINPR_API HANDLE OpenSemaphoreA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
93
94 WINPR_ATTR_MALLOC(CloseHandle, 1)
95 WINPR_API HANDLE OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
96
97#ifdef UNICODE
98#define CreateSemaphore CreateSemaphoreW
99#define OpenSemaphore OpenSemaphoreW
100#else
101#define CreateSemaphore CreateSemaphoreA
102#define OpenSemaphore OpenSemaphoreA
103#endif
104
105 WINPR_ATTR_NODISCARD
106 WINPR_API BOOL ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);
107
108/* Event */
109#define CREATE_EVENT_MANUAL_RESET 0x00000001
110#define CREATE_EVENT_INITIAL_SET 0x00000002
111
112 WINPR_ATTR_MALLOC(CloseHandle, 1)
113 WINPR_API HANDLE CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
114 BOOL bInitialState, LPCSTR lpName);
115
116 WINPR_ATTR_MALLOC(CloseHandle, 1)
117 WINPR_API HANDLE CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
118 BOOL bInitialState, LPCWSTR lpName);
119
120 WINPR_ATTR_MALLOC(CloseHandle, 1)
121 WINPR_API HANDLE CreateEventExA(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCSTR lpName,
122 DWORD dwFlags, DWORD dwDesiredAccess);
123
124 WINPR_ATTR_MALLOC(CloseHandle, 1)
125 WINPR_API HANDLE CreateEventExW(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCWSTR lpName,
126 DWORD dwFlags, DWORD dwDesiredAccess);
127
128 WINPR_ATTR_MALLOC(CloseHandle, 1)
129 WINPR_API HANDLE OpenEventA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
130
131 WINPR_ATTR_MALLOC(CloseHandle, 1)
132 WINPR_API HANDLE OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
133
134 WINPR_API BOOL SetEvent(HANDLE hEvent);
135
136 WINPR_API BOOL ResetEvent(HANDLE hEvent);
137
138#if defined(WITH_DEBUG_EVENTS)
139#define DumpEventHandles() DumpEventHandles_(__func__, __FILE__, __LINE__)
140 WINPR_API void DumpEventHandles_(const char* fkt, const char* file, size_t line);
141#endif
142#ifdef UNICODE
143#define CreateEvent CreateEventW
144#define CreateEventEx CreateEventExW
145#define OpenEvent OpenEventW
146#else
147#define CreateEvent CreateEventA
148#define CreateEventEx CreateEventExA
149#define OpenEvent OpenEventA
150#endif
151
152 /* Condition Variable */
153
154 typedef PVOID RTL_CONDITION_VARIABLE;
155 typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE, *PCONDITION_VARIABLE;
156
157 /* Critical Section */
158
159 typedef struct
160 {
161 PVOID DebugInfo;
162 LONG LockCount;
163 LONG RecursionCount;
164 HANDLE OwningThread;
165 HANDLE LockSemaphore;
166 ULONG_PTR SpinCount;
167 } RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
168
169 typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
170 typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION;
171 typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION;
172
173 WINPR_API VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
174
175 WINPR_ATTR_NODISCARD
176 WINPR_API BOOL InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection,
177 DWORD dwSpinCount, DWORD Flags);
178
179 WINPR_ATTR_NODISCARD
180 WINPR_API BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection,
181 DWORD dwSpinCount);
182
183 WINPR_API DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION lpCriticalSection,
184 DWORD dwSpinCount);
185
186 WINPR_API VOID EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
187
188 WINPR_ATTR_NODISCARD
189 WINPR_API BOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
190
191 WINPR_API VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
192
193 WINPR_API VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
194
195 /* Sleep */
196
197 WINPR_API VOID Sleep(DWORD dwMilliseconds);
198
199 WINPR_API DWORD SleepEx(DWORD dwMilliseconds, BOOL bAlertable);
200
201 /* Address */
202
203 WINPR_API VOID WakeByAddressAll(PVOID Address);
204 WINPR_API VOID WakeByAddressSingle(PVOID Address);
205
206 WINPR_ATTR_NODISCARD
207 WINPR_API BOOL WaitOnAddress(VOID volatile* Address, PVOID CompareAddress, size_t AddressSize,
208 DWORD dwMilliseconds);
209
210 /* Wait */
211
212#define INFINITE 0xFFFFFFFFUL
213
214#define WAIT_OBJECT_0 0x00000000UL
215#define WAIT_ABANDONED 0x00000080UL
216#define WAIT_IO_COMPLETION 0x000000C0UL
217
218#ifndef WAIT_TIMEOUT
219#define WAIT_TIMEOUT 0x00000102UL
220#endif
221
222#define WAIT_FAILED 0xFFFFFFFFUL
223
224#define MAXIMUM_WAIT_OBJECTS 64
225
226 WINPR_API DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
227
228 WINPR_ATTR_NODISCARD
229 WINPR_API DWORD WaitForSingleObjectEx(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable);
230
231 WINPR_ATTR_NODISCARD
232 WINPR_API DWORD WaitForMultipleObjects(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll,
233 DWORD dwMilliseconds);
234
235 WINPR_ATTR_NODISCARD
236 WINPR_API DWORD WaitForMultipleObjectsEx(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll,
237 DWORD dwMilliseconds, BOOL bAlertable);
238
239 WINPR_ATTR_NODISCARD
240 WINPR_API DWORD SignalObjectAndWait(HANDLE hObjectToSignal, HANDLE hObjectToWaitOn,
241 DWORD dwMilliseconds, BOOL bAlertable);
242
243 /* Waitable Timer */
244
245#define CREATE_WAITABLE_TIMER_MANUAL_RESET 0x00000001
246
247 typedef struct
248 {
249 ULONG Version;
250 DWORD Flags;
251
252 union
253 {
254 struct
255 {
256 HMODULE LocalizedReasonModule;
257 ULONG LocalizedReasonId;
258 ULONG ReasonStringCount;
259 LPWSTR* ReasonStrings;
260 } Detailed;
261
262 LPWSTR SimpleReasonString;
263 } Reason;
264 } REASON_CONTEXT, *PREASON_CONTEXT;
265
266 typedef VOID (*PTIMERAPCROUTINE)(LPVOID lpArgToCompletionRoutine, DWORD dwTimerLowValue,
267 DWORD dwTimerHighValue);
268
269 WINPR_ATTR_MALLOC(CloseHandle, 1)
270 WINPR_API HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes,
271 BOOL bManualReset, LPCSTR lpTimerName);
272
273 WINPR_ATTR_MALLOC(CloseHandle, 1)
274 WINPR_API HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes,
275 BOOL bManualReset, LPCWSTR lpTimerName);
276
277 WINPR_ATTR_MALLOC(CloseHandle, 1)
278 WINPR_API HANDLE CreateWaitableTimerExA(LPSECURITY_ATTRIBUTES lpTimerAttributes,
279 LPCSTR lpTimerName, DWORD dwFlags,
280 DWORD dwDesiredAccess);
281
282 WINPR_ATTR_MALLOC(CloseHandle, 1)
283 WINPR_API HANDLE CreateWaitableTimerExW(LPSECURITY_ATTRIBUTES lpTimerAttributes,
284 LPCWSTR lpTimerName, DWORD dwFlags,
285 DWORD dwDesiredAccess);
286
287 WINPR_ATTR_NODISCARD
288 WINPR_API BOOL SetWaitableTimer(HANDLE hTimer, const LARGE_INTEGER* lpDueTime, LONG lPeriod,
289 PTIMERAPCROUTINE pfnCompletionRoutine,
290 LPVOID lpArgToCompletionRoutine, BOOL fResume);
291
292 WINPR_ATTR_NODISCARD
293 WINPR_API BOOL SetWaitableTimerEx(HANDLE hTimer, const LARGE_INTEGER* lpDueTime, LONG lPeriod,
294 PTIMERAPCROUTINE pfnCompletionRoutine,
295 LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext,
296 ULONG TolerableDelay);
297
298 WINPR_ATTR_MALLOC(CloseHandle, 1)
299 WINPR_API HANDLE OpenWaitableTimerA(DWORD dwDesiredAccess, BOOL bInheritHandle,
300 LPCSTR lpTimerName);
301
302 WINPR_ATTR_MALLOC(CloseHandle, 1)
303 WINPR_API HANDLE OpenWaitableTimerW(DWORD dwDesiredAccess, BOOL bInheritHandle,
304 LPCWSTR lpTimerName);
305
306 WINPR_ATTR_NODISCARD
307 WINPR_API BOOL CancelWaitableTimer(HANDLE hTimer);
308
309#ifdef UNICODE
310#define CreateWaitableTimer CreateWaitableTimerW
311#define CreateWaitableTimerEx CreateWaitableTimerExW
312#define OpenWaitableTimer OpenWaitableTimerW
313#else
314#define CreateWaitableTimer CreateWaitableTimerA
315#define CreateWaitableTimerEx CreateWaitableTimerExA
316#define OpenWaitableTimer OpenWaitableTimerA
317#endif
318
319 WINPR_ATTR_NODISCARD
320 WINPR_API int GetTimerFileDescriptor(HANDLE hTimer);
321
326#define WT_EXECUTEDEFAULT 0x00000000
327#define WT_EXECUTEINIOTHREAD 0x00000001
328#define WT_EXECUTEINUITHREAD 0x00000002
329#define WT_EXECUTEINWAITTHREAD 0x00000004
330#define WT_EXECUTEONLYONCE 0x00000008
331#define WT_EXECUTELONGFUNCTION 0x00000010
332#define WT_EXECUTEINTIMERTHREAD 0x00000020
333#define WT_EXECUTEINPERSISTENTIOTHREAD 0x00000040
334#define WT_EXECUTEINPERSISTENTTHREAD 0x00000080
335#define WT_TRANSFER_IMPERSONATION 0x00000100
336
337 typedef VOID (*WAITORTIMERCALLBACK)(PVOID lpParameter, BOOLEAN TimerOrWaitFired);
338
339 WINPR_ATTR_MALLOC(CloseHandle, 1)
340 WINPR_API HANDLE CreateTimerQueue(void);
341
342 WINPR_ATTR_NODISCARD
343 WINPR_API BOOL DeleteTimerQueue(HANDLE TimerQueue);
344
345 WINPR_ATTR_NODISCARD
346 WINPR_API BOOL DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent);
347
348 WINPR_ATTR_NODISCARD
349 WINPR_API BOOL CreateTimerQueueTimer(HANDLE* phNewTimer, HANDLE TimerQueue,
350 WAITORTIMERCALLBACK Callback, void* Parameter,
351 DWORD DueTime, DWORD Period, ULONG Flags);
352
353 WINPR_ATTR_NODISCARD
354 WINPR_API BOOL ChangeTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, ULONG DueTime,
355 ULONG Period);
356
357 WINPR_ATTR_NODISCARD
358 WINPR_API BOOL DeleteTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent);
359
360#endif
361
362#if (defined(_WIN32) && (_WIN32_WINNT < 0x0600))
363#define InitializeCriticalSectionEx(lpCriticalSection, dwSpinCount, Flags) \
364 InitializeCriticalSectionAndSpinCount(lpCriticalSection, dwSpinCount)
365#endif
366
367 WINPR_PRAGMA_DIAG_PUSH
368 WINPR_PRAGMA_DIAG_IGNORED_RESERVED_ID_MACRO
369
370#ifndef _RTL_RUN_ONCE_DEF
371// NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
372#define _RTL_RUN_ONCE_DEF
373
374 WINPR_PRAGMA_DIAG_POP
375
376#define RTL_RUN_ONCE_INIT \
377 { \
378 0 \
379 }
380
381#define RTL_RUN_ONCE_CHECK_ONLY 0x00000001
382#define RTL_RUN_ONCE_ASYNC 0x00000002
383#define RTL_RUN_ONCE_INIT_FAILED 0x00000004
384
385#define RTL_RUN_ONCE_CTX_RESERVED_BITS 2
386
387 typedef struct
388 {
389 PVOID Ptr;
390 } RTL_RUN_ONCE, *PRTL_RUN_ONCE;
391
392 typedef ULONG CALLBACK RTL_RUN_ONCE_INIT_FN(PRTL_RUN_ONCE RunOnce, PVOID Parameter,
393 PVOID* Context);
394 typedef RTL_RUN_ONCE_INIT_FN* PRTL_RUN_ONCE_INIT_FN;
395
396#endif
397
398#if (!defined(_WIN32)) || (defined(_WIN32) && (_WIN32_WINNT < 0x0600))
399
400 /* One-Time Initialization */
401
402#define INIT_ONCE_STATIC_INIT RTL_RUN_ONCE_INIT
403
404 typedef RTL_RUN_ONCE INIT_ONCE;
405 typedef PRTL_RUN_ONCE PINIT_ONCE;
406 typedef PRTL_RUN_ONCE LPINIT_ONCE;
407 typedef BOOL(CALLBACK* PINIT_ONCE_FN)(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context);
408
409 WINPR_ATTR_NODISCARD
410 WINPR_API BOOL winpr_InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags,
411 PBOOL fPending, LPVOID* lpContext);
412
413 WINPR_ATTR_NODISCARD
414 WINPR_API BOOL winpr_InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpContext);
415
416 WINPR_ATTR_NODISCARD
417 WINPR_API BOOL winpr_InitOnceExecuteOnce(PINIT_ONCE InitOnce, PINIT_ONCE_FN InitFn,
418 PVOID Parameter, LPVOID* Context);
419
420 WINPR_API VOID winpr_InitOnceInitialize(PINIT_ONCE InitOnce);
421
422#define InitOnceBeginInitialize winpr_InitOnceBeginInitialize
423#define InitOnceComplete winpr_InitOnceComplete
424#define InitOnceExecuteOnce winpr_InitOnceExecuteOnce
425#define InitOnceInitialize winpr_InitOnceInitialize
426#endif
427
428 /* Synchronization Barrier */
429
430#if (!defined(_WIN32)) || (defined(_WIN32) && (_WIN32_WINNT < 0x0602) && !defined(_SYNCHAPI_H_))
431#define WINPR_SYNCHRONIZATION_BARRIER 1
432#endif
433
434#ifdef WINPR_SYNCHRONIZATION_BARRIER
435
436 typedef struct
437 {
438 DWORD Reserved1;
439 DWORD Reserved2;
440 ULONG_PTR Reserved3[2];
441 DWORD Reserved4;
442 DWORD Reserved5;
443 } RTL_BARRIER, *PRTL_BARRIER;
444
445 typedef RTL_BARRIER SYNCHRONIZATION_BARRIER;
446 typedef PRTL_BARRIER PSYNCHRONIZATION_BARRIER;
447 typedef PRTL_BARRIER LPSYNCHRONIZATION_BARRIER;
448
449#define SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY 0x01
450#define SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY 0x02
451#define SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE 0x04
452
453 WINPR_ATTR_NODISCARD
454 WINPR_API BOOL WINAPI winpr_InitializeSynchronizationBarrier(
455 LPSYNCHRONIZATION_BARRIER lpBarrier, LONG lTotalThreads, LONG lSpinCount);
456
457 WINPR_ATTR_NODISCARD
458 WINPR_API BOOL WINAPI winpr_EnterSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier,
459 DWORD dwFlags);
460
461 WINPR_ATTR_NODISCARD
462 WINPR_API BOOL WINAPI winpr_DeleteSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier);
463
464#define InitializeSynchronizationBarrier winpr_InitializeSynchronizationBarrier
465#define EnterSynchronizationBarrier winpr_EnterSynchronizationBarrier
466#define DeleteSynchronizationBarrier winpr_DeleteSynchronizationBarrier
467
468#endif
469
470 /* Extended API */
471
472 WINPR_API VOID USleep(DWORD dwMicroseconds);
473
474 WINPR_ATTR_MALLOC(CloseHandle, 1)
475 WINPR_API HANDLE CreateFileDescriptorEventW(LPSECURITY_ATTRIBUTES lpEventAttributes,
476 BOOL bManualReset, BOOL bInitialState,
477 int FileDescriptor, ULONG mode);
478
479 WINPR_ATTR_MALLOC(CloseHandle, 1)
480 WINPR_API HANDLE CreateFileDescriptorEventA(LPSECURITY_ATTRIBUTES lpEventAttributes,
481 BOOL bManualReset, BOOL bInitialState,
482 int FileDescriptor, ULONG mode);
483
484 WINPR_ATTR_MALLOC(CloseHandle, 1)
485 WINPR_API HANDLE CreateWaitObjectEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,
486 BOOL bManualReset, BOOL bInitialState, void* pObject);
487
488#ifdef UNICODE
489#define CreateFileDescriptorEvent CreateFileDescriptorEventW
490#else
491#define CreateFileDescriptorEvent CreateFileDescriptorEventA
492#endif
493
494 WINPR_ATTR_NODISCARD
495 WINPR_API int GetEventFileDescriptor(HANDLE hEvent);
496
497 WINPR_ATTR_NODISCARD
498 WINPR_API int SetEventFileDescriptor(HANDLE hEvent, int FileDescriptor, ULONG mode);
499
500 WINPR_ATTR_NODISCARD
501 WINPR_API void* GetEventWaitObject(HANDLE hEvent);
502
503#ifdef __cplusplus
504}
505#endif
506
507#endif /* WINPR_SYNCH_H */
REASON_CONTEXT
Definition include/winpr/synch.h:248
RTL_BARRIER
Definition include/winpr/synch.h:437
RTL_CRITICAL_SECTION
Definition include/winpr/synch.h:160
RTL_RUN_ONCE
Definition include/winpr/synch.h:388
LARGE_INTEGER
Definition wtypes.h:309