ethstream/netutil.c

#include "netutil.h"
#include "compat.h"
#include <errno.h>
#include <sys/types.h>
#include <stdio.h>

/* Initialize networking */
void net_init(void)
{
#ifdef __WIN32__
	WSADATA blah;
	WSAStartup(0x0101, &blah);
#endif
}

/* Set socket blocking/nonblocking */
int soblock(int socket, int blocking)
{
#ifdef __WIN32__
	unsigned long arg = blocking ? 0 : 1;
	if (ioctlsocket(socket, FIONBIO, &arg) != 0)
		return -1;
	return 0;
#else
	int sockopt;

	/* Get flags */
	sockopt = fcntl(socket, F_GETFL);
	if (sockopt == -1) {
		return -1;
	}

	/* Modify */
	if (blocking)
		sockopt &= ~O_NONBLOCK;
	else
		sockopt |= O_NONBLOCK;

	/* Set flags */
	if (fcntl(socket, F_SETFL, sockopt) != 0)
		return -1;

	return 0;
#endif
}

/* Like connect(2), but with a timeout.  Socket must be non-blocking. */
int
connect_timeout(int s, const struct sockaddr *serv_addr, socklen_t addrlen,
		struct timeval *timeout)
{
	int ret;
	fd_set writefds;
	fd_set exceptfds;
	int optval;
	socklen_t optlen;

	/* Start connect */
	ret = connect(s, serv_addr, addrlen);

	if (ret == 0) {
		/* Success */
		return 0;
	}

	/* Check for immediate failure */
#ifdef __WIN32__
	errno = WSAGetLastError();
	if (ret < 0 && errno != WSAEWOULDBLOCK && errno != WSAEINVAL)
		return -1;
#else
	if (ret < 0 && errno != EINPROGRESS && errno != EALREADY)
		return -1;
#endif

	/* In progress, wait for result. */
	FD_ZERO(&writefds);
	FD_SET(s, &writefds);
	FD_ZERO(&exceptfds);
	FD_SET(s, &exceptfds);
	ret = select(s + 1, NULL, &writefds, &exceptfds, timeout);
	if (ret < 0) {
		/* Error */
		return -1;
	}
	if (ret == 0) {
		/* Timed out */
		errno = ETIMEDOUT;
		return -1;
	}

	/* Check the socket state */
	optlen = sizeof(optval);
	if (getsockopt(s, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen) != 0)
		return -1;

	if (optval != 0) {
		/* Connection failed. */
		errno = optval;
		return -1;
	}

	/* On Windows, SO_ERROR sometimes shows no error but the connection
	   still failed.  Sigh. */
	if (FD_ISSET(s, &exceptfds) || !FD_ISSET(s, &writefds)) {
		errno = EIO;
		return -1;
	}

	/* Success */
	return 0;
}

/* Like send(2), but with a timeout.  Socket must be non-blocking.
   The timeout only applies if no data at all is sent -- this function
   may still send less than requested. */
ssize_t
send_timeout(int s, const void *buf, size_t len, int flags,
	     struct timeval * timeout)
{
	fd_set writefds;
	int ret;

	FD_ZERO(&writefds);
	FD_SET(s, &writefds);
	ret = select(s + 1, NULL, &writefds, NULL, timeout);
	if (ret == 0) {
		/* Timed out */
		errno = ETIMEDOUT;
		return -1;
	}
	if (ret != 1) {
		/* Error */
		return -1;
	}

	return send(s, buf, len, flags);
}

/* Like recv(2), but with a timeout.  Socket must be non-blocking. 
   The timeout only applies if no data at all is received -- this
   function may still return less than requested. */
ssize_t
recv_timeout(int s, void *buf, size_t len, int flags, struct timeval * timeout)
{
	fd_set readfds;
	int ret;

	FD_ZERO(&readfds);
	FD_SET(s, &readfds);
	ret = select(s + 1, &readfds, NULL, NULL, timeout);
	if (ret == 0) {
		/* Timed out */
		errno = ETIMEDOUT;
		return -1;
	}
	if (ret != 1) {
		/* Error */
		return -1;
	}

	return recv(s, buf, len, flags);
}

/* Like recvfrom(2), but with a timeout.  Socket must be non-blocking. 
   The timeout only applies if no data at all is received -- this
   function may still return less than requested. */
ssize_t
recvfrom_timeout(int s, void *buf, size_t len, int flags,
		 struct sockaddr * address, socklen_t * address_len,
		 struct timeval * timeout)
{
	fd_set readfds;
	int ret;

	FD_ZERO(&readfds);
	FD_SET(s, &readfds);
	ret = select(s + 1, &readfds, NULL, NULL, timeout);
	if (ret == 0) {
		/* Timed out */
		errno = ETIMEDOUT;
		return -1;
	}
	if (ret != 1) {
		/* Error */
		return -1;
	}

	return recvfrom(s, buf, len, flags, address, address_len);
}

/* Like send_timeout, but retries (with the same timeout) in case of
   partial transfers.  This is a stronger attempt to send all
   requested data. */
ssize_t
send_all_timeout(int s, const void *buf, size_t len, int flags,
		 struct timeval * timeout)
{
	struct timeval tv;
	size_t left = len;
	ssize_t ret;

	while (left > 0) {
		tv.tv_sec = timeout->tv_sec;
		tv.tv_usec = timeout->tv_usec;
		ret = send_timeout(s, buf, left, flags, &tv);

		if (ret < 0)
			return ret;

		if (ret == 0)
			break;

		left -= ret;
		buf += ret;
	}

	return len - left;
}

/* Like recv_timeout, but retries (with the same timeout) in case of
   partial transfers.  This is a stronger attempt to recv all
   requested data. */
ssize_t
recv_all_timeout(int s, void *buf, size_t len, int flags,
		 struct timeval * timeout)
{
	struct timeval tv;
	size_t left = len;
	ssize_t ret;

	while (left > 0) {
		tv.tv_sec = timeout->tv_sec;
		tv.tv_usec = timeout->tv_usec;
		ret = recv_timeout(s, buf, left, flags, &tv);

		if (ret < 0)
			return ret;

		if (ret == 0)
			break;

		left -= ret;
		buf += ret;
	}

	return len - left;
}