/**

 * WinPR: Windows Portable Runtime

 * Synchronization Functions

 *

 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2014 Hardening <contact@hardening-consulting.com>

 *

 * 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

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_POLL_H

#include <poll.h>

#else

#ifndef _WIN32

#include <sys/select.h>

#endif

#endif

#include <assert.h>

#include <errno.h>

#include <winpr/crt.h>

#include <winpr/synch.h>

#include <winpr/platform.h>

#include "synch.h"

#include "../thread/thread.h"

#include <winpr/thread.h>

#include <winpr/debug.h>

#include "../log.h"

#define TAG WINPR_TAG("sync.wait")

/**

 * WaitForSingleObject

 * WaitForSingleObjectEx

 * WaitForMultipleObjectsEx

 * SignalObjectAndWait

 */

#ifndef _WIN32

#include <stdlib.h>

#include <time.h>

#include <sys/time.h>

#include <sys/wait.h>

#include "../handle/handle.h"

#include "../pipe/pipe.h"

/* clock_gettime is not implemented on OSX prior to 10.12 */

#ifdef __MACH__

#include <mach/mach_time.h>

#ifndef CLOCK_REALTIME

#define CLOCK_REALTIME 0

#endif

#ifndef CLOCK_MONOTONIC

#define CLOCK_MONOTONIC 0

#endif

/* clock_gettime is not implemented on OSX prior to 10.12 */

int _mach_clock_gettime(int clk_id, struct timespec* t);

int _mach_clock_gettime(int clk_id, struct timespec* t)

{

	UINT64 time;

	double seconds;

	double nseconds;

	mach_timebase_info_data_t timebase;

	mach_timebase_info(&timebase);

	time = mach_absolute_time();

	nseconds = ((double)time * (double)timebase.numer) / ((double)timebase.denom);

	seconds = ((double)time * (double)timebase.numer) / ((double)timebase.denom * 1e9);

	t->tv_sec = seconds;

	t->tv_nsec = nseconds;

	return 0;

}

/* if clock_gettime is declared, then __CLOCK_AVAILABILITY will be defined */

#ifdef __CLOCK_AVAILABILITY

/* If we compiled with Mac OSX 10.12 or later, then clock_gettime will be declared

 * * but it may be NULL at runtime. So we need to check before using it. */

int _mach_safe_clock_gettime(int clk_id, struct timespec* t);

int _mach_safe_clock_gettime(int clk_id, struct timespec* t)

{

	if (clock_gettime)

	{

		return clock_gettime(clk_id, t);

	}

	return _mach_clock_gettime(clk_id, t);

}

#define clock_gettime _mach_safe_clock_gettime

#else

#define clock_gettime _mach_clock_gettime

#endif

#endif

static long long ts_difftime(const struct timespec* o, const struct timespec* n)

{

	long long oldValue = o->tv_sec * 1000000000LL + o->tv_nsec;

	long long newValue = n->tv_sec * 1000000000LL + n->tv_nsec;

	return newValue - oldValue;

}

/* Drop in replacement for pthread_mutex_timedlock

 */

#if !defined(HAVE_PTHREAD_MUTEX_TIMEDLOCK)

#include <pthread.h>

static int pthread_mutex_timedlock(pthread_mutex_t* mutex, const struct timespec* timeout)

{

	struct timespec timenow;

	struct timespec sleepytime;

	unsigned long long diff;

	int retcode;

	/* This is just to avoid a completely busy wait */

	clock_gettime(CLOCK_MONOTONIC, &timenow);

	diff = ts_difftime(&timenow, timeout);

	sleepytime.tv_sec = diff / 1000000000LL;

	sleepytime.tv_nsec = diff % 1000000000LL;

	while ((retcode = pthread_mutex_trylock(mutex)) == EBUSY)

	{

		clock_gettime(CLOCK_MONOTONIC, &timenow);

		if (ts_difftime(timeout, &timenow) >= 0)

		{

			return ETIMEDOUT;

		}

		nanosleep(&sleepytime, NULL);

	}

	return retcode;

}

#endif

#ifdef HAVE_POLL_H

static DWORD handle_mode_to_pollevent(ULONG mode)

{

	DWORD event = 0;

	if (mode & WINPR_FD_READ)

		event |= POLLIN;

	if (mode & WINPR_FD_WRITE)

		event |= POLLOUT;

	return event;

}

#endif

static void ts_add_ms(struct timespec* ts, DWORD dwMilliseconds)

{

	ts->tv_sec += dwMilliseconds / 1000L;

	ts->tv_nsec += (dwMilliseconds % 1000L) * 1000000L;

	ts->tv_sec += ts->tv_nsec / 1000000000L;

	ts->tv_nsec = ts->tv_nsec % 1000000000L;

}

static int waitOnFd(int fd, ULONG mode, DWORD dwMilliseconds)

{

	int status;

#ifdef HAVE_POLL_H

	struct pollfd pollfds;

	pollfds.fd = fd;

	pollfds.events = handle_mode_to_pollevent(mode);

	pollfds.revents = 0;

	do

	{

		status = poll(&pollfds, 1, dwMilliseconds);

	} while ((status < 0) && (errno == EINTR));

#else

	struct timeval timeout;

	fd_set rfds, wfds;

	fd_set* prfds = NULL;

	fd_set* pwfds = NULL;

	fd_set* pefds = NULL;

	FD_ZERO(&rfds);

	FD_SET(fd, &rfds);

	FD_ZERO(&wfds);

	FD_SET(fd, &wfds);

	ZeroMemory(&timeout, sizeof(timeout));

	if (mode & WINPR_FD_READ)

		prfds = &rfd;;

	if (mode & WINPR_FD_WRITE)

		pwfds = &wfd;;

	if ((dwMilliseconds != INFINITE) && (dwMilliseconds != 0))

	{

		timeout.tv_sec = dwMilliseconds / 1000;

		timeout.tv_usec = (dwMilliseconds % 1000) * 1000;

	}

	do

	{

		status =

		    select(fd + 1, prfds, pwfds, pefds, (dwMilliseconds == INFINITE) ? NULL : &timeout);

	} while (status < 0 && (errno == EINTR));

#endif

	return status;

}

DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds)

{

	ULONG Type;

	WINPR_HANDLE* Object;

	if (!winpr_Handle_GetInfo(hHandle, &Type, &Object))

	{

		WLog_ERR(TAG, "invalid hHandle.");

		SetLastError(ERROR_INVALID_HANDLE);

		return WAIT_FAILED;

	}

	if (Type == HANDLE_TYPE_PROCESS)

	{

		WINPR_PROCESS* process;

		process = (WINPR_PROCESS*)Object;

		if (process->pid != waitpid(process->pid, &(process->status), 0))

		{

			WLog_ERR(TAG, "waitpid failure [%d] %s", errno, strerror(errno));

			SetLastError(ERROR_INTERNAL_ERROR);

			return WAIT_FAILED;

		}

		process->dwExitCode = (DWORD)process->status;

		return WAIT_OBJECT_0;

	}

	else if (Type == HANDLE_TYPE_MUTEX)

	{

		WINPR_MUTEX* mutex;

		mutex = (WINPR_MUTEX*)Object;

		if (dwMilliseconds != INFINITE)

		{

			int status;

			struct timespec timeout;

			clock_gettime(CLOCK_MONOTONIC, &timeout);

			ts_add_ms(&timeout, dwMilliseconds);

			status = pthread_mutex_timedlock(&mutex->mutex, &timeout);

			if (ETIMEDOUT == status)

				return WAIT_TIMEOUT;

		}

		else

		{

			pthread_mutex_lock(&mutex->mutex);

		}

		return WAIT_OBJECT_0;

	}

	else

	{

		int status;

		int fd = winpr_Handle_getFd(Object);

		if (fd < 0)

		{

			WLog_ERR(TAG, "winpr_Handle_getFd did not return a fd!");

			SetLastError(ERROR_INVALID_HANDLE);

			return WAIT_FAILED;

		}

		status = waitOnFd(fd, Object->Mode, dwMilliseconds);

		if (status < 0)

		{

			WLog_ERR(TAG, "waitOnFd() failure [%d] %s", errno, strerror(errno));

			SetLastError(ERROR_INTERNAL_ERROR);

			return WAIT_FAILED;

		}

		if (status != 1)

			return WAIT_TIMEOUT;

		return winpr_Handle_cleanup(Object);

	}

	SetLastError(ERROR_INTERNAL_ERROR);

	return WAIT_FAILED;

}

DWORD WaitForSingleObjectEx(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable)

{

	if (bAlertable)

	{

		/* TODO: Implement */

		WLog_ERR(TAG, "%s: Not implemented: bAlertable", __FUNCTION__);

		return WAIT_FAILED;

	}

	return WaitForSingleObject(hHandle, dwMilliseconds);

}

DWORD WaitForMultipleObjects(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll,

                             DWORD dwMilliseconds)

{

	struct timespec starttime;

	struct timespec timenow;

	unsigned long long diff;

	DWORD signalled;

	DWORD polled;

	DWORD* poll_map = NULL;

	BOOL* signalled_idx = NULL;

	int fd = -1;

	DWORD index;

	int status;

	ULONG Type;

	BOOL signal_handled = FALSE;

	WINPR_HANDLE* Object;

#ifdef HAVE_POLL_H

	struct pollfd* pollfds;

#else

	int maxfd;

	fd_set rfds;

	fd_set wfds;

	struct timeval timeout;

#endif

	if (!nCount || (nCount > MAXIMUM_WAIT_OBJECTS))

	{

		WLog_ERR(TAG, "invalid handles count(%" PRIu32 ")", nCount);

		return WAIT_FAILED;

	}

	if (bWaitAll)

	{

		signalled_idx = alloca(nCount * sizeof(BOOL));

		memset(signalled_idx, FALSE, nCount * sizeof(BOOL));

		poll_map = alloca(nCount * sizeof(DWORD));

		memset(poll_map, 0, nCount * sizeof(DWORD));

	}

#ifdef HAVE_POLL_H

	pollfds = alloca(nCount * sizeof(struct pollfd));

#endif

	signalled = 0;

	do

	{

#ifndef HAVE_POLL_H

		fd_set* prfds = NULL;

		fd_set* pwfds = NULL;

		maxfd = 0;

		FD_ZERO(&rfds);

		FD_ZERO(&wfds);

		ZeroMemory(&timeout, sizeof(timeout));

#endif

		if (bWaitAll && (dwMilliseconds != INFINITE))

			clock_gettime(CLOCK_MONOTONIC, &starttime);

		polled = 0;

		for (index = 0; index < nCount; index++)

		{

			if (bWaitAll)

			{

				if (signalled_idx[index])

					continue;

				poll_map[polled] = index;

			}

			if (!winpr_Handle_GetInfo(lpHandles[index], &Type, &Object))

			{

				WLog_ERR(TAG, "invalid event file descriptor");

				SetLastError(ERROR_INVALID_HANDLE);

				return WAIT_FAILED;

			}

			fd = winpr_Handle_getFd(Object);

			if (fd == -1)

			{

				WLog_ERR(TAG, "invalid file descriptor");

				SetLastError(ERROR_INVALID_HANDLE);

				return WAIT_FAILED;

			}

#ifdef HAVE_POLL_H

			pollfds[polled].fd = fd;

			pollfds[polled].events = handle_mode_to_pollevent(Object->Mode);

			pollfds[polled].revents = 0;

#else

			if (Object->Mode & WINPR_FD_READ)

			{

				FD_SET(fd, &rfds);

				prfds = &rfd;;

			}

			if (Object->Mode & WINPR_FD_WRITE)

			{

				FD_SET(fd, &wfds);

				pwfds = &wfd;;

			}

			if (fd > maxfd)

				maxfd = fd;

#endif

			polled++;

		}

#ifdef HAVE_POLL_H

		do

		{

			status = poll(pollfds, polled, dwMilliseconds);

		} while (status < 0 && errno == EINTR);

#else

		if ((dwMilliseconds != INFINITE) && (dwMilliseconds != 0))

		{

			timeout.tv_sec = dwMilliseconds / 1000;

			timeout.tv_usec = (dwMilliseconds % 1000) * 1000;

		}

		do

		{

			status =

			    select(maxfd + 1, prfds, pwfds, 0, (dwMilliseconds == INFINITE) ? NULL : &timeout);

		} while (status < 0 && errno == EINTR);

#endif

		if (status < 0)

		{

#ifdef HAVE_POLL_H

			WLog_ERR(TAG, "poll() handle %d (%" PRIu32 ") failure [%d] %s", index, nCount, errno,

			         strerror(errno));

#else

			WLog_ERR(TAG, "select() handle %d (%" PRIu32 ") failure [%d] %s", index, nCount, errno,

			         strerror(errno));

#endif

			winpr_log_backtrace(TAG, WLOG_ERROR, 20);

			SetLastError(ERROR_INTERNAL_ERROR);

			return WAIT_FAILED;

		}

		if (status == 0)

			return WAIT_TIMEOUT;

		if (bWaitAll && (dwMilliseconds != INFINITE))

		{

			clock_gettime(CLOCK_MONOTONIC, &timenow);

			diff = ts_difftime(&timenow, &starttime);

			if (diff / 1000 > dwMilliseconds)

				return WAIT_TIMEOUT;

			else

				dwMilliseconds -= (diff / 1000);

		}

		signal_handled = FALSE;

		for (index = 0; index < polled; index++)

		{

			DWORD idx;

			BOOL signal_set = FALSE;

			if (bWaitAll)

				idx = poll_map[index];

			else

				idx = index;

			if (!winpr_Handle_GetInfo(lpHandles[idx], &Type, &Object))

			{

				WLog_ERR(TAG, "invalid hHandle.");

				SetLastError(ERROR_INVALID_HANDLE);

				return WAIT_FAILED;

			}

			fd = winpr_Handle_getFd(lpHandles[idx]);

			if (fd == -1)

			{

				WLog_ERR(TAG, "invalid file descriptor");

				SetLastError(ERROR_INVALID_HANDLE);

				return WAIT_FAILED;

			}

#ifdef HAVE_POLL_H

			signal_set = pollfds[index].revents & pollfds[index].events;

#else

			if (Object->Mode & WINPR_FD_READ)

				signal_set = FD_ISSET(fd, &rfds) ? 1 : 0;

			if (Object->Mode & WINPR_FD_WRITE)

				signal_set |= FD_ISSET(fd, &wfds) ? 1 : 0;

#endif

			if (signal_set)

			{

				DWORD rc = winpr_Handle_cleanup(lpHandles[idx]);

				if (rc != WAIT_OBJECT_0)

					return rc;

				if (bWaitAll)

				{

					signalled_idx[idx] = TRUE;

					/* Continue checks from last position. */

					for (; signalled < nCount; signalled++)

					{

						if (!signalled_idx[signalled])

							break;

					}

				}

				if (!bWaitAll)

					return (WAIT_OBJECT_0 + index);

				if (signalled >= nCount)

					return (WAIT_OBJECT_0);

				signal_handled = TRUE;

			}

		}

	} while (bWaitAll || !signal_handled);

	WLog_ERR(TAG, "failed (unknown error)");

	SetLastError(ERROR_INTERNAL_ERROR);

	return WAIT_FAILED;

}

DWORD WaitForMultipleObjectsEx(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll,

                               DWORD dwMilliseconds, BOOL bAlertable)

{

	if (bAlertable)

	{

		/* TODO: Implement */

		WLog_ERR(TAG, "%s: Not implemented: bAlertable", __FUNCTION__);

		return WAIT_FAILED;

	}

	return WaitForMultipleObjects(nCount, lpHandles, bWaitAll, dwMilliseconds);

}

DWORD SignalObjectAndWait(HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds,

                          BOOL bAlertable)

{

	WLog_ERR(TAG, "%s: Not implemented.", __FUNCTION__);

	SetLastError(ERROR_NOT_SUPPORTED);

	return WAIT_FAILED;

}

#endif