src/backend/port/win32/socket.c - cloudberry - Git at Google

 /*-------------------------------------------------------------------------
  *
  * socket.c
  *	  Microsoft Windows Win32 Socket Functions
  *
  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
  *	  src/backend/port/win32/socket.c
  *
  *-------------------------------------------------------------------------
  */

 #include "postgres.h"

 /*
  * Indicate if pgwin32_recv() and pgwin32_send() should operate
  * in non-blocking mode.
  *
  * Since the socket emulation layer always sets the actual socket to
  * non-blocking mode in order to be able to deliver signals, we must
  * specify this in a separate flag if we actually need non-blocking
  * operation.
  *
  * This flag changes the behaviour *globally* for all socket operations,
  * so it should only be set for very short periods of time.
  */
 int			pgwin32_noblock = 0;

 /* Undef the macros defined in win32.h, so we can access system functions */
 #undef socket
 #undef bind
 #undef listen
 #undef accept
 #undef connect
 #undef select
 #undef recv
 #undef send

 /*
  * Blocking socket functions implemented so they listen on both
  * the socket and the signal event, required for signal handling.
  */

 /*
  * Convert the last socket error code into errno
  *
  * Note: where there is a direct correspondence between a WSAxxx error code
  * and a Berkeley error symbol, this mapping is actually a no-op, because
  * in win32_port.h we redefine the network-related Berkeley error symbols to
  * have the values of their WSAxxx counterparts.  The point of the switch is
  * mostly to translate near-miss error codes into something that's sensible
  * in the Berkeley universe.
  */
 static void
 TranslateSocketError(void)
 {
 	switch (WSAGetLastError())
 	{
 		case WSAEINVAL:
 		case WSANOTINITIALISED:
 		case WSAEINVALIDPROVIDER:
 		case WSAEINVALIDPROCTABLE:
 		case WSAEDESTADDRREQ:
 			errno = EINVAL;
 			break;
 		case WSAEINPROGRESS:
 			errno = EINPROGRESS;
 			break;
 		case WSAEFAULT:
 			errno = EFAULT;
 			break;
 		case WSAEISCONN:
 			errno = EISCONN;
 			break;
 		case WSAEMSGSIZE:
 			errno = EMSGSIZE;
 			break;
 		case WSAEAFNOSUPPORT:
 			errno = EAFNOSUPPORT;
 			break;
 		case WSAEMFILE:
 			errno = EMFILE;
 			break;
 		case WSAENOBUFS:
 			errno = ENOBUFS;
 			break;
 		case WSAEPROTONOSUPPORT:
 		case WSAEPROTOTYPE:
 		case WSAESOCKTNOSUPPORT:
 			errno = EPROTONOSUPPORT;
 			break;
 		case WSAECONNABORTED:
 			errno = ECONNABORTED;
 			break;
 		case WSAECONNREFUSED:
 			errno = ECONNREFUSED;
 			break;
 		case WSAECONNRESET:
 			errno = ECONNRESET;
 			break;
 		case WSAEINTR:
 			errno = EINTR;
 			break;
 		case WSAENOTSOCK:
 			errno = ENOTSOCK;
 			break;
 		case WSAEOPNOTSUPP:
 			errno = EOPNOTSUPP;
 			break;
 		case WSAEWOULDBLOCK:
 			errno = EWOULDBLOCK;
 			break;
 		case WSAEACCES:
 			errno = EACCES;
 			break;
 		case WSAEADDRINUSE:
 			errno = EADDRINUSE;
 			break;
 		case WSAEADDRNOTAVAIL:
 			errno = EADDRNOTAVAIL;
 			break;
 		case WSAEHOSTDOWN:
 			errno = EHOSTDOWN;
 			break;
 		case WSAEHOSTUNREACH:
 		case WSAHOST_NOT_FOUND:
 			errno = EHOSTUNREACH;
 			break;
 		case WSAENETDOWN:
 			errno = ENETDOWN;
 			break;
 		case WSAENETUNREACH:
 			errno = ENETUNREACH;
 			break;
 		case WSAENETRESET:
 			errno = ENETRESET;
 			break;
 		case WSAENOTCONN:
 		case WSAESHUTDOWN:
 		case WSAEDISCON:
 			errno = ENOTCONN;
 			break;
 		case WSAETIMEDOUT:
 			errno = ETIMEDOUT;
 			break;
 		default:
 			ereport(NOTICE,
 					(errmsg_internal("unrecognized win32 socket error code: %d",
 									 WSAGetLastError())));
 			errno = EINVAL;
 			break;
 	}
 }

 static int
 pgwin32_poll_signals(void)
 {
 	if (UNBLOCKED_SIGNAL_QUEUE())
 	{
 		pgwin32_dispatch_queued_signals();
 		errno = EINTR;
 		return 1;
 	}
 	return 0;
 }

 static int
 isDataGram(SOCKET s)
 {
 	int			type;
 	int			typelen = sizeof(type);

 	if (getsockopt(s, SOL_SOCKET, SO_TYPE, (char *) &type, &typelen))
 		return 1;

 	return (type == SOCK_DGRAM) ? 1 : 0;
 }

 int
 pgwin32_waitforsinglesocket(SOCKET s, int what, int timeout)
 {
 	static HANDLE waitevent = INVALID_HANDLE_VALUE;
 	static SOCKET current_socket = INVALID_SOCKET;
 	static int	isUDP = 0;
 	HANDLE		events[2];
 	int			r;

 	/* Create an event object just once and use it on all future calls */
 	if (waitevent == INVALID_HANDLE_VALUE)
 	{
 		waitevent = CreateEvent(NULL, TRUE, FALSE, NULL);

 		if (waitevent == INVALID_HANDLE_VALUE)
 			ereport(ERROR,
 					(errmsg_internal("could not create socket waiting event: error code %lu", GetLastError())));
 	}
 	else if (!ResetEvent(waitevent))
 		ereport(ERROR,
 				(errmsg_internal("could not reset socket waiting event: error code %lu", GetLastError())));

 	/*
 	 * Track whether socket is UDP or not.  (NB: most likely, this is both
 	 * useless and wrong; there is no reason to think that the behavior of
 	 * WSAEventSelect is different for TCP and UDP.)
 	 */
 	if (current_socket != s)
 		isUDP = isDataGram(s);
 	current_socket = s;

 	/*
 	 * Attach event to socket.  NOTE: we must detach it again before
 	 * returning, since other bits of code may try to attach other events to
 	 * the socket.
 	 */
 	if (WSAEventSelect(s, waitevent, what) != 0)
 	{
 		TranslateSocketError();
 		return 0;
 	}

 	events[0] = pgwin32_signal_event;
 	events[1] = waitevent;

 	/*
 	 * Just a workaround of unknown locking problem with writing in UDP socket
 	 * under high load: Client's pgsql backend sleeps infinitely in
 	 * WaitForMultipleObjectsEx, pgstat process sleeps in pgwin32_select().
 	 * So, we will wait with small timeout(0.1 sec) and if socket is still
 	 * blocked, try WSASend (see comments in pgwin32_select) and wait again.
 	 */
 	if ((what & FD_WRITE) && isUDP)
 	{
 		for (;;)
 		{
 			r = WaitForMultipleObjectsEx(2, events, FALSE, 100, TRUE);

 			if (r == WAIT_TIMEOUT)
 			{
 				char		c;
 				WSABUF		buf;
 				DWORD		sent;

 				buf.buf = &c;
 				buf.len = 0;

 				r = WSASend(s, &buf, 1, &sent, 0, NULL, NULL);
 				if (r == 0)		/* Completed - means things are fine! */
 				{
 					WSAEventSelect(s, NULL, 0);
 					return 1;
 				}
 				else if (WSAGetLastError() != WSAEWOULDBLOCK)
 				{
 					TranslateSocketError();
 					WSAEventSelect(s, NULL, 0);
 					return 0;
 				}
 			}
 			else
 				break;
 		}
 	}
 	else
 		r = WaitForMultipleObjectsEx(2, events, FALSE, timeout, TRUE);

 	WSAEventSelect(s, NULL, 0);

 	if (r == WAIT_OBJECT_0 || r == WAIT_IO_COMPLETION)
 	{
 		pgwin32_dispatch_queued_signals();
 		errno = EINTR;
 		return 0;
 	}
 	if (r == WAIT_OBJECT_0 + 1)
 		return 1;
 	if (r == WAIT_TIMEOUT)
 	{
 		errno = EWOULDBLOCK;
 		return 0;
 	}
 	ereport(ERROR,
 			(errmsg_internal("unrecognized return value from WaitForMultipleObjects: %d (error code %lu)", r, GetLastError())));
 	return 0;
 }

 /*
  * Create a socket, setting it to overlapped and non-blocking
  */
 SOCKET
 pgwin32_socket(int af, int type, int protocol)
 {
 	SOCKET		s;
 	unsigned long on = 1;

 	s = WSASocket(af, type, protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
 	if (s == INVALID_SOCKET)
 	{
 		TranslateSocketError();
 		return INVALID_SOCKET;
 	}

 	if (ioctlsocket(s, FIONBIO, &on))
 	{
 		TranslateSocketError();
 		closesocket(s);
 		return INVALID_SOCKET;
 	}
 	errno = 0;

 	return s;
 }

 int
 pgwin32_bind(SOCKET s, struct sockaddr *addr, int addrlen)
 {
 	int			res;

 	res = bind(s, addr, addrlen);
 	if (res < 0)
 		TranslateSocketError();
 	return res;
 }

 int
 pgwin32_listen(SOCKET s, int backlog)
 {
 	int			res;

 	res = listen(s, backlog);
 	if (res < 0)
 		TranslateSocketError();
 	return res;
 }

 SOCKET
 pgwin32_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
 {
 	SOCKET		rs;

 	/*
 	 * Poll for signals, but don't return with EINTR, since we don't handle
 	 * that in pqcomm.c
 	 */
 	pgwin32_poll_signals();

 	rs = WSAAccept(s, addr, addrlen, NULL, 0);
 	if (rs == INVALID_SOCKET)
 	{
 		TranslateSocketError();
 		return INVALID_SOCKET;
 	}
 	return rs;
 }


 /* No signal delivery during connect. */
 int
 pgwin32_connect(SOCKET s, const struct sockaddr *addr, int addrlen)
 {
 	int			r;

 	r = WSAConnect(s, addr, addrlen, NULL, NULL, NULL, NULL);
 	if (r == 0)
 		return 0;

 	if (WSAGetLastError() != WSAEWOULDBLOCK)
 	{
 		TranslateSocketError();
 		return -1;
 	}

 	while (pgwin32_waitforsinglesocket(s, FD_CONNECT, INFINITE) == 0)
 	{
 		/* Loop endlessly as long as we are just delivering signals */
 	}

 	return 0;
 }

 int
 pgwin32_recv(SOCKET s, char *buf, int len, int f)
 {
 	WSABUF		wbuf;
 	int			r;
 	DWORD		b;
 	DWORD		flags = f;
 	int			n;

 	if (pgwin32_poll_signals())
 		return -1;

 	wbuf.len = len;
 	wbuf.buf = buf;

 	r = WSARecv(s, &wbuf, 1, &b, &flags, NULL, NULL);
 	if (r != SOCKET_ERROR)
 		return b;				/* success */

 	if (WSAGetLastError() != WSAEWOULDBLOCK)
 	{
 		TranslateSocketError();
 		return -1;
 	}

 	if (pgwin32_noblock)
 	{
 		/*
 		 * No data received, and we are in "emulated non-blocking mode", so
 		 * return indicating that we'd block if we were to continue.
 		 */
 		errno = EWOULDBLOCK;
 		return -1;
 	}

 	/* We're in blocking mode, so wait for data */

 	for (n = 0; n < 5; n++)
 	{
 		if (pgwin32_waitforsinglesocket(s, FD_READ | FD_CLOSE | FD_ACCEPT,
 										INFINITE) == 0)
 			return -1;			/* errno already set */

 		r = WSARecv(s, &wbuf, 1, &b, &flags, NULL, NULL);
 		if (r != SOCKET_ERROR)
 			return b;			/* success */
 		if (WSAGetLastError() != WSAEWOULDBLOCK)
 		{
 			TranslateSocketError();
 			return -1;
 		}

 		/*
 		 * There seem to be cases on win2k (at least) where WSARecv can return
 		 * WSAEWOULDBLOCK even when pgwin32_waitforsinglesocket claims the
 		 * socket is readable.  In this case, just sleep for a moment and try
 		 * again.  We try up to 5 times - if it fails more than that it's not
 		 * likely to ever come back.
 		 */
 		pg_usleep(10000);
 	}
 	ereport(NOTICE,
 			(errmsg_internal("could not read from ready socket (after retries)")));
 	errno = EWOULDBLOCK;
 	return -1;
 }

 /*
  * The second argument to send() is defined by SUS to be a "const void *"
  * and so we use the same signature here to keep compilers happy when
  * handling callers.
  *
  * But the buf member of a WSABUF struct is defined as "char *", so we cast
  * the second argument to that here when assigning it, also to keep compilers
  * happy.
  */

 int
 pgwin32_send(SOCKET s, const void *buf, int len, int flags)
 {
 	WSABUF		wbuf;
 	int			r;
 	DWORD		b;

 	if (pgwin32_poll_signals())
 		return -1;

 	wbuf.len = len;
 	wbuf.buf = (char *) buf;

 	/*
 	 * Readiness of socket to send data to UDP socket may be not true: socket
 	 * can become busy again! So loop until send or error occurs.
 	 */
 	for (;;)
 	{
 		r = WSASend(s, &wbuf, 1, &b, flags, NULL, NULL);
 		if (r != SOCKET_ERROR && b > 0)
 			/* Write succeeded right away */
 			return b;

 		if (r == SOCKET_ERROR &&
 			WSAGetLastError() != WSAEWOULDBLOCK)
 		{
 			TranslateSocketError();
 			return -1;
 		}

 		if (pgwin32_noblock)
 		{
 			/*
 			 * No data sent, and we are in "emulated non-blocking mode", so
 			 * return indicating that we'd block if we were to continue.
 			 */
 			errno = EWOULDBLOCK;
 			return -1;
 		}

 		/* No error, zero bytes */

 		if (pgwin32_waitforsinglesocket(s, FD_WRITE | FD_CLOSE, INFINITE) == 0)
 			return -1;
 	}

 	return -1;
 }


 /*
  * Wait for activity on one or more sockets.
  * While waiting, allow signals to run
  *
  * NOTE! Currently does not implement exceptfds check,
  * since it is not used in postgresql!
  */
 int
 pgwin32_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout)
 {
 	WSAEVENT	events[FD_SETSIZE * 2]; /* worst case is readfds totally
 										 * different from writefds, so
 										 * 2*FD_SETSIZE sockets */
 	SOCKET		sockets[FD_SETSIZE * 2];
 	int			numevents = 0;
 	int			i;
 	int			r;
 	DWORD		timeoutval = WSA_INFINITE;
 	FD_SET		outreadfds;
 	FD_SET		outwritefds;
 	int			nummatches = 0;

 	Assert(exceptfds == NULL);

 	if (pgwin32_poll_signals())
 		return -1;

 	FD_ZERO(&outreadfds);
 	FD_ZERO(&outwritefds);

 	/*
 	 * Windows does not guarantee to log an FD_WRITE network event indicating
 	 * that more data can be sent unless the previous send() failed with
 	 * WSAEWOULDBLOCK.  While our caller might well have made such a call, we
 	 * cannot assume that here.  Therefore, if waiting for write-ready, force
 	 * the issue by doing a dummy send().  If the dummy send() succeeds,
 	 * assume that the socket is in fact write-ready, and return immediately.
 	 * Also, if it fails with something other than WSAEWOULDBLOCK, return a
 	 * write-ready indication to let our caller deal with the error condition.
 	 */
 	if (writefds != NULL)
 	{
 		for (i = 0; i < writefds->fd_count; i++)
 		{
 			char		c;
 			WSABUF		buf;
 			DWORD		sent;

 			buf.buf = &c;
 			buf.len = 0;

 			r = WSASend(writefds->fd_array[i], &buf, 1, &sent, 0, NULL, NULL);
 			if (r == 0 || WSAGetLastError() != WSAEWOULDBLOCK)
 				FD_SET(writefds->fd_array[i], &outwritefds);
 		}

 		/* If we found any write-ready sockets, just return them immediately */
 		if (outwritefds.fd_count > 0)
 		{
 			memcpy(writefds, &outwritefds, sizeof(fd_set));
 			if (readfds)
 				FD_ZERO(readfds);
 			return outwritefds.fd_count;
 		}
 	}


 	/* Now set up for an actual select */

 	if (timeout != NULL)
 	{
 		/* timeoutval is in milliseconds */
 		timeoutval = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
 	}

 	if (readfds != NULL)
 	{
 		for (i = 0; i < readfds->fd_count; i++)
 		{
 			events[numevents] = WSACreateEvent();
 			sockets[numevents] = readfds->fd_array[i];
 			numevents++;
 		}
 	}
 	if (writefds != NULL)
 	{
 		for (i = 0; i < writefds->fd_count; i++)
 		{
 			if (!readfds ||
 				!FD_ISSET(writefds->fd_array[i], readfds))
 			{
 				/* If the socket is not in the read list */
 				events[numevents] = WSACreateEvent();
 				sockets[numevents] = writefds->fd_array[i];
 				numevents++;
 			}
 		}
 	}

 	for (i = 0; i < numevents; i++)
 	{
 		int			flags = 0;

 		if (readfds && FD_ISSET(sockets[i], readfds))
 			flags |= FD_READ | FD_ACCEPT | FD_CLOSE;

 		if (writefds && FD_ISSET(sockets[i], writefds))
 			flags |= FD_WRITE | FD_CLOSE;

 		if (WSAEventSelect(sockets[i], events[i], flags) != 0)
 		{
 			TranslateSocketError();
 			/* release already-assigned event objects */
 			while (--i >= 0)
 				WSAEventSelect(sockets[i], NULL, 0);
 			for (i = 0; i < numevents; i++)
 				WSACloseEvent(events[i]);
 			return -1;
 		}
 	}

 	events[numevents] = pgwin32_signal_event;
 	r = WaitForMultipleObjectsEx(numevents + 1, events, FALSE, timeoutval, TRUE);
 	if (r != WAIT_TIMEOUT && r != WAIT_IO_COMPLETION && r != (WAIT_OBJECT_0 + numevents))
 	{
 		/*
 		 * We scan all events, even those not signaled, in case more than one
 		 * event has been tagged but Wait.. can only return one.
 		 */
 		WSANETWORKEVENTS resEvents;

 		for (i = 0; i < numevents; i++)
 		{
 			ZeroMemory(&resEvents, sizeof(resEvents));
 			if (WSAEnumNetworkEvents(sockets[i], events[i], &resEvents) != 0)
 				elog(ERROR, "failed to enumerate network events: error code %d",
 					 WSAGetLastError());
 			/* Read activity? */
 			if (readfds && FD_ISSET(sockets[i], readfds))
 			{
 				if ((resEvents.lNetworkEvents & FD_READ) ||
 					(resEvents.lNetworkEvents & FD_ACCEPT) ||
 					(resEvents.lNetworkEvents & FD_CLOSE))
 				{
 					FD_SET(sockets[i], &outreadfds);

 					nummatches++;
 				}
 			}
 			/* Write activity? */
 			if (writefds && FD_ISSET(sockets[i], writefds))
 			{
 				if ((resEvents.lNetworkEvents & FD_WRITE) ||
 					(resEvents.lNetworkEvents & FD_CLOSE))
 				{
 					FD_SET(sockets[i], &outwritefds);

 					nummatches++;
 				}
 			}
 		}
 	}

 	/* Clean up all the event objects */
 	for (i = 0; i < numevents; i++)
 	{
 		WSAEventSelect(sockets[i], NULL, 0);
 		WSACloseEvent(events[i]);
 	}

 	if (r == WSA_WAIT_TIMEOUT)
 	{
 		if (readfds)
 			FD_ZERO(readfds);
 		if (writefds)
 			FD_ZERO(writefds);
 		return 0;
 	}

 	/* Signal-like events. */
 	if (r == WAIT_OBJECT_0 + numevents || r == WAIT_IO_COMPLETION)
 	{
 		pgwin32_dispatch_queued_signals();
 		errno = EINTR;
 		if (readfds)
 			FD_ZERO(readfds);
 		if (writefds)
 			FD_ZERO(writefds);
 		return -1;
 	}

 	/* Overwrite socket sets with our resulting values */
 	if (readfds)
 		memcpy(readfds, &outreadfds, sizeof(fd_set));
 	if (writefds)
 		memcpy(writefds, &outwritefds, sizeof(fd_set));
 	return nummatches;
 }
	/*-------------------------------------------------------------------------
	*
	* socket.c
	* Microsoft Windows Win32 Socket Functions
	*
	* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
	*
	* IDENTIFICATION
	* src/backend/port/win32/socket.c
	*
	*-------------------------------------------------------------------------
	*/

	#include "postgres.h"

	/*
	* Indicate if pgwin32_recv() and pgwin32_send() should operate
	* in non-blocking mode.
	*
	* Since the socket emulation layer always sets the actual socket to
	* non-blocking mode in order to be able to deliver signals, we must
	* specify this in a separate flag if we actually need non-blocking
	* operation.
	*
	* This flag changes the behaviour globally for all socket operations,
	* so it should only be set for very short periods of time.
	*/
	int pgwin32_noblock = 0;

	/* Undef the macros defined in win32.h, so we can access system functions */
	#undef socket
	#undef bind
	#undef listen
	#undef accept
	#undef connect
	#undef select
	#undef recv
	#undef send

	/*
	* Blocking socket functions implemented so they listen on both
	* the socket and the signal event, required for signal handling.
	*/

	/*
	* Convert the last socket error code into errno
	*
	* Note: where there is a direct correspondence between a WSAxxx error code
	* and a Berkeley error symbol, this mapping is actually a no-op, because
	* in win32_port.h we redefine the network-related Berkeley error symbols to
	* have the values of their WSAxxx counterparts. The point of the switch is
	* mostly to translate near-miss error codes into something that's sensible
	* in the Berkeley universe.
	*/
	static void
	TranslateSocketError(void)
	{
	switch (WSAGetLastError())
	{
	case WSAEINVAL:
	case WSANOTINITIALISED:
	case WSAEINVALIDPROVIDER:
	case WSAEINVALIDPROCTABLE:
	case WSAEDESTADDRREQ:
	errno = EINVAL;
	break;
	case WSAEINPROGRESS:
	errno = EINPROGRESS;
	break;
	case WSAEFAULT:
	errno = EFAULT;
	break;
	case WSAEISCONN:
	errno = EISCONN;
	break;
	case WSAEMSGSIZE:
	errno = EMSGSIZE;
	break;
	case WSAEAFNOSUPPORT:
	errno = EAFNOSUPPORT;
	break;
	case WSAEMFILE:
	errno = EMFILE;
	break;
	case WSAENOBUFS:
	errno = ENOBUFS;
	break;
	case WSAEPROTONOSUPPORT:
	case WSAEPROTOTYPE:
	case WSAESOCKTNOSUPPORT:
	errno = EPROTONOSUPPORT;
	break;
	case WSAECONNABORTED:
	errno = ECONNABORTED;
	break;
	case WSAECONNREFUSED:
	errno = ECONNREFUSED;
	break;
	case WSAECONNRESET:
	errno = ECONNRESET;
	break;
	case WSAEINTR:
	errno = EINTR;
	break;
	case WSAENOTSOCK:
	errno = ENOTSOCK;
	break;
	case WSAEOPNOTSUPP:
	errno = EOPNOTSUPP;
	break;
	case WSAEWOULDBLOCK:
	errno = EWOULDBLOCK;
	break;
	case WSAEACCES:
	errno = EACCES;
	break;
	case WSAEADDRINUSE:
	errno = EADDRINUSE;
	break;
	case WSAEADDRNOTAVAIL:
	errno = EADDRNOTAVAIL;
	break;
	case WSAEHOSTDOWN:
	errno = EHOSTDOWN;
	break;
	case WSAEHOSTUNREACH:
	case WSAHOST_NOT_FOUND:
	errno = EHOSTUNREACH;
	break;
	case WSAENETDOWN:
	errno = ENETDOWN;
	break;
	case WSAENETUNREACH:
	errno = ENETUNREACH;
	break;
	case WSAENETRESET:
	errno = ENETRESET;
	break;
	case WSAENOTCONN:
	case WSAESHUTDOWN:
	case WSAEDISCON:
	errno = ENOTCONN;
	break;
	case WSAETIMEDOUT:
	errno = ETIMEDOUT;
	break;
	default:
	ereport(NOTICE,
	(errmsg_internal("unrecognized win32 socket error code: %d",
	WSAGetLastError())));
	errno = EINVAL;
	break;
	}
	}

	static int
	pgwin32_poll_signals(void)
	{
	if (UNBLOCKED_SIGNAL_QUEUE())
	{
	pgwin32_dispatch_queued_signals();
	errno = EINTR;
	return 1;
	}
	return 0;
	}

	static int
	isDataGram(SOCKET s)
	{
	int type;
	int typelen = sizeof(type);

	if (getsockopt(s, SOL_SOCKET, SO_TYPE, (char *) &type, &typelen))
	return 1;

	return (type == SOCK_DGRAM) ? 1 : 0;
	}

	int
	pgwin32_waitforsinglesocket(SOCKET s, int what, int timeout)
	{
	static HANDLE waitevent = INVALID_HANDLE_VALUE;
	static SOCKET current_socket = INVALID_SOCKET;
	static int isUDP = 0;
	HANDLE events[2];
	int r;

	/* Create an event object just once and use it on all future calls */
	if (waitevent == INVALID_HANDLE_VALUE)
	{
	waitevent = CreateEvent(NULL, TRUE, FALSE, NULL);

	if (waitevent == INVALID_HANDLE_VALUE)
	ereport(ERROR,
	(errmsg_internal("could not create socket waiting event: error code %lu", GetLastError())));
	}
	else if (!ResetEvent(waitevent))
	ereport(ERROR,
	(errmsg_internal("could not reset socket waiting event: error code %lu", GetLastError())));

	/*
	* Track whether socket is UDP or not. (NB: most likely, this is both
	* useless and wrong; there is no reason to think that the behavior of
	* WSAEventSelect is different for TCP and UDP.)
	*/
	if (current_socket != s)
	isUDP = isDataGram(s);
	current_socket = s;

	/*
	* Attach event to socket. NOTE: we must detach it again before
	* returning, since other bits of code may try to attach other events to
	* the socket.
	*/
	if (WSAEventSelect(s, waitevent, what) != 0)
	{
	TranslateSocketError();
	return 0;
	}

	events[0] = pgwin32_signal_event;
	events[1] = waitevent;

	/*
	* Just a workaround of unknown locking problem with writing in UDP socket
	* under high load: Client's pgsql backend sleeps infinitely in
	* WaitForMultipleObjectsEx, pgstat process sleeps in pgwin32_select().
	* So, we will wait with small timeout(0.1 sec) and if socket is still
	* blocked, try WSASend (see comments in pgwin32_select) and wait again.
	*/
	if ((what & FD_WRITE) && isUDP)
	{
	for (;;)
	{
	r = WaitForMultipleObjectsEx(2, events, FALSE, 100, TRUE);

	if (r == WAIT_TIMEOUT)
	{
	char c;
	WSABUF buf;
	DWORD sent;

	buf.buf = &c;
	buf.len = 0;

	r = WSASend(s, &buf, 1, &sent, 0, NULL, NULL);
	if (r == 0) /* Completed - means things are fine! */
	{
	WSAEventSelect(s, NULL, 0);
	return 1;
	}
	else if (WSAGetLastError() != WSAEWOULDBLOCK)
	{
	TranslateSocketError();
	WSAEventSelect(s, NULL, 0);
	return 0;
	}
	}
	else
	break;
	}
	}
	else
	r = WaitForMultipleObjectsEx(2, events, FALSE, timeout, TRUE);

	WSAEventSelect(s, NULL, 0);

	if (r == WAIT_OBJECT_0 \|\| r == WAIT_IO_COMPLETION)
	{
	pgwin32_dispatch_queued_signals();
	errno = EINTR;
	return 0;
	}
	if (r == WAIT_OBJECT_0 + 1)
	return 1;
	if (r == WAIT_TIMEOUT)
	{
	errno = EWOULDBLOCK;
	return 0;
	}
	ereport(ERROR,
	(errmsg_internal("unrecognized return value from WaitForMultipleObjects: %d (error code %lu)", r, GetLastError())));
	return 0;
	}

	/*
	* Create a socket, setting it to overlapped and non-blocking
	*/
	SOCKET
	pgwin32_socket(int af, int type, int protocol)
	{
	SOCKET s;
	unsigned long on = 1;

	s = WSASocket(af, type, protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (s == INVALID_SOCKET)
	{
	TranslateSocketError();
	return INVALID_SOCKET;
	}

	if (ioctlsocket(s, FIONBIO, &on))
	{
	TranslateSocketError();
	closesocket(s);
	return INVALID_SOCKET;
	}
	errno = 0;

	return s;
	}

	int
	pgwin32_bind(SOCKET s, struct sockaddr *addr, int addrlen)
	{
	int res;

	res = bind(s, addr, addrlen);
	if (res < 0)
	TranslateSocketError();
	return res;
	}

	int
	pgwin32_listen(SOCKET s, int backlog)
	{
	int res;

	res = listen(s, backlog);
	if (res < 0)
	TranslateSocketError();
	return res;
	}

	SOCKET
	pgwin32_accept(SOCKET s, struct sockaddr addr, int addrlen)
	{
	SOCKET rs;

	/*
	* Poll for signals, but don't return with EINTR, since we don't handle
	* that in pqcomm.c
	*/
	pgwin32_poll_signals();

	rs = WSAAccept(s, addr, addrlen, NULL, 0);
	if (rs == INVALID_SOCKET)
	{
	TranslateSocketError();
	return INVALID_SOCKET;
	}
	return rs;
	}


	/* No signal delivery during connect. */
	int
	pgwin32_connect(SOCKET s, const struct sockaddr *addr, int addrlen)
	{
	int r;

	r = WSAConnect(s, addr, addrlen, NULL, NULL, NULL, NULL);
	if (r == 0)
	return 0;

	if (WSAGetLastError() != WSAEWOULDBLOCK)
	{
	TranslateSocketError();
	return -1;
	}

	while (pgwin32_waitforsinglesocket(s, FD_CONNECT, INFINITE) == 0)
	{
	/* Loop endlessly as long as we are just delivering signals */
	}

	return 0;
	}

	int
	pgwin32_recv(SOCKET s, char *buf, int len, int f)
	{
	WSABUF wbuf;
	int r;
	DWORD b;
	DWORD flags = f;
	int n;

	if (pgwin32_poll_signals())
	return -1;

	wbuf.len = len;
	wbuf.buf = buf;

	r = WSARecv(s, &wbuf, 1, &b, &flags, NULL, NULL);
	if (r != SOCKET_ERROR)
	return b; /* success */

	if (WSAGetLastError() != WSAEWOULDBLOCK)
	{
	TranslateSocketError();
	return -1;
	}

	if (pgwin32_noblock)
	{
	/*
	* No data received, and we are in "emulated non-blocking mode", so
	* return indicating that we'd block if we were to continue.
	*/
	errno = EWOULDBLOCK;
	return -1;
	}

	/* We're in blocking mode, so wait for data */

	for (n = 0; n < 5; n++)
	{
	if (pgwin32_waitforsinglesocket(s, FD_READ \| FD_CLOSE \| FD_ACCEPT,
	INFINITE) == 0)
	return -1; /* errno already set */

	r = WSARecv(s, &wbuf, 1, &b, &flags, NULL, NULL);
	if (r != SOCKET_ERROR)
	return b; /* success */
	if (WSAGetLastError() != WSAEWOULDBLOCK)
	{
	TranslateSocketError();
	return -1;
	}

	/*
	* There seem to be cases on win2k (at least) where WSARecv can return
	* WSAEWOULDBLOCK even when pgwin32_waitforsinglesocket claims the
	* socket is readable. In this case, just sleep for a moment and try
	* again. We try up to 5 times - if it fails more than that it's not
	* likely to ever come back.
	*/
	pg_usleep(10000);
	}
	ereport(NOTICE,
	(errmsg_internal("could not read from ready socket (after retries)")));
	errno = EWOULDBLOCK;
	return -1;
	}

	/*
	* The second argument to send() is defined by SUS to be a "const void *"
	* and so we use the same signature here to keep compilers happy when
	* handling callers.
	*
	* But the buf member of a WSABUF struct is defined as "char *", so we cast
	* the second argument to that here when assigning it, also to keep compilers
	* happy.
	*/

	int
	pgwin32_send(SOCKET s, const void *buf, int len, int flags)
	{
	WSABUF wbuf;
	int r;
	DWORD b;

	if (pgwin32_poll_signals())
	return -1;

	wbuf.len = len;
	wbuf.buf = (char *) buf;

	/*
	* Readiness of socket to send data to UDP socket may be not true: socket
	* can become busy again! So loop until send or error occurs.
	*/
	for (;;)
	{
	r = WSASend(s, &wbuf, 1, &b, flags, NULL, NULL);
	if (r != SOCKET_ERROR && b > 0)
	/* Write succeeded right away */
	return b;

	if (r == SOCKET_ERROR &&
	WSAGetLastError() != WSAEWOULDBLOCK)
	{
	TranslateSocketError();
	return -1;
	}

	if (pgwin32_noblock)
	{
	/*
	* No data sent, and we are in "emulated non-blocking mode", so
	* return indicating that we'd block if we were to continue.
	*/
	errno = EWOULDBLOCK;
	return -1;
	}

	/* No error, zero bytes */

	if (pgwin32_waitforsinglesocket(s, FD_WRITE \| FD_CLOSE, INFINITE) == 0)
	return -1;
	}

	return -1;
	}


	/*
	* Wait for activity on one or more sockets.
	* While waiting, allow signals to run
	*
	* NOTE! Currently does not implement exceptfds check,
	* since it is not used in postgresql!
	*/
	int
	pgwin32_select(int nfds, fd_set readfds, fd_set writefds, fd_set exceptfds, const struct timeval timeout)
	{
	WSAEVENT events[FD_SETSIZE * 2]; /* worst case is readfds totally
	* different from writefds, so
	* 2FD_SETSIZE sockets /
	SOCKET sockets[FD_SETSIZE * 2];
	int numevents = 0;
	int i;
	int r;
	DWORD timeoutval = WSA_INFINITE;
	FD_SET outreadfds;
	FD_SET outwritefds;
	int nummatches = 0;

	Assert(exceptfds == NULL);

	if (pgwin32_poll_signals())
	return -1;

	FD_ZERO(&outreadfds);
	FD_ZERO(&outwritefds);

	/*
	* Windows does not guarantee to log an FD_WRITE network event indicating
	* that more data can be sent unless the previous send() failed with
	* WSAEWOULDBLOCK. While our caller might well have made such a call, we
	* cannot assume that here. Therefore, if waiting for write-ready, force
	* the issue by doing a dummy send(). If the dummy send() succeeds,
	* assume that the socket is in fact write-ready, and return immediately.
	* Also, if it fails with something other than WSAEWOULDBLOCK, return a
	* write-ready indication to let our caller deal with the error condition.
	*/
	if (writefds != NULL)
	{
	for (i = 0; i < writefds->fd_count; i++)
	{
	char c;
	WSABUF buf;
	DWORD sent;

	buf.buf = &c;
	buf.len = 0;

	r = WSASend(writefds->fd_array[i], &buf, 1, &sent, 0, NULL, NULL);
	if (r == 0 \|\| WSAGetLastError() != WSAEWOULDBLOCK)
	FD_SET(writefds->fd_array[i], &outwritefds);
	}

	/* If we found any write-ready sockets, just return them immediately */
	if (outwritefds.fd_count > 0)
	{
	memcpy(writefds, &outwritefds, sizeof(fd_set));
	if (readfds)
	FD_ZERO(readfds);
	return outwritefds.fd_count;
	}
	}


	/* Now set up for an actual select */

	if (timeout != NULL)
	{
	/* timeoutval is in milliseconds */
	timeoutval = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
	}

	if (readfds != NULL)
	{
	for (i = 0; i < readfds->fd_count; i++)
	{
	events[numevents] = WSACreateEvent();
	sockets[numevents] = readfds->fd_array[i];
	numevents++;
	}
	}
	if (writefds != NULL)
	{
	for (i = 0; i < writefds->fd_count; i++)
	{
	if (!readfds \|\|
	!FD_ISSET(writefds->fd_array[i], readfds))
	{
	/* If the socket is not in the read list */
	events[numevents] = WSACreateEvent();
	sockets[numevents] = writefds->fd_array[i];
	numevents++;
	}
	}
	}

	for (i = 0; i < numevents; i++)
	{
	int flags = 0;

	if (readfds && FD_ISSET(sockets[i], readfds))
	flags \|= FD_READ \| FD_ACCEPT \| FD_CLOSE;

	if (writefds && FD_ISSET(sockets[i], writefds))
	flags \|= FD_WRITE \| FD_CLOSE;

	if (WSAEventSelect(sockets[i], events[i], flags) != 0)
	{
	TranslateSocketError();
	/* release already-assigned event objects */
	while (--i >= 0)
	WSAEventSelect(sockets[i], NULL, 0);
	for (i = 0; i < numevents; i++)
	WSACloseEvent(events[i]);
	return -1;
	}
	}

	events[numevents] = pgwin32_signal_event;
	r = WaitForMultipleObjectsEx(numevents + 1, events, FALSE, timeoutval, TRUE);
	if (r != WAIT_TIMEOUT && r != WAIT_IO_COMPLETION && r != (WAIT_OBJECT_0 + numevents))
	{
	/*
	* We scan all events, even those not signaled, in case more than one
	* event has been tagged but Wait.. can only return one.
	*/
	WSANETWORKEVENTS resEvents;

	for (i = 0; i < numevents; i++)
	{
	ZeroMemory(&resEvents, sizeof(resEvents));
	if (WSAEnumNetworkEvents(sockets[i], events[i], &resEvents) != 0)
	elog(ERROR, "failed to enumerate network events: error code %d",
	WSAGetLastError());
	/* Read activity? */
	if (readfds && FD_ISSET(sockets[i], readfds))
	{
	if ((resEvents.lNetworkEvents & FD_READ) \|\|
	(resEvents.lNetworkEvents & FD_ACCEPT) \|\|
	(resEvents.lNetworkEvents & FD_CLOSE))
	{
	FD_SET(sockets[i], &outreadfds);

	nummatches++;
	}
	}
	/* Write activity? */
	if (writefds && FD_ISSET(sockets[i], writefds))
	{
	if ((resEvents.lNetworkEvents & FD_WRITE) \|\|
	(resEvents.lNetworkEvents & FD_CLOSE))
	{
	FD_SET(sockets[i], &outwritefds);

	nummatches++;
	}
	}
	}
	}

	/* Clean up all the event objects */
	for (i = 0; i < numevents; i++)
	{
	WSAEventSelect(sockets[i], NULL, 0);
	WSACloseEvent(events[i]);
	}

	if (r == WSA_WAIT_TIMEOUT)
	{
	if (readfds)
	FD_ZERO(readfds);
	if (writefds)
	FD_ZERO(writefds);
	return 0;
	}

	/* Signal-like events. */
	if (r == WAIT_OBJECT_0 + numevents \|\| r == WAIT_IO_COMPLETION)
	{
	pgwin32_dispatch_queued_signals();
	errno = EINTR;
	if (readfds)
	FD_ZERO(readfds);
	if (writefds)
	FD_ZERO(writefds);
	return -1;
	}

	/* Overwrite socket sets with our resulting values */
	if (readfds)
	memcpy(readfds, &outreadfds, sizeof(fd_set));
	if (writefds)
	memcpy(writefds, &outwritefds, sizeof(fd_set));
	return nummatches;
	}