/**

 * WinPR: Windows Portable Runtime

 * Serial Communication API

 *

 * Copyright 2011 O.S. Systems Software Ltda.

 * Copyright 2011 Eduardo Fiss Beloni <beloni@ossystems.com.br>

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

 * Copyright 2014 Hewlett-Packard Development Company, L.P.

 *

 * 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

#if defined __linux__ && !defined ANDROID

#include <assert.h>

#include <errno.h>

#include <fcntl.h>

#include <pthread.h>

#include <stdarg.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <termios.h>

#include <unistd.h>

#include <winpr/crt.h>

#include <winpr/comm.h>

#include <winpr/tchar.h>

#include <winpr/wlog.h>

#include <winpr/handle.h>

#include "comm_ioctl.h"

/**

 * Communication Resources:

 * http://msdn.microsoft.com/en-us/library/windows/desktop/aa363196/

 */

#include "comm.h"

static wLog* _Log = NULL;

struct comm_device

{

	LPTSTR name;

	LPTSTR path;

};

typedef struct comm_device COMM_DEVICE;

/* FIXME: get a clever data structure, see also io.h functions */

/* _CommDevices is a NULL-terminated array with a maximun of COMM_DEVICE_MAX COMM_DEVICE */

#define COMM_DEVICE_MAX 128

static COMM_DEVICE** _CommDevices = NULL;

static CRITICAL_SECTION _CommDevicesLock;

static HANDLE_CREATOR _CommHandleCreator;

static pthread_once_t _CommInitialized = PTHREAD_ONCE_INIT;

static int CommGetFd(HANDLE handle)

{

	WINPR_COMM* comm = (WINPR_COMM*)handle;

	if (!CommIsHandled(handle))

		return -1;

	return comm->fd;

}

HANDLE_CREATOR* GetCommHandleCreator(void)

{

	_CommHandleCreator.IsHandled = IsCommDevice;

	_CommHandleCreator.CreateFileA = CommCreateFileA;

	return &_CommHandleCreator;

}

static void _CommInit(void)

{

	/* NB: error management to be done outside of this function */

	assert(_Log == NULL);

	assert(_CommDevices == NULL);

	_CommDevices = (COMM_DEVICE**)calloc(COMM_DEVICE_MAX + 1, sizeof(COMM_DEVICE*));

	if (!_CommDevices)

		return;

	if (!InitializeCriticalSectionEx(&_CommDevicesLock, 0, 0))

	{

		free(_CommDevices);

		_CommDevices = NULL;

		return;

	}

	_Log = WLog_Get("com.winpr.comm");

	assert(_Log != NULL);

}

/**

 * Returns TRUE when the comm module is correctly intialized, FALSE otherwise

 * with ERROR_DLL_INIT_FAILED set as the last error.

 */

static BOOL CommInitialized()

{

	if (pthread_once(&_CommInitialized, _CommInit) != 0)

	{

		SetLastError(ERROR_DLL_INIT_FAILED);

		return FALSE;

	}

	return TRUE;

}

void CommLog_Print(DWORD level, ...)

{

	if (!CommInitialized())

		return;

	va_list ap;

	va_start(ap, level);

	WLog_PrintVA(_Log, level, ap);

	va_end(ap);

}

BOOL BuildCommDCBA(LPCSTR lpDef, LPDCB lpDCB)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL BuildCommDCBW(LPCWSTR lpDef, LPDCB lpDCB)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL BuildCommDCBAndTimeoutsA(LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL BuildCommDCBAndTimeoutsW(LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL CommConfigDialogA(LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL CommConfigDialogW(LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL GetCommConfig(HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hCommDev;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL SetCommConfig(HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hCommDev;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL GetCommMask(HANDLE hFile, PDWORD lpEvtMask)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL SetCommMask(HANDLE hFile, DWORD dwEvtMask)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL GetCommModemStatus(HANDLE hFile, PDWORD lpModemStat)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

/**

 * ERRORS:

 *   ERROR_DLL_INIT_FAILED

 *   ERROR_INVALID_HANDLE

 */

BOOL GetCommProperties(HANDLE hFile, LPCOMMPROP lpCommProp)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	DWORD bytesReturned;

	if (!CommInitialized())

		return FALSE;

	if (!pComm || pComm->Type != HANDLE_TYPE_COMM || !pComm->fd)

	{

		SetLastError(ERROR_INVALID_HANDLE);

		return FALSE;

	}

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_GET_PROPERTIES, NULL, 0, lpCommProp,

	                         sizeof(COMMPROP), &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "GetCommProperties failure.");

		return FALSE;

	}

	return TRUE;

}

/**

 *

 *

 * ERRORS:

 *   ERROR_INVALID_HANDLE

 *   ERROR_INVALID_DATA

 *   ERROR_IO_DEVICE

 *   ERROR_OUTOFMEMORY

 */

BOOL GetCommState(HANDLE hFile, LPDCB lpDCB)

{

	DCB* lpLocalDcb;

	struct termios currentState;

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	DWORD bytesReturned;

	if (!CommInitialized())

		return FALSE;

	if (!pComm || pComm->Type != HANDLE_TYPE_COMM || !pComm->fd)

	{

		SetLastError(ERROR_INVALID_HANDLE);

		return FALSE;

	}

	if (!lpDCB)

	{

		SetLastError(ERROR_INVALID_DATA);

		return FALSE;

	}

	if (lpDCB->DCBlength < sizeof(DCB))

	{

		SetLastError(ERROR_INVALID_DATA);

		return FALSE;

	}

	if (tcgetattr(pComm->fd, &currentState) < 0)

	{

		SetLastError(ERROR_IO_DEVICE);

		return FALSE;

	}

	lpLocalDcb = (DCB*)calloc(1, lpDCB->DCBlength);

	if (lpLocalDcb == NULL)

	{

		SetLastError(ERROR_OUTOFMEMORY);

		return FALSE;

	}

	/* error_handle */

	lpLocalDcb->DCBlength = lpDCB->DCBlength;

	SERIAL_BAUD_RATE baudRate;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_GET_BAUD_RATE, NULL, 0, &baudRate,

	                         sizeof(SERIAL_BAUD_RATE), &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "GetCommState failure: could not get the baud rate.");

		goto error_handle;

	}

	lpLocalDcb->BaudRate = baudRate.BaudRate;

	lpLocalDcb->fBinary = (currentState.c_cflag & ICANON) == 0;

	if (!lpLocalDcb->fBinary)

	{

		CommLog_Print(WLOG_WARN, "Unexpected nonbinary mode, consider to unset the ICANON flag.");

	}

	lpLocalDcb->fParity = (currentState.c_iflag & INPCK) != 0;

	SERIAL_HANDFLOW handflow;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_GET_HANDFLOW, NULL, 0, &handflow,

	                         sizeof(SERIAL_HANDFLOW), &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "GetCommState failure: could not get the handflow settings.");

		goto error_handle;

	}

	lpLocalDcb->fOutxCtsFlow = (handflow.ControlHandShake & SERIAL_CTS_HANDSHAKE) != 0;

	lpLocalDcb->fOutxDsrFlow = (handflow.ControlHandShake & SERIAL_DSR_HANDSHAKE) != 0;

	if (handflow.ControlHandShake & SERIAL_DTR_HANDSHAKE)

	{

		lpLocalDcb->fDtrControl = DTR_CONTROL_HANDSHAKE;

	}

	else if (handflow.ControlHandShake & SERIAL_DTR_CONTROL)

	{

		lpLocalDcb->fDtrControl = DTR_CONTROL_ENABLE;

	}

	else

	{

		lpLocalDcb->fDtrControl = DTR_CONTROL_DISABLE;

	}

	lpLocalDcb->fDsrSensitivity = (handflow.ControlHandShake & SERIAL_DSR_SENSITIVITY) != 0;

	lpLocalDcb->fTXContinueOnXoff = (handflow.FlowReplace & SERIAL_XOFF_CONTINUE) != 0;

	lpLocalDcb->fOutX = (handflow.FlowReplace & SERIAL_AUTO_TRANSMIT) != 0;

	lpLocalDcb->fInX = (handflow.FlowReplace & SERIAL_AUTO_RECEIVE) != 0;

	lpLocalDcb->fErrorChar = (handflow.FlowReplace & SERIAL_ERROR_CHAR) != 0;

	lpLocalDcb->fNull = (handflow.FlowReplace & SERIAL_NULL_STRIPPING) != 0;

	if (handflow.FlowReplace & SERIAL_RTS_HANDSHAKE)

	{

		lpLocalDcb->fRtsControl = RTS_CONTROL_HANDSHAKE;

	}

	else if (handflow.FlowReplace & SERIAL_RTS_CONTROL)

	{

		lpLocalDcb->fRtsControl = RTS_CONTROL_ENABLE;

	}

	else

	{

		lpLocalDcb->fRtsControl = RTS_CONTROL_DISABLE;

	}

	// FIXME: how to get the RTS_CONTROL_TOGGLE state? Does it match the UART 16750's Autoflow

	// Control Enabled bit in its Modem Control Register (MCR)

	lpLocalDcb->fAbortOnError = (handflow.ControlHandShake & SERIAL_ERROR_ABORT) != 0;

	/* lpLocalDcb->fDummy2 not used */

	lpLocalDcb->wReserved = 0; /* must be zero */

	lpLocalDcb->XonLim = handflow.XonLimit;

	lpLocalDcb->XoffLim = handflow.XoffLimit;

	SERIAL_LINE_CONTROL lineControl;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_GET_LINE_CONTROL, NULL, 0, &lineControl,

	                         sizeof(SERIAL_LINE_CONTROL), &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "GetCommState failure: could not get the control settings.");

		goto error_handle;

	}

	lpLocalDcb->ByteSize = lineControl.WordLength;

	lpLocalDcb->Parity = lineControl.Parity;

	lpLocalDcb->StopBits = lineControl.StopBits;

	SERIAL_CHARS serialChars;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_GET_CHARS, NULL, 0, &serialChars,

	                         sizeof(SERIAL_CHARS), &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "GetCommState failure: could not get the serial chars.");

		goto error_handle;

	}

	lpLocalDcb->XonChar = serialChars.XonChar;

	lpLocalDcb->XoffChar = serialChars.XoffChar;

	lpLocalDcb->ErrorChar = serialChars.ErrorChar;

	lpLocalDcb->EofChar = serialChars.EofChar;

	lpLocalDcb->EvtChar = serialChars.EventChar;

	memcpy(lpDCB, lpLocalDcb, lpDCB->DCBlength);

	free(lpLocalDcb);

	return TRUE;

error_handle:

	free(lpLocalDcb);

	return FALSE;

}

/**

 * @return TRUE on success, FALSE otherwise.

 *

 * As of today, SetCommState() can fail half-way with some settings

 * applied and some others not. SetCommState() returns on the first

 * failure met. FIXME: or is it correct?

 *

 * ERRORS:

 *   ERROR_INVALID_HANDLE

 *   ERROR_IO_DEVICE

 */

BOOL SetCommState(HANDLE hFile, LPDCB lpDCB)

{

	struct termios upcomingTermios;

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	DWORD bytesReturned;

	/* FIXME: validate changes according GetCommProperties? */

	if (!CommInitialized())

		return FALSE;

	if (!pComm || pComm->Type != HANDLE_TYPE_COMM || !pComm->fd)

	{

		SetLastError(ERROR_INVALID_HANDLE);

		return FALSE;

	}

	if (!lpDCB)

	{

		SetLastError(ERROR_INVALID_DATA);

		return FALSE;

	}

	/* NB: did the choice to call ioctls first when available and

	   then to setup upcomingTermios. Don't mix both stages. */

	/** ioctl calls stage **/

	SERIAL_BAUD_RATE baudRate;

	baudRate.BaudRate = lpDCB->BaudRate;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_SET_BAUD_RATE, &baudRate, sizeof(SERIAL_BAUD_RATE),

	                         NULL, 0, &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "SetCommState failure: could not set the baud rate.");

		return FALSE;

	}

	SERIAL_CHARS serialChars;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_GET_CHARS, NULL, 0, &serialChars,

	                         sizeof(SERIAL_CHARS), &bytesReturned,

	                         NULL)) /* as of today, required for BreakChar */

	{

		CommLog_Print(WLOG_WARN, "SetCommState failure: could not get the initial serial chars.");

		return FALSE;

	}

	serialChars.XonChar = lpDCB->XonChar;

	serialChars.XoffChar = lpDCB->XoffChar;

	serialChars.ErrorChar = lpDCB->ErrorChar;

	serialChars.EofChar = lpDCB->EofChar;

	serialChars.EventChar = lpDCB->EvtChar;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_SET_CHARS, &serialChars, sizeof(SERIAL_CHARS),

	                         NULL, 0, &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "SetCommState failure: could not set the serial chars.");

		return FALSE;

	}

	SERIAL_LINE_CONTROL lineControl;

	lineControl.StopBits = lpDCB->StopBits;

	lineControl.Parity = lpDCB->Parity;

	lineControl.WordLength = lpDCB->ByteSize;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_SET_LINE_CONTROL, &lineControl,

	                         sizeof(SERIAL_LINE_CONTROL), NULL, 0, &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "SetCommState failure: could not set the control settings.");

		return FALSE;

	}

	SERIAL_HANDFLOW handflow;

	ZeroMemory(&handflow, sizeof(SERIAL_HANDFLOW));

	if (lpDCB->fOutxCtsFlow)

	{

		handflow.ControlHandShake |= SERIAL_CTS_HANDSHAKE;

	}

	if (lpDCB->fOutxDsrFlow)

	{

		handflow.ControlHandShake |= SERIAL_DSR_HANDSHAKE;

	}

	switch (lpDCB->fDtrControl)

	{

		case SERIAL_DTR_HANDSHAKE:

			handflow.ControlHandShake |= DTR_CONTROL_HANDSHAKE;

			break;

		case SERIAL_DTR_CONTROL:

			handflow.ControlHandShake |= DTR_CONTROL_ENABLE;

			break;

		case DTR_CONTROL_DISABLE:

			/* do nothing since handflow is init-zeroed */

			break;

		default:

			CommLog_Print(WLOG_WARN, "Unexpected fDtrControl value: %" PRIu32 "\n",

			              lpDCB->fDtrControl);

			return FALSE;

	}

	if (lpDCB->fDsrSensitivity)

	{

		handflow.ControlHandShake |= SERIAL_DSR_SENSITIVITY;

	}

	if (lpDCB->fTXContinueOnXoff)

	{

		handflow.FlowReplace |= SERIAL_XOFF_CONTINUE;

	}

	if (lpDCB->fOutX)

	{

		handflow.FlowReplace |= SERIAL_AUTO_TRANSMIT;

	}

	if (lpDCB->fInX)

	{

		handflow.FlowReplace |= SERIAL_AUTO_RECEIVE;

	}

	if (lpDCB->fErrorChar)

	{

		handflow.FlowReplace |= SERIAL_ERROR_CHAR;

	}

	if (lpDCB->fNull)

	{

		handflow.FlowReplace |= SERIAL_NULL_STRIPPING;

	}

	switch (lpDCB->fRtsControl)

	{

		case RTS_CONTROL_TOGGLE:

			CommLog_Print(WLOG_WARN, "Unsupported RTS_CONTROL_TOGGLE feature");

			// FIXME: see also GetCommState()

			return FALSE;

		case RTS_CONTROL_HANDSHAKE:

			handflow.FlowReplace |= SERIAL_RTS_HANDSHAKE;

			break;

		case RTS_CONTROL_ENABLE:

			handflow.FlowReplace |= SERIAL_RTS_CONTROL;

			break;

		case RTS_CONTROL_DISABLE:

			/* do nothing since handflow is init-zeroed */

			break;

		default:

			CommLog_Print(WLOG_WARN, "Unexpected fRtsControl value: %" PRIu32 "\n",

			              lpDCB->fRtsControl);

			return FALSE;

	}

	if (lpDCB->fAbortOnError)

	{

		handflow.ControlHandShake |= SERIAL_ERROR_ABORT;

	}

	/* lpDCB->fDummy2 not used */

	/* lpLocalDcb->wReserved  ignored */

	handflow.XonLimit = lpDCB->XonLim;

	handflow.XoffLimit = lpDCB->XoffLim;

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_SET_HANDFLOW, &handflow, sizeof(SERIAL_HANDFLOW),

	                         NULL, 0, &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "SetCommState failure: could not set the handflow settings.");

		return FALSE;

	}

	/** upcomingTermios stage **/

	ZeroMemory(&upcomingTermios, sizeof(struct termios));

	if (tcgetattr(pComm->fd, &upcomingTermios) <

	    0) /* NB: preserves current settings not directly handled by the Communication Functions */

	{

		SetLastError(ERROR_IO_DEVICE);

		return FALSE;

	}

	if (lpDCB->fBinary)

	{

		upcomingTermios.c_lflag &= ~ICANON;

	}

	else

	{

		upcomingTermios.c_lflag |= ICANON;

		CommLog_Print(WLOG_WARN, "Unexpected nonbinary mode, consider to unset the ICANON flag.");

	}

	if (lpDCB->fParity)

	{

		upcomingTermios.c_iflag |= INPCK;

	}

	else

	{

		upcomingTermios.c_iflag &= ~INPCK;

	}

	/* http://msdn.microsoft.com/en-us/library/windows/desktop/aa363423%28v=vs.85%29.aspx

	 *

	 * The SetCommState function reconfigures the communications

	 * resource, but it does not affect the internal output and

	 * input buffers of the specified driver. The buffers are not

	 * flushed, and pending read and write operations are not

	 * terminated prematurely.

	 *

	 * TCSANOW matches the best this definition

	 */

	if (_comm_ioctl_tcsetattr(pComm->fd, TCSANOW, &upcomingTermios) < 0)

	{

		SetLastError(ERROR_IO_DEVICE);

		return FALSE;

	}

	return TRUE;

}

/**

 * ERRORS:

 *   ERROR_INVALID_HANDLE

 */

BOOL GetCommTimeouts(HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	DWORD bytesReturned;

	if (!CommInitialized())

		return FALSE;

	if (!pComm || pComm->Type != HANDLE_TYPE_COMM || !pComm->fd)

	{

		SetLastError(ERROR_INVALID_HANDLE);

		return FALSE;

	}

	/* as of today, SERIAL_TIMEOUTS and COMMTIMEOUTS structures are identical */

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_GET_TIMEOUTS, NULL, 0, lpCommTimeouts,

	                         sizeof(COMMTIMEOUTS), &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "GetCommTimeouts failure.");

		return FALSE;

	}

	return TRUE;

}

/**

 * ERRORS:

 *   ERROR_INVALID_HANDLE

 */

BOOL SetCommTimeouts(HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	DWORD bytesReturned;

	if (!CommInitialized())

		return FALSE;

	if (!pComm || pComm->Type != HANDLE_TYPE_COMM || !pComm->fd)

	{

		SetLastError(ERROR_INVALID_HANDLE);

		return FALSE;

	}

	/* as of today, SERIAL_TIMEOUTS and COMMTIMEOUTS structures are identical */

	if (!CommDeviceIoControl(pComm, IOCTL_SERIAL_SET_TIMEOUTS, lpCommTimeouts, sizeof(COMMTIMEOUTS),

	                         NULL, 0, &bytesReturned, NULL))

	{

		CommLog_Print(WLOG_WARN, "SetCommTimeouts failure.");

		return FALSE;

	}

	return TRUE;

}

BOOL GetDefaultCommConfigA(LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL GetDefaultCommConfigW(LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL SetDefaultCommConfigA(LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL SetDefaultCommConfigW(LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize)

{

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL SetCommBreak(HANDLE hFile)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL ClearCommBreak(HANDLE hFile)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL ClearCommError(HANDLE hFile, PDWORD lpErrors, LPCOMSTAT lpStat)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	if (!CommInitialized())

		return FALSE;

	/* TODO: not implemented */

	if (!pComm)

		return FALSE;

	CommLog_Print(WLOG_ERROR, "%s: Not implemented", __FUNCTION__);

	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

	return FALSE;

}

BOOL PurgeComm(HANDLE hFile, DWORD dwFlags)

{

	WINPR_COMM* pComm = (WINPR_COMM*)hFile;

	DWORD bytesReturned = 0;

	if (!CommInitialized())

		return FALSE;

	if (!pComm || pComm->Type != HANDLE_TYPE_COMM || !pComm->fd)

	{

		SetLastError(ERROR_INVALID_HANDLE);

		return FALSE;

	}