FreeRDP/winpr/libwinpr/synch/event.c

453 lines
9.8 KiB
C
Raw Normal View History

2012-05-29 22:14:26 +04:00
/**
* WinPR: Windows Portable Runtime
* Synchronization Functions
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2017 Armin Novak <armin.novak@thincast.com>
* Copyright 2017 Thincast Technologies GmbH
2012-05-29 22:14:26 +04:00
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
2012-11-27 05:34:36 +04:00
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
2012-05-29 22:14:26 +04:00
2012-11-27 05:34:36 +04:00
#include <winpr/synch.h>
#ifndef _WIN32
#include "synch.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_EVENTFD_H
2013-01-24 00:59:01 +04:00
#include <sys/eventfd.h>
#endif
#include <errno.h>
2013-05-17 01:32:58 +04:00
#include "../handle/handle.h"
#include "../pipe/pipe.h"
2013-05-17 01:32:58 +04:00
2014-08-18 19:22:22 +04:00
#include "../log.h"
#define TAG WINPR_TAG("synch.event")
2014-08-18 19:22:22 +04:00
2015-03-11 17:11:11 +03:00
static BOOL EventCloseHandle(HANDLE handle);
static BOOL EventIsHandled(HANDLE handle)
{
2019-11-06 17:24:51 +03:00
WINPR_TIMER* pEvent = (WINPR_TIMER*)handle;
2015-03-11 17:11:11 +03:00
if (!pEvent || (pEvent->Type != HANDLE_TYPE_EVENT))
2015-03-11 17:11:11 +03:00
{
SetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
return TRUE;
}
static int EventGetFd(HANDLE handle)
{
WINPR_EVENT* event = (WINPR_EVENT*)handle;
2015-03-11 19:57:01 +03:00
if (!EventIsHandled(handle))
return -1;
return event->pipe_fd[0];
2015-03-11 17:11:11 +03:00
}
2019-02-08 11:05:59 +03:00
static BOOL EventCloseHandle_(WINPR_EVENT* event)
{
2019-02-08 11:05:59 +03:00
if (!event)
2015-03-11 17:11:11 +03:00
return FALSE;
if (!event->bAttached)
{
if (event->pipe_fd[0] != -1)
{
close(event->pipe_fd[0]);
event->pipe_fd[0] = -1;
}
if (event->pipe_fd[1] != -1)
{
close(event->pipe_fd[1]);
event->pipe_fd[1] = -1;
}
}
2019-02-08 11:05:59 +03:00
free(event->name);
free(event);
return TRUE;
2015-03-11 17:11:11 +03:00
}
2019-02-08 11:05:59 +03:00
static BOOL EventCloseHandle(HANDLE handle)
{
2019-11-06 17:24:51 +03:00
WINPR_EVENT* event = (WINPR_EVENT*)handle;
2019-02-08 11:05:59 +03:00
if (!EventIsHandled(handle))
return FALSE;
return EventCloseHandle_(event);
}
2019-11-06 17:24:51 +03:00
static HANDLE_OPS ops = { EventIsHandled, EventCloseHandle,
EventGetFd, NULL, /* CleanupHandle */
NULL, NULL,
NULL, NULL,
NULL, NULL,
NULL, NULL,
NULL, NULL,
NULL, NULL,
NULL, NULL,
NULL, NULL };
HANDLE CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState,
LPCWSTR lpName)
{
HANDLE handle;
char* name = NULL;
if (lpName)
{
int rc = ConvertFromUnicode(CP_UTF8, 0, lpName, -1, &name, 0, NULL, NULL);
if (rc < 0)
return NULL;
}
handle = CreateEventA(lpEventAttributes, bManualReset, bInitialState, name);
free(name);
return handle;
}
HANDLE CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState,
LPCSTR lpName)
{
2019-11-06 17:24:51 +03:00
WINPR_EVENT* event = (WINPR_EVENT*)calloc(1, sizeof(WINPR_EVENT));
if (lpEventAttributes)
WLog_WARN(TAG, "%s [%s] does not support lpEventAttributes", __FUNCTION__, lpName);
if (!event)
return NULL;
2019-02-08 11:05:59 +03:00
if (lpName)
event->name = strdup(lpName);
event->bAttached = FALSE;
event->bManualReset = bManualReset;
event->ops = &ops;
WINPR_HANDLE_SET_TYPE_AND_MODE(event, HANDLE_TYPE_EVENT, FD_READ);
if (!event->bManualReset)
WLog_ERR(TAG, "auto-reset events not yet implemented");
event->pipe_fd[0] = -1;
event->pipe_fd[1] = -1;
#ifdef HAVE_SYS_EVENTFD_H
event->pipe_fd[0] = eventfd(0, EFD_NONBLOCK);
if (event->pipe_fd[0] < 0)
goto fail;
2014-08-18 19:22:22 +04:00
2013-01-24 00:59:01 +04:00
#else
if (pipe(event->pipe_fd) < 0)
goto fail;
2014-08-18 19:22:22 +04:00
#endif
if (bInitialState)
{
if (!SetEvent(event))
goto fail;
}
2014-11-16 19:06:42 +03:00
return (HANDLE)event;
fail:
2019-02-08 11:05:59 +03:00
EventCloseHandle_(event);
return NULL;
}
HANDLE CreateEventExW(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCWSTR lpName, DWORD dwFlags,
DWORD dwDesiredAccess)
{
BOOL initial = FALSE;
BOOL manual = FALSE;
if (dwFlags & CREATE_EVENT_INITIAL_SET)
initial = TRUE;
if (dwFlags & CREATE_EVENT_MANUAL_RESET)
manual = TRUE;
if (dwDesiredAccess != 0)
2019-11-06 17:24:51 +03:00
WLog_WARN(TAG, "%s [%s] does not support dwDesiredAccess 0x%08" PRIx32, __FUNCTION__,
lpName, dwDesiredAccess);
return CreateEventW(lpEventAttributes, manual, initial, lpName);
}
HANDLE CreateEventExA(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCSTR lpName, DWORD dwFlags,
DWORD dwDesiredAccess)
{
BOOL initial = FALSE;
BOOL manual = FALSE;
if (dwFlags & CREATE_EVENT_INITIAL_SET)
initial = TRUE;
if (dwFlags & CREATE_EVENT_MANUAL_RESET)
manual = TRUE;
if (dwDesiredAccess != 0)
2019-11-06 17:24:51 +03:00
WLog_WARN(TAG, "%s [%s] does not support dwDesiredAccess 0x%08" PRIx32, __FUNCTION__,
lpName, dwDesiredAccess);
return CreateEventA(lpEventAttributes, manual, initial, lpName);
}
HANDLE OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName)
{
/* TODO: Implement */
WINPR_UNUSED(dwDesiredAccess);
WINPR_UNUSED(bInheritHandle);
WINPR_UNUSED(lpName);
WLog_ERR(TAG, "%s not implemented", __FUNCTION__);
return NULL;
}
2012-05-29 22:14:26 +04:00
HANDLE OpenEventA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
{
/* TODO: Implement */
WINPR_UNUSED(dwDesiredAccess);
WINPR_UNUSED(bInheritHandle);
WINPR_UNUSED(lpName);
WLog_ERR(TAG, "%s not implemented", __FUNCTION__);
return NULL;
}
#ifdef HAVE_SYS_EVENTFD_H
#if !defined(WITH_EVENTFD_READ_WRITE)
static int eventfd_read(int fd, eventfd_t* value)
{
return (read(fd, value, sizeof(*value)) == sizeof(*value)) ? 0 : -1;
}
static int eventfd_write(int fd, eventfd_t value)
{
return (write(fd, &value, sizeof(value)) == sizeof(value)) ? 0 : -1;
}
#endif
#endif
BOOL SetEvent(HANDLE hEvent)
{
ULONG Type;
WINPR_HANDLE* Object;
int length;
BOOL status;
2014-08-18 21:34:47 +04:00
WINPR_EVENT* event;
status = FALSE;
if (winpr_Handle_GetInfo(hEvent, &Type, &Object))
{
2019-11-06 17:24:51 +03:00
event = (WINPR_EVENT*)Object;
#ifdef HAVE_SYS_EVENTFD_H
eventfd_t val = 1;
2013-02-10 02:13:53 +04:00
do
{
length = eventfd_write(event->pipe_fd[0], val);
2019-11-06 17:24:51 +03:00
} while ((length < 0) && (errno == EINTR));
2013-02-10 02:13:53 +04:00
status = (length == 0) ? TRUE : FALSE;
2013-01-24 00:59:01 +04:00
#else
if (WaitForSingleObject(hEvent, 0) != WAIT_OBJECT_0)
{
length = write(event->pipe_fd[1], "-", 1);
if (length == 1)
status = TRUE;
}
else
{
status = TRUE;
}
2014-08-18 19:22:22 +04:00
#endif
}
return status;
}
2012-05-29 22:14:26 +04:00
BOOL ResetEvent(HANDLE hEvent)
{
ULONG Type;
WINPR_HANDLE* Object;
int length;
BOOL status = TRUE;
2014-08-18 21:34:47 +04:00
WINPR_EVENT* event;
if (!winpr_Handle_GetInfo(hEvent, &Type, &Object))
return FALSE;
2019-11-06 17:24:51 +03:00
event = (WINPR_EVENT*)Object;
while (status && WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0)
{
do
{
#ifdef HAVE_SYS_EVENTFD_H
2013-01-24 00:59:01 +04:00
eventfd_t value;
length = eventfd_read(event->pipe_fd[0], &value);
2013-01-24 00:59:01 +04:00
#else
length = read(event->pipe_fd[0], &length, 1);
2013-01-24 00:59:01 +04:00
#endif
2019-11-06 17:24:51 +03:00
} while ((length < 0) && (errno == EINTR));
if (length < 0)
status = FALSE;
}
return status;
}
#endif
2019-11-06 17:24:51 +03:00
HANDLE CreateFileDescriptorEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
BOOL bInitialState, int FileDescriptor, ULONG mode)
{
2012-11-27 05:34:36 +04:00
#ifndef _WIN32
2014-08-18 21:34:47 +04:00
WINPR_EVENT* event;
HANDLE handle = NULL;
2019-11-06 17:24:51 +03:00
event = (WINPR_EVENT*)calloc(1, sizeof(WINPR_EVENT));
if (event)
{
event->bAttached = TRUE;
event->bManualReset = bManualReset;
event->pipe_fd[0] = FileDescriptor;
event->pipe_fd[1] = -1;
event->ops = &ops;
WINPR_HANDLE_SET_TYPE_AND_MODE(event, HANDLE_TYPE_EVENT, mode);
2019-11-06 17:24:51 +03:00
handle = (HANDLE)event;
}
return handle;
2012-11-27 05:34:36 +04:00
#else
return NULL;
#endif
}
2019-11-06 17:24:51 +03:00
HANDLE CreateFileDescriptorEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
BOOL bInitialState, int FileDescriptor, ULONG mode)
{
2019-11-06 17:24:51 +03:00
return CreateFileDescriptorEventW(lpEventAttributes, bManualReset, bInitialState,
FileDescriptor, mode);
}
/**
* Returns an event based on the handle returned by GetEventWaitObject()
*/
2019-11-06 17:24:51 +03:00
HANDLE CreateWaitObjectEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
BOOL bInitialState, void* pObject)
{
#ifndef _WIN32
2019-11-06 17:24:51 +03:00
return CreateFileDescriptorEventW(lpEventAttributes, bManualReset, bInitialState,
(int)(ULONG_PTR)pObject, WINPR_FD_READ);
#else
HANDLE hEvent = NULL;
DuplicateHandle(GetCurrentProcess(), pObject, GetCurrentProcess(), &hEvent, 0, FALSE,
DUPLICATE_SAME_ACCESS);
return hEvent;
#endif
}
/*
* Returns inner file descriptor for usage with select()
* This file descriptor is not usable on Windows
*/
int GetEventFileDescriptor(HANDLE hEvent)
{
2012-11-27 05:34:36 +04:00
#ifndef _WIN32
return winpr_Handle_getFd(hEvent);
2012-11-27 05:34:36 +04:00
#else
return -1;
#endif
}
/*
* Set inner file descriptor for usage with select()
* This file descriptor is not usable on Windows
*/
int SetEventFileDescriptor(HANDLE hEvent, int FileDescriptor, ULONG mode)
{
#ifndef _WIN32
ULONG Type;
WINPR_HANDLE* Object;
2014-08-18 21:34:47 +04:00
WINPR_EVENT* event;
if (!winpr_Handle_GetInfo(hEvent, &Type, &Object))
return -1;
2019-11-06 17:24:51 +03:00
event = (WINPR_EVENT*)Object;
if (!event->bAttached && event->pipe_fd[0] >= 0 && event->pipe_fd[0] != FileDescriptor)
close(event->pipe_fd[0]);
event->bAttached = TRUE;
event->Mode = mode;
event->pipe_fd[0] = FileDescriptor;
return 0;
#else
return -1;
#endif
}
/**
* Returns platform-specific wait object as a void pointer
*
* On Windows, the returned object is the same as the hEvent
* argument and is an event HANDLE usable in WaitForMultipleObjects
*
* On other platforms, the returned object can be cast to an int
* to obtain a file descriptor usable in select()
*/
2014-08-18 21:34:47 +04:00
void* GetEventWaitObject(HANDLE hEvent)
{
#ifndef _WIN32
int fd;
2014-08-18 21:34:47 +04:00
void* obj;
fd = GetEventFileDescriptor(hEvent);
2019-11-06 17:24:51 +03:00
obj = ((void*)(long)fd);
return obj;
#else
return hEvent;
#endif
}