/*
 * Copyright (C) 2010-2016 Free Software Foundation, Inc.
 * Copyright (C) 2015-2016 Red Hat, Inc.
 *
 * Author: Nikos Mavrogiannopoulos
 *
 * This file is part of GnuTLS.
 *
 * The GnuTLS is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>
 *
 */

#include "config.h"
#include "system.h"
#include "gnutls_int.h"
#include "errors.h"

#include <sys/socket.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>

#ifdef _WIN32
#include <windows.h>
#else /* !_WIN32 */
#include <poll.h>
#endif

/* System specific socket function wrappers.
 */

#ifdef _WIN32
/* Do not use the gnulib functions for sending and receiving data.
 * Using them makes gnutls only working with gnulib applications.
 */
#undef send
#undef recv
#undef select

int system_errno(gnutls_transport_ptr p)
{
	int tmperr = WSAGetLastError();
	int ret = 0;
	switch (tmperr) {
	case WSAEWOULDBLOCK:
		ret = EAGAIN;
		break;
	case NO_ERROR:
		ret = 0;
		break;
	case WSAEINTR:
		ret = EINTR;
		break;
	case WSAEMSGSIZE:
		ret = EMSGSIZE;
		break;
	default:
		ret = EIO;
		break;
	}
	WSASetLastError(tmperr);

	return ret;
}

ssize_t system_write(gnutls_transport_ptr ptr, const void *data,
		     size_t data_size)
{
	return send(GNUTLS_POINTER_TO_INT(ptr), data, data_size, 0);
}

ssize_t system_writev(gnutls_transport_ptr_t ptr, const giovec_t *iovec,
		      int iovec_cnt)
{
	WSABUF bufs[32];
	DWORD bytes_sent;
	DWORD to_send_cnt = 0;
	size_t to_send_bytes = 0;

	if ((size_t)iovec_cnt > sizeof(bufs) / sizeof(bufs[0]))
		iovec_cnt = sizeof(bufs) / sizeof(bufs[0]);

	while (to_send_cnt < (DWORD)iovec_cnt && to_send_bytes < SSIZE_MAX) {
		bufs[to_send_cnt].buf = iovec[to_send_cnt].iov_base;

		if (to_send_bytes + iovec[to_send_cnt].iov_len > SSIZE_MAX) {
			/* Return value limit: successful result value cannot
			 * exceed SSIZE_MAX */
			size_t space_left = (size_t)SSIZE_MAX - to_send_bytes;
			bufs[to_send_cnt].len =
				(unsigned long)(space_left > ULONG_MAX ?
							ULONG_MAX :
							space_left);
			to_send_cnt++;
			break;
		}
#ifdef _WIN64
		if (iovec[to_send_cnt].iov_len > ULONG_MAX) {
			/* WSASend() limitation */
			bufs[to_send_cnt].len = ULONG_MAX;
			to_send_cnt++;
			break;
		}
#endif
		bufs[to_send_cnt].len =
			(unsigned long)iovec[to_send_cnt].iov_len;
		to_send_bytes += iovec[to_send_cnt].iov_len;
		to_send_cnt++;
	}

	if (WSASend(GNUTLS_POINTER_TO_INT(ptr), bufs, to_send_cnt, &bytes_sent,
		    0, NULL, NULL) != 0)
		return -1;

	return (ssize_t)bytes_sent;
}

#else /* POSIX */
int system_errno(gnutls_transport_ptr_t ptr)
{
#if defined(_AIX) || defined(AIX)
	if (errno == 0)
		errno = EAGAIN;
#endif

	return errno;
}

static ssize_t _system_writev(gnutls_transport_ptr_t ptr, const giovec_t *iovec,
			      int iovec_cnt, int flags)
{
	struct msghdr hdr;

	memset(&hdr, 0, sizeof(hdr));
	hdr.msg_iov = (struct iovec *)iovec;
	hdr.msg_iovlen = iovec_cnt;

	return sendmsg(GNUTLS_POINTER_TO_INT(ptr), &hdr, flags);
}

#ifdef MSG_NOSIGNAL
ssize_t system_writev_nosignal(gnutls_transport_ptr_t ptr,
			       const giovec_t *iovec, int iovec_cnt)
{
	return _system_writev(ptr, iovec, iovec_cnt, MSG_NOSIGNAL);
}

#endif

ssize_t system_writev(gnutls_transport_ptr_t ptr, const giovec_t *iovec,
		      int iovec_cnt)
{
	return _system_writev(ptr, iovec, iovec_cnt, 0);
}

#endif

ssize_t system_read(gnutls_transport_ptr_t ptr, void *data, size_t data_size)
{
	return recv(GNUTLS_POINTER_TO_INT(ptr), data, data_size, 0);
}

/**
 * gnutls_system_recv_timeout:
 * @ptr: A file descriptor (wrapped in a gnutls_transport_ptr_t pointer)
 * @ms: The number of milliseconds to wait.
 *
 * Wait for data to be received from the provided socket (@ptr) within a
 * timeout period in milliseconds, using select() on the provided @ptr.
 *
 * This function is provided as a helper for constructing custom
 * callbacks for gnutls_transport_set_pull_timeout_function(),
 * which can be used if you rely on socket file descriptors.
 *
 * Returns -1 on error, 0 on timeout, positive value if data are available for reading.
 *
 * Since: 3.4.0
 **/
int gnutls_system_recv_timeout(gnutls_transport_ptr_t ptr, unsigned int ms)
{
	int ret;
	int fd = GNUTLS_POINTER_TO_INT(ptr);
#ifndef _WIN32
	int timeo;
	struct pollfd pfd;

	pfd.fd = fd;
	pfd.events = POLLIN;
	pfd.revents = 0;

	if (ms == GNUTLS_INDEFINITE_TIMEOUT)
		timeo = -1;
	else
		timeo = ms;
	do {
		ret = poll(&pfd, 1, timeo);
	} while (ret == -1 && errno == EINTR);
#else
	fd_set rfds;
	TIMEVAL _tv, *tv = NULL;

	FD_ZERO(&rfds);
	FD_SET(fd, &rfds);

	if (ms != GNUTLS_INDEFINITE_TIMEOUT) {
		_tv.tv_sec = ms / 1000;
		_tv.tv_usec = (ms % 1000) * 1000;
		tv = &_tv;
	}

	ret = select(fd + 1, &rfds, NULL, NULL, tv);
#endif
	if (ret <= 0)
		return ret;

	return ret;
}