21#include <winpr/config.h>
24#include <winpr/file.h>
25#include <winpr/assert.h>
26#include <winpr/sysinfo.h>
28#include <winpr/synch.h>
42#include "../handle/handle.h"
43#include "../thread/thread.h"
46#define TAG WINPR_TAG("synch.timer")
48static BOOL TimerCloseHandle(HANDLE handle);
50static BOOL TimerIsHandled(HANDLE handle)
52 return WINPR_HANDLE_IS_HANDLED(handle, HANDLE_TYPE_TIMER, FALSE);
55static int TimerGetFd(HANDLE handle)
57 WINPR_TIMER* timer = (WINPR_TIMER*)handle;
59 if (!TimerIsHandled(handle))
65static DWORD TimerCleanupHandle(HANDLE handle)
67 WINPR_TIMER* timer = (WINPR_TIMER*)handle;
69 if (!TimerIsHandled(handle))
72 if (timer->bManualReset)
75#ifdef TIMER_IMPL_TIMERFD
79 UINT64 expirations = 0;
80 length = read(timer->fd, (
void*)&expirations,
sizeof(UINT64));
81 }
while (length < 0 && errno == EINTR);
87 char ebuffer[256] = { 0 };
98 WLog_ERR(TAG,
"timer read() failure [%d] %s", errno,
99 winpr_strerror(errno, ebuffer,
sizeof(ebuffer)));
103 WLog_ERR(TAG,
"timer read() failure - incorrect number of bytes read");
108#elif defined(TIMER_IMPL_POSIX) || defined(TIMER_IMPL_DISPATCH)
109 if (!winpr_event_reset(&timer->event))
111 WLog_ERR(TAG,
"timer reset() failure");
116 return WAIT_OBJECT_0;
121 WINPR_APC_ITEM apcItem;
125static void TimerPostDelete_APC(LPVOID arg)
127 TimerDeleter* deleter = (TimerDeleter*)arg;
128 WINPR_ASSERT(deleter);
129 free(deleter->timer);
130 deleter->apcItem.markedForFree = TRUE;
131 deleter->apcItem.markedForRemove = TRUE;
134BOOL TimerCloseHandle(HANDLE handle)
136 WINPR_TIMER* timer = NULL;
137 timer = (WINPR_TIMER*)handle;
139 if (!TimerIsHandled(handle))
142#ifdef TIMER_IMPL_TIMERFD
147#ifdef TIMER_IMPL_POSIX
148 timer_delete(timer->tid);
151#ifdef TIMER_IMPL_DISPATCH
152 dispatch_release(timer->queue);
153 dispatch_release(timer->source);
156#if defined(TIMER_IMPL_POSIX) || defined(TIMER_IMPL_DISPATCH)
157 winpr_event_uninit(&timer->event);
161 if (timer->apcItem.linked)
163 TimerDeleter* deleter = NULL;
164 WINPR_APC_ITEM* apcItem = NULL;
166 switch (apc_remove(&timer->apcItem))
170 case APC_REMOVE_DELAY_FREE:
172 WINPR_THREAD* thread = winpr_GetCurrentThread();
176 deleter = calloc(1,
sizeof(*deleter));
179 WLog_ERR(TAG,
"unable to allocate a timer deleter");
183 deleter->timer = timer;
184 apcItem = &deleter->apcItem;
185 apcItem->type = APC_TYPE_HANDLE_FREE;
186 apcItem->alwaysSignaled = TRUE;
187 apcItem->completion = TimerPostDelete_APC;
188 apcItem->completionArgs = deleter;
189 apc_register(thread, apcItem);
192 case APC_REMOVE_ERROR:
194 WLog_ERR(TAG,
"unable to remove timer from APC list");
203#ifdef TIMER_IMPL_POSIX
205static void WaitableTimerSignalHandler(
int signum, siginfo_t* siginfo,
void* arg)
207 WINPR_TIMER* timer = siginfo->si_value.sival_ptr;
211 if (!timer || (signum != SIGALRM))
214 if (!winpr_event_set(&timer->event))
215 WLog_ERR(TAG,
"error when notifying event");
218static INIT_ONCE TimerSignalHandler_InitOnce = INIT_ONCE_STATIC_INIT;
220static BOOL InstallTimerSignalHandler(
PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context)
222 struct sigaction action;
223 sigemptyset(&action.sa_mask);
224 sigaddset(&action.sa_mask, SIGALRM);
225 action.sa_flags = SA_RESTART | SA_SIGINFO;
226 action.sa_sigaction = WaitableTimerSignalHandler;
227 sigaction(SIGALRM, &action, NULL);
232#ifdef TIMER_IMPL_DISPATCH
233static void WaitableTimerHandler(
void* arg)
235 WINPR_TIMER* timer = (WINPR_TIMER*)arg;
240 if (!winpr_event_set(&timer->event))
241 WLog_ERR(TAG,
"failed to write to pipe");
243 if (timer->lPeriod == 0)
246 dispatch_suspend(timer->source);
248 timer->running = FALSE;
253static int InitializeWaitableTimer(WINPR_TIMER* timer)
257#ifdef TIMER_IMPL_TIMERFD
258 timer->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
261#elif defined(TIMER_IMPL_POSIX)
262 struct sigevent sigev = { 0 };
263 InitOnceExecuteOnce(&TimerSignalHandler_InitOnce, InstallTimerSignalHandler, NULL, NULL);
264 sigev.sigev_notify = SIGEV_SIGNAL;
265 sigev.sigev_signo = SIGALRM;
266 sigev.sigev_value.sival_ptr = (
void*)timer;
268 if ((timer_create(CLOCK_MONOTONIC, &sigev, &(timer->tid))) != 0)
270 WLog_ERR(TAG,
"timer_create");
273#elif !defined(TIMER_IMPL_DISPATCH)
274 WLog_ERR(TAG,
"os specific implementation is missing");
282static BOOL timer_drain_fd(
int fd)
289 ret = read(fd, &expr,
sizeof(expr));
290 }
while (ret < 0 && errno == EINTR);
321HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset,
324 HANDLE handle = NULL;
325 WINPR_TIMER* timer = NULL;
327 if (lpTimerAttributes)
328 WLog_WARN(TAG,
"[%s] does not support lpTimerAttributes", lpTimerName);
330 timer = (WINPR_TIMER*)calloc(1,
sizeof(WINPR_TIMER));
334 WINPR_HANDLE_SET_TYPE_AND_MODE(timer, HANDLE_TYPE_TIMER, WINPR_FD_READ);
335 handle = (HANDLE)timer;
338 timer->bManualReset = bManualReset;
339 timer->pfnCompletionRoutine = NULL;
340 timer->lpArgToCompletionRoutine = NULL;
341 timer->bInit = FALSE;
344 timer->name = strdup(lpTimerName);
346 timer->common.ops = &ops;
347#if defined(TIMER_IMPL_DISPATCH) || defined(TIMER_IMPL_POSIX)
348 if (!winpr_event_init(&timer->event))
350 timer->fd = timer->event.fds[0];
353#if defined(TIMER_IMPL_DISPATCH)
354 timer->queue = dispatch_queue_create(TAG, DISPATCH_QUEUE_SERIAL);
359 timer->source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, timer->queue);
364 dispatch_set_context(timer->source, timer);
365 dispatch_source_set_event_handler_f(timer->source, WaitableTimerHandler);
371#if defined(TIMER_IMPL_DISPATCH) || defined(TIMER_IMPL_POSIX)
373 TimerCloseHandle(handle);
378HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset,
381 HANDLE handle = NULL;
386 name = ConvertWCharToUtf8Alloc(lpTimerName, NULL);
391 handle = CreateWaitableTimerA(lpTimerAttributes, bManualReset, name);
396HANDLE CreateWaitableTimerExA(LPSECURITY_ATTRIBUTES lpTimerAttributes, LPCSTR lpTimerName,
397 DWORD dwFlags, DWORD dwDesiredAccess)
399 BOOL bManualReset = (dwFlags & CREATE_WAITABLE_TIMER_MANUAL_RESET) ? TRUE : FALSE;
401 if (dwDesiredAccess != 0)
402 WLog_WARN(TAG,
"[%s] does not support dwDesiredAccess 0x%08" PRIx32, lpTimerName,
405 return CreateWaitableTimerA(lpTimerAttributes, bManualReset, lpTimerName);
408HANDLE CreateWaitableTimerExW(LPSECURITY_ATTRIBUTES lpTimerAttributes, LPCWSTR lpTimerName,
409 DWORD dwFlags, DWORD dwDesiredAccess)
411 HANDLE handle = NULL;
416 name = ConvertWCharToUtf8Alloc(lpTimerName, NULL);
421 handle = CreateWaitableTimerExA(lpTimerAttributes, name, dwFlags, dwDesiredAccess);
426static void timerAPC(LPVOID arg)
428 WINPR_TIMER* timer = (WINPR_TIMER*)arg;
434 switch (apc_remove(&timer->apcItem))
437 case APC_REMOVE_DELAY_FREE:
439 case APC_REMOVE_ERROR:
441 WLog_ERR(TAG,
"error removing the APC routine");
445 if (timer->pfnCompletionRoutine)
446 timer->pfnCompletionRoutine(timer->lpArgToCompletionRoutine, 0, 0);
448#ifdef TIMER_IMPL_TIMERFD
449 while (timer_drain_fd(timer->fd))
451#elif defined(TIMER_IMPL_POSIX) || defined(TIMER_IMPL_DISPATCH)
452 winpr_event_reset(&timer->event);
456BOOL SetWaitableTimer(HANDLE hTimer,
const LARGE_INTEGER* lpDueTime, LONG lPeriod,
457 PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine,
462 WINPR_TIMER* timer = NULL;
463 LONGLONG seconds = 0;
464 LONGLONG nanoseconds = 0;
467 if (!winpr_Handle_GetInfo(hTimer, &Type, &Object))
470 if (Type != HANDLE_TYPE_TIMER)
481 WLog_ERR(TAG,
"does not support fResume");
485 timer = (WINPR_TIMER*)Object;
486 timer->lPeriod = lPeriod;
487 timer->pfnCompletionRoutine = pfnCompletionRoutine;
488 timer->lpArgToCompletionRoutine = lpArgToCompletionRoutine;
492 if (InitializeWaitableTimer(timer) < 0)
496#if defined(TIMER_IMPL_TIMERFD) || defined(TIMER_IMPL_POSIX)
497 ZeroMemory(&(timer->timeout),
sizeof(
struct itimerspec));
499 if (lpDueTime->QuadPart < 0)
501 LONGLONG due = lpDueTime->QuadPart * (-1);
503 seconds = (due / 10000000);
504 nanoseconds = ((due % 10000000) * 100);
506 else if (lpDueTime->QuadPart == 0)
508 seconds = nanoseconds = 0;
512 WLog_ERR(TAG,
"absolute time not implemented");
518 timer->timeout.it_interval.tv_sec = (lPeriod / 1000LL);
519 timer->timeout.it_interval.tv_nsec = (1000000LL * (lPeriod % 1000LL));
522 if (lpDueTime->QuadPart != 0)
524 timer->timeout.it_value.tv_sec = seconds;
525 timer->timeout.it_value.tv_nsec = nanoseconds;
529 timer->timeout.it_value.tv_sec = timer->timeout.it_interval.tv_sec;
530 timer->timeout.it_value.tv_nsec = timer->timeout.it_interval.tv_nsec;
533#ifdef TIMER_IMPL_TIMERFD
534 status = timerfd_settime(timer->fd, 0, &(timer->timeout), NULL);
537 WLog_ERR(TAG,
"timerfd_settime failure: %d", status);
541 status = timer_settime(timer->tid, 0, &(timer->timeout), NULL);
544 WLog_ERR(TAG,
"timer_settime failure");
550#ifdef TIMER_IMPL_DISPATCH
551 if (lpDueTime->QuadPart < 0)
553 LONGLONG due = lpDueTime->QuadPart * (-1);
555 seconds = (due / 10000000);
556 nanoseconds = due * 100;
558 else if (lpDueTime->QuadPart == 0)
560 seconds = nanoseconds = 0;
564 WLog_ERR(TAG,
"absolute time not implemented");
568 if (!winpr_event_reset(&timer->event))
570 WLog_ERR(TAG,
"error when resetting timer event");
575 dispatch_suspend(timer->source);
577 dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, nanoseconds);
578 uint64_t interval = DISPATCH_TIME_FOREVER;
581 interval = lPeriod * 1000000;
583 dispatch_source_set_timer(timer->source, start, interval, 0);
584 dispatch_resume(timer->source);
585 timer->running = TRUE;
589 if (pfnCompletionRoutine)
591 WINPR_APC_ITEM* apcItem = &timer->apcItem;
594 apcItem->type = APC_TYPE_TIMER;
595 apcItem->alwaysSignaled = FALSE;
596 apcItem->pollFd = timer->fd;
597 apcItem->pollMode = WINPR_FD_READ;
598 apcItem->completion = timerAPC;
599 apcItem->completionArgs = timer;
601 if (!apcItem->linked)
603 WINPR_THREAD* thread = winpr_GetCurrentThread();
607 apc_register(thread, apcItem);
612 if (timer->apcItem.linked)
614 apc_remove(&timer->apcItem);
620BOOL SetWaitableTimerEx(HANDLE hTimer,
const LARGE_INTEGER* lpDueTime, LONG lPeriod,
621 PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine,
623 WINPR_ATTR_UNUSED ULONG TolerableDelay)
625 return SetWaitableTimer(hTimer, lpDueTime, lPeriod, pfnCompletionRoutine,
626 lpArgToCompletionRoutine, FALSE);
629HANDLE OpenWaitableTimerA(WINPR_ATTR_UNUSED DWORD dwDesiredAccess,
630 WINPR_ATTR_UNUSED BOOL bInheritHandle,
631 WINPR_ATTR_UNUSED LPCSTR lpTimerName)
634 WLog_ERR(TAG,
"not implemented");
638HANDLE OpenWaitableTimerW(WINPR_ATTR_UNUSED DWORD dwDesiredAccess,
639 WINPR_ATTR_UNUSED BOOL bInheritHandle,
640 WINPR_ATTR_UNUSED LPCWSTR lpTimerName)
643 WLog_ERR(TAG,
"not implemented");
647BOOL CancelWaitableTimer(HANDLE hTimer)
652 if (!winpr_Handle_GetInfo(hTimer, &Type, &Object))
655 if (Type != HANDLE_TYPE_TIMER)
658#if defined(__APPLE__)
660 WINPR_TIMER* timer = (WINPR_TIMER*)Object;
662 dispatch_suspend(timer->source);
664 timer->running = FALSE;
675int GetTimerFileDescriptor(HANDLE hTimer)
680 if (!winpr_Handle_GetInfo(hTimer, &type, &hdl) || type != HANDLE_TYPE_TIMER)
682 WLog_ERR(TAG,
"GetTimerFileDescriptor: hTimer is not an timer");
683 SetLastError(ERROR_INVALID_PARAMETER);
687 return winpr_Handle_getFd(hTimer);
699static void timespec_add_ms(
struct timespec* tspec, UINT32 ms)
703 ns = tspec->tv_nsec + (ms * 1000000LL);
704 tspec->tv_sec += (ns / 1000000000LL);
705 tspec->tv_nsec = (ns % 1000000000LL);
708static void timespec_gettimeofday(
struct timespec* tspec)
712 const UINT64 ns = winpr_GetUnixTimeNS();
713 tspec->tv_sec = WINPR_TIME_NS_TO_S(ns);
714 tspec->tv_nsec = WINPR_TIME_NS_REM_NS(ns);
717static INT64 timespec_compare(
const struct timespec* tspec1,
const struct timespec* tspec2)
719 WINPR_ASSERT(tspec1);
720 WINPR_ASSERT(tspec2);
721 if (tspec1->tv_sec == tspec2->tv_sec)
722 return (tspec1->tv_nsec - tspec2->tv_nsec);
724 return (tspec1->tv_sec - tspec2->tv_sec);
727static void timespec_copy(
struct timespec* dst,
struct timespec* src)
731 dst->tv_sec = src->tv_sec;
732 dst->tv_nsec = src->tv_nsec;
735static void InsertTimerQueueTimer(WINPR_TIMER_QUEUE_TIMER** pHead, WINPR_TIMER_QUEUE_TIMER* timer)
737 WINPR_TIMER_QUEUE_TIMER* node = NULL;
753 if (timespec_compare(&(timer->ExpirationTime), &(node->ExpirationTime)) > 0)
755 if (timespec_compare(&(timer->ExpirationTime), &(node->next->ExpirationTime)) < 0)
764 timer->next = node->next->next;
774static void RemoveTimerQueueTimer(WINPR_TIMER_QUEUE_TIMER** pHead, WINPR_TIMER_QUEUE_TIMER* timer)
777 WINPR_TIMER_QUEUE_TIMER* node = NULL;
778 WINPR_TIMER_QUEUE_TIMER* prevNode = NULL;
784 *pHead = timer->next;
808 prevNode->next = timer->next;
815static int FireExpiredTimerQueueTimers(WINPR_TIMER_QUEUE* timerQueue)
817 struct timespec CurrentTime;
818 WINPR_TIMER_QUEUE_TIMER* node = NULL;
820 WINPR_ASSERT(timerQueue);
822 if (!timerQueue->activeHead)
825 timespec_gettimeofday(&CurrentTime);
826 node = timerQueue->activeHead;
830 if (timespec_compare(&CurrentTime, &(node->ExpirationTime)) >= 0)
832 node->Callback(node->Parameter, TRUE);
834 timerQueue->activeHead = node->next;
839 timespec_add_ms(&(node->ExpirationTime), node->Period);
840 InsertTimerQueueTimer(&(timerQueue->activeHead), node);
844 InsertTimerQueueTimer(&(timerQueue->inactiveHead), node);
847 node = timerQueue->activeHead;
858static void* TimerQueueThread(
void* arg)
861 struct timespec timeout;
862 WINPR_TIMER_QUEUE* timerQueue = (WINPR_TIMER_QUEUE*)arg;
864 WINPR_ASSERT(timerQueue);
867 pthread_mutex_lock(&(timerQueue->cond_mutex));
868 timespec_gettimeofday(&timeout);
870 if (!timerQueue->activeHead)
872 timespec_add_ms(&timeout, 50);
876 if (timespec_compare(&timeout, &(timerQueue->activeHead->ExpirationTime)) < 0)
878 timespec_copy(&timeout, &(timerQueue->activeHead->ExpirationTime));
882 status = pthread_cond_timedwait(&(timerQueue->cond), &(timerQueue->cond_mutex), &timeout);
883 FireExpiredTimerQueueTimers(timerQueue);
884 const BOOL bCancelled = timerQueue->bCancelled;
885 pthread_mutex_unlock(&(timerQueue->cond_mutex));
887 if ((status != ETIMEDOUT) && (status != 0))
897static int StartTimerQueueThread(WINPR_TIMER_QUEUE* timerQueue)
899 WINPR_ASSERT(timerQueue);
900 pthread_cond_init(&(timerQueue->cond), NULL);
901 pthread_mutex_init(&(timerQueue->cond_mutex), NULL);
902 pthread_mutex_init(&(timerQueue->mutex), NULL);
903 pthread_attr_init(&(timerQueue->attr));
904 timerQueue->param.sched_priority = sched_get_priority_max(SCHED_FIFO);
905 pthread_attr_setschedparam(&(timerQueue->attr), &(timerQueue->param));
906 pthread_attr_setschedpolicy(&(timerQueue->attr), SCHED_FIFO);
907 pthread_create(&(timerQueue->thread), &(timerQueue->attr), TimerQueueThread, timerQueue);
911HANDLE CreateTimerQueue(
void)
913 HANDLE handle = NULL;
914 WINPR_TIMER_QUEUE* timerQueue = NULL;
915 timerQueue = (WINPR_TIMER_QUEUE*)calloc(1,
sizeof(WINPR_TIMER_QUEUE));
919 WINPR_HANDLE_SET_TYPE_AND_MODE(timerQueue, HANDLE_TYPE_TIMER_QUEUE, WINPR_FD_READ);
920 handle = (HANDLE)timerQueue;
921 timerQueue->activeHead = NULL;
922 timerQueue->inactiveHead = NULL;
923 timerQueue->bCancelled = FALSE;
924 StartTimerQueueThread(timerQueue);
930BOOL DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
933 WINPR_TIMER_QUEUE* timerQueue = NULL;
934 WINPR_TIMER_QUEUE_TIMER* node = NULL;
935 WINPR_TIMER_QUEUE_TIMER* nextNode = NULL;
940 timerQueue = (WINPR_TIMER_QUEUE*)TimerQueue;
942 pthread_mutex_lock(&(timerQueue->cond_mutex));
943 timerQueue->bCancelled = TRUE;
944 pthread_cond_signal(&(timerQueue->cond));
945 pthread_mutex_unlock(&(timerQueue->cond_mutex));
946 pthread_join(timerQueue->thread, &rvalue);
959 node = timerQueue->activeHead;
963 InsertTimerQueueTimer(&(timerQueue->inactiveHead), node);
967 timerQueue->activeHead = NULL;
969 node = timerQueue->inactiveHead;
973 nextNode = node->next;
978 timerQueue->inactiveHead = NULL;
981 pthread_cond_destroy(&(timerQueue->cond));
982 pthread_mutex_destroy(&(timerQueue->cond_mutex));
983 pthread_mutex_destroy(&(timerQueue->mutex));
984 pthread_attr_destroy(&(timerQueue->attr));
987 if (CompletionEvent && (CompletionEvent != INVALID_HANDLE_VALUE))
988 (void)SetEvent(CompletionEvent);
993BOOL DeleteTimerQueue(HANDLE TimerQueue)
995 return DeleteTimerQueueEx(TimerQueue, NULL);
998BOOL CreateTimerQueueTimer(HANDLE* phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback,
999 void* Parameter, DWORD DueTime, DWORD Period, ULONG Flags)
1001 struct timespec CurrentTime = { 0 };
1006 timespec_gettimeofday(&CurrentTime);
1007 WINPR_TIMER_QUEUE* timerQueue = (WINPR_TIMER_QUEUE*)TimerQueue;
1008 WINPR_TIMER_QUEUE_TIMER* timer = calloc(1,
sizeof(WINPR_TIMER_QUEUE_TIMER));
1013 WINPR_HANDLE_SET_TYPE_AND_MODE(timer, HANDLE_TYPE_TIMER_QUEUE_TIMER, WINPR_FD_READ);
1014 *phNewTimer = (HANDLE)timer;
1015 timespec_copy(&(timer->StartTime), &CurrentTime);
1016 timespec_add_ms(&(timer->StartTime), DueTime);
1017 timespec_copy(&(timer->ExpirationTime), &(timer->StartTime));
1018 timer->Flags = Flags;
1019 timer->DueTime = DueTime;
1020 timer->Period = Period;
1021 timer->Callback = Callback;
1022 timer->Parameter = Parameter;
1023 timer->timerQueue = (WINPR_TIMER_QUEUE*)TimerQueue;
1024 timer->FireCount = 0;
1026 pthread_mutex_lock(&(timerQueue->cond_mutex));
1027 InsertTimerQueueTimer(&(timerQueue->activeHead), timer);
1028 pthread_cond_signal(&(timerQueue->cond));
1029 pthread_mutex_unlock(&(timerQueue->cond_mutex));
1033BOOL ChangeTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period)
1035 struct timespec CurrentTime;
1036 WINPR_TIMER_QUEUE* timerQueue = NULL;
1037 WINPR_TIMER_QUEUE_TIMER* timer = NULL;
1039 if (!TimerQueue || !Timer)
1042 timespec_gettimeofday(&CurrentTime);
1043 timerQueue = (WINPR_TIMER_QUEUE*)TimerQueue;
1044 timer = (WINPR_TIMER_QUEUE_TIMER*)Timer;
1045 pthread_mutex_lock(&(timerQueue->cond_mutex));
1046 RemoveTimerQueueTimer(&(timerQueue->activeHead), timer);
1047 RemoveTimerQueueTimer(&(timerQueue->inactiveHead), timer);
1048 timer->DueTime = DueTime;
1049 timer->Period = Period;
1051 timespec_copy(&(timer->StartTime), &CurrentTime);
1052 timespec_add_ms(&(timer->StartTime), DueTime);
1053 timespec_copy(&(timer->ExpirationTime), &(timer->StartTime));
1054 InsertTimerQueueTimer(&(timerQueue->activeHead), timer);
1055 pthread_cond_signal(&(timerQueue->cond));
1056 pthread_mutex_unlock(&(timerQueue->cond_mutex));
1060BOOL DeleteTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent)
1062 WINPR_TIMER_QUEUE* timerQueue = NULL;
1063 WINPR_TIMER_QUEUE_TIMER* timer = NULL;
1065 if (!TimerQueue || !Timer)
1068 timerQueue = (WINPR_TIMER_QUEUE*)TimerQueue;
1069 timer = (WINPR_TIMER_QUEUE_TIMER*)Timer;
1070 pthread_mutex_lock(&(timerQueue->cond_mutex));
1081 RemoveTimerQueueTimer(&(timerQueue->activeHead), timer);
1082 pthread_cond_signal(&(timerQueue->cond));
1083 pthread_mutex_unlock(&(timerQueue->cond_mutex));
1086 if (CompletionEvent && (CompletionEvent != INVALID_HANDLE_VALUE))
1087 (void)SetEvent(CompletionEvent);