tcp.c

 
#include <freerdp/config.h>
 
#include "settings.h"
 
#include <time.h>
#include <errno.h>
#include <fcntl.h>
 
#include <winpr/crt.h>
#include <winpr/platform.h>
#include <winpr/winsock.h>
 
#include "rdp.h"
#include "utils.h"
 
#if !defined(_WIN32)
 
#include <netdb.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <net/if.h>
#include <sys/types.h>
#include <arpa/inet.h>
 
#ifdef WINPR_HAVE_POLL_H
#include <poll.h>
#else
#include <time.h>
#include <sys/select.h>
#endif
 
#if defined(__FreeBSD__) || defined(__OpenBSD__)
#ifndef SOL_TCP
#define SOL_TCP IPPROTO_TCP
#endif
#endif
 
#ifdef __APPLE__
#ifndef SOL_TCP
#define SOL_TCP IPPROTO_TCP
#endif
#ifndef TCP_KEEPIDLE
#define TCP_KEEPIDLE TCP_KEEPALIVE
#endif
#endif
 
#else
 
#include <winpr/windows.h>
 
#include <winpr/crt.h>
 
#define SHUT_RDWR SD_BOTH
#define close(_fd) closesocket(_fd)
 
#endif
 
#include <freerdp/log.h>
 
#include <winpr/stream.h>
 
#include "tcp.h"
#include "../crypto/opensslcompat.h"
 
#if defined(HAVE_AF_VSOCK_H)
#include <ctype.h>
#include <linux/vm_sockets.h>
#endif
 
#define TAG FREERDP_TAG("core")
 
/* Simple Socket BIO */
 
typedef struct
{
  SOCKET socket;
  HANDLE hEvent;
} WINPR_BIO_SIMPLE_SOCKET;
 
static int transport_bio_simple_init(BIO* bio, SOCKET socket, int shutdown);
static int transport_bio_simple_uninit(BIO* bio);
 
static int transport_bio_simple_write(BIO* bio, const char* buf, int size)
{
  int error = 0;
  int status = 0;
  WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
 
  if (!buf)
    return 0;
 
  BIO_clear_flags(bio, BIO_FLAGS_WRITE);
  status = _send(ptr->socket, buf, size, 0);
 
  if (status <= 0)
  {
    error = WSAGetLastError();
 
    if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
        (error == WSAEALREADY))
    {
      BIO_set_flags(bio, (BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY));
    }
    else
    {
      BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
    }
  }
 
  return status;
}
 
static int transport_bio_simple_read(BIO* bio, char* buf, int size)
{
  int error = 0;
  int status = 0;
  WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
 
  if (!buf)
    return 0;
 
  BIO_clear_flags(bio, BIO_FLAGS_READ);
  (void)WSAResetEvent(ptr->hEvent);
  status = _recv(ptr->socket, buf, size, 0);
 
  if (status > 0)
  {
    return status;
  }
 
  if (status == 0)
  {
    BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
    return 0;
  }
 
  error = WSAGetLastError();
 
  if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
      (error == WSAEALREADY))
  {
    BIO_set_flags(bio, (BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY));
  }
  else
  {
    BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
  }
 
  return -1;
}
 
static int transport_bio_simple_puts(WINPR_ATTR_UNUSED BIO* bio, WINPR_ATTR_UNUSED const char* str)
{
  return -2;
}
 
static int transport_bio_simple_gets(WINPR_ATTR_UNUSED BIO* bio, WINPR_ATTR_UNUSED char* str,
                                     WINPR_ATTR_UNUSED int size)
{
  return 1;
}
 
static long transport_bio_simple_ctrl(BIO* bio, int cmd, long arg1, void* arg2)
{
  int status = -1;
  WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
 
  switch (cmd)
  {
    case BIO_C_SET_SOCKET:
      transport_bio_simple_uninit(bio);
      transport_bio_simple_init(bio, (SOCKET)arg2, (int)arg1);
      return 1;
    case BIO_C_GET_SOCKET:
      if (!BIO_get_init(bio) || !arg2)
        return 0;
 
      *((SOCKET*)arg2) = ptr->socket;
      return 1;
    case BIO_C_GET_EVENT:
      if (!BIO_get_init(bio) || !arg2)
        return 0;
 
      *((HANDLE*)arg2) = ptr->hEvent;
      return 1;
    case BIO_C_SET_NONBLOCK:
    {
#ifndef _WIN32
      int flags = 0;
      flags = fcntl((int)ptr->socket, F_GETFL);
 
      if (flags == -1)
        return 0;
 
      if (arg1)
        (void)fcntl((int)ptr->socket, F_SETFL, flags | O_NONBLOCK);
      else
        (void)fcntl((int)ptr->socket, F_SETFL, flags & ~(O_NONBLOCK));
 
#else
      /* the internal socket is always non-blocking */
#endif
      return 1;
    }
    case BIO_C_WAIT_READ:
    {
      int timeout = (int)arg1;
      int sockfd = (int)ptr->socket;
#ifdef WINPR_HAVE_POLL_H
      struct pollfd pollset;
      pollset.fd = sockfd;
      pollset.events = POLLIN;
      pollset.revents = 0;
 
      do
      {
        status = poll(&pollset, 1, timeout);
      } while ((status < 0) && (errno == EINTR));
 
#else
      fd_set rset = WINPR_C_ARRAY_INIT;
      struct timeval tv = WINPR_C_ARRAY_INIT;
      FD_ZERO(&rset);
      FD_SET(sockfd, &rset);
 
      if (timeout)
      {
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = (timeout % 1000) * 1000;
      }
 
      do
      {
        status = select(sockfd + 1, &rset, nullptr, nullptr, timeout ? &tv : nullptr);
      } while ((status < 0) && (errno == EINTR));
 
#endif
      /* Convert timeout to error return */
      if (status == 0)
        errno = ETIMEDOUT;
    }
    break;
 
    case BIO_C_WAIT_WRITE:
    {
      int timeout = (int)arg1;
      int sockfd = (int)ptr->socket;
#ifdef WINPR_HAVE_POLL_H
      struct pollfd pollset;
      pollset.fd = sockfd;
      pollset.events = POLLOUT;
      pollset.revents = 0;
 
      do
      {
        status = poll(&pollset, 1, timeout);
      } while ((status < 0) && (errno == EINTR));
 
#else
      fd_set rset = WINPR_C_ARRAY_INIT;
      struct timeval tv = WINPR_C_ARRAY_INIT;
      FD_ZERO(&rset);
      FD_SET(sockfd, &rset);
 
      if (timeout)
      {
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = (timeout % 1000) * 1000;
      }
 
      do
      {
        status = select(sockfd + 1, nullptr, &rset, nullptr, timeout ? &tv : nullptr);
      } while ((status < 0) && (errno == EINTR));
 
#endif
      /* Convert timeout to error return */
      if (status == 0)
        errno = ETIMEDOUT;
    }
    break;
 
    case BIO_C_SET_FD:
      if (arg2)
      {
        transport_bio_simple_uninit(bio);
        transport_bio_simple_init(bio, (SOCKET) * ((int*)arg2), (int)arg1);
        status = 1;
      }
 
      break;
 
    case BIO_C_GET_FD:
      if (BIO_get_init(bio))
      {
        if (arg2)
          *((int*)arg2) = (int)ptr->socket;
 
        status = (int)ptr->socket;
      }
 
      break;
 
    case BIO_CTRL_GET_CLOSE:
      status = BIO_get_shutdown(bio);
      break;
 
    case BIO_CTRL_SET_CLOSE:
      BIO_set_shutdown(bio, (int)arg1);
      status = 1;
      break;
 
    case BIO_CTRL_FLUSH:
    case BIO_CTRL_DUP:
      status = 1;
      break;
 
    default:
      status = 0;
      break;
  }
 
  return status;
}
 
static int transport_bio_simple_init(BIO* bio, SOCKET socket, int shutdown)
{
  WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
  ptr->socket = socket;
  BIO_set_shutdown(bio, shutdown);
  BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
  BIO_set_init(bio, 1);
  ptr->hEvent = WSACreateEvent();
 
  if (!ptr->hEvent)
    return 0;
 
  /* WSAEventSelect automatically sets the socket in non-blocking mode */
  if (WSAEventSelect(ptr->socket, ptr->hEvent, FD_READ | FD_ACCEPT | FD_CLOSE))
  {
    WLog_ERR(TAG, "WSAEventSelect returned 0x%08x",
             WINPR_CXX_COMPAT_CAST(unsigned, WSAGetLastError()));
    return 0;
  }
 
  return 1;
}
 
static int transport_bio_simple_uninit(BIO* bio)
{
  WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
 
  if (BIO_get_shutdown(bio))
  {
    if (BIO_get_init(bio) && ptr)
    {
      _shutdown(ptr->socket, SD_BOTH);
      closesocket(ptr->socket);
      ptr->socket = 0;
    }
  }
 
  if (ptr && ptr->hEvent)
  {
    (void)CloseHandle(ptr->hEvent);
    ptr->hEvent = nullptr;
  }
 
  BIO_set_init(bio, 0);
  BIO_set_flags(bio, 0);
  return 1;
}
 
static int transport_bio_simple_new(BIO* bio)
{
  WINPR_BIO_SIMPLE_SOCKET* ptr = nullptr;
  BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
  ptr = (WINPR_BIO_SIMPLE_SOCKET*)calloc(1, sizeof(WINPR_BIO_SIMPLE_SOCKET));
 
  if (!ptr)
    return 0;
 
  BIO_set_data(bio, ptr);
  return 1;
}
 
static int transport_bio_simple_free(BIO* bio)
{
  WINPR_BIO_SIMPLE_SOCKET* ptr = nullptr;
 
  if (!bio)
    return 0;
 
  transport_bio_simple_uninit(bio);
  ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
 
  if (ptr)
  {
    BIO_set_data(bio, nullptr);
    free(ptr);
  }
 
  return 1;
}
 
BIO_METHOD* BIO_s_simple_socket(void)
{
  static BIO_METHOD* bio_methods = nullptr;
 
  if (bio_methods == nullptr)
  {
    if (!(bio_methods = BIO_meth_new(BIO_TYPE_SIMPLE, "SimpleSocket")))
      return nullptr;
 
    BIO_meth_set_write(bio_methods, transport_bio_simple_write);
    BIO_meth_set_read(bio_methods, transport_bio_simple_read);
    BIO_meth_set_puts(bio_methods, transport_bio_simple_puts);
    BIO_meth_set_gets(bio_methods, transport_bio_simple_gets);
    BIO_meth_set_ctrl(bio_methods, transport_bio_simple_ctrl);
    BIO_meth_set_create(bio_methods, transport_bio_simple_new);
    BIO_meth_set_destroy(bio_methods, transport_bio_simple_free);
  }
 
  return bio_methods;
}
 
/* Buffered Socket BIO */
 
typedef struct
{
  BIO* bufferedBio;
  BOOL readBlocked;
  BOOL writeBlocked;
  RingBuffer xmitBuffer;
} WINPR_BIO_BUFFERED_SOCKET;
 
static int transport_bio_buffered_write(BIO* bio, const char* buf, int num)
{
  int ret = num;
  int nchunks = 0;
  size_t committedBytes = 0;
  DataChunk chunks[2] = WINPR_C_ARRAY_INIT;
  WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
  BIO* next_bio = nullptr;
 
  WINPR_ASSERT(bio);
  WINPR_ASSERT(ptr);
  if (num < 0)
    return num;
 
  ptr->writeBlocked = FALSE;
  BIO_clear_flags(bio, BIO_FLAGS_WRITE);
 
  /* we directly append extra bytes in the xmit buffer, this could be prevented
   * but for now it makes the code more simple.
   */
  if (buf && (num > 0) && !ringbuffer_write(&ptr->xmitBuffer, (const BYTE*)buf, (size_t)num))
  {
    WLog_ERR(TAG, "an error occurred when writing (num: %d)", num);
    return -1;
  }
 
  nchunks = ringbuffer_peek(&ptr->xmitBuffer, chunks, ringbuffer_used(&ptr->xmitBuffer));
  next_bio = BIO_next(bio);
 
  for (int i = 0; i < nchunks; i++)
  {
    while (chunks[i].size)
    {
      ERR_clear_error();
 
      const size_t wr = MIN(INT32_MAX, chunks[i].size);
      const int status = BIO_write(next_bio, chunks[i].data, (int)wr);
 
      if (status <= 0)
      {
        if (!BIO_should_retry(next_bio))
        {
          BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
          ret = -1; /* fatal error */
          goto out;
        }
 
        if (BIO_should_write(next_bio))
        {
          BIO_set_flags(bio, BIO_FLAGS_WRITE);
          ptr->writeBlocked = TRUE;
          goto out; /* EWOULDBLOCK */
        }
      }
      else
      {
        committedBytes += (size_t)status;
        chunks[i].size -= (size_t)status;
        chunks[i].data += status;
      }
    }
  }
 
out:
  ringbuffer_commit_read_bytes(&ptr->xmitBuffer, committedBytes);
  return ret;
}
 
static int transport_bio_buffered_read(BIO* bio, char* buf, int size)
{
  int status = 0;
  WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
  BIO* next_bio = BIO_next(bio);
  ptr->readBlocked = FALSE;
  BIO_clear_flags(bio, BIO_FLAGS_READ);
  ERR_clear_error();
  status = BIO_read(next_bio, buf, size);
 
  if (status <= 0)
  {
    if (!BIO_should_retry(next_bio))
    {
      BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
      goto out;
    }
 
    BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
 
    if (BIO_should_read(next_bio))
    {
      BIO_set_flags(bio, BIO_FLAGS_READ);
      ptr->readBlocked = TRUE;
      goto out;
    }
  }
 
out:
  return status;
}
 
static int transport_bio_buffered_puts(WINPR_ATTR_UNUSED BIO* bio,
                                       WINPR_ATTR_UNUSED const char* str)
{
  return 1;
}
 
static int transport_bio_buffered_gets(WINPR_ATTR_UNUSED BIO* bio, WINPR_ATTR_UNUSED char* str,
                                       WINPR_ATTR_UNUSED int size)
{
  return 1;
}
 
static long transport_bio_buffered_ctrl(BIO* bio, int cmd, long arg1, void* arg2)
{
  long status = -1;
  WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
 
  switch (cmd)
  {
    case BIO_CTRL_FLUSH:
      if (!ringbuffer_used(&ptr->xmitBuffer))
        status = 1;
      else
        status = (transport_bio_buffered_write(bio, nullptr, 0) >= 0) ? 1 : -1;
 
      break;
 
    case BIO_CTRL_WPENDING:
      status = WINPR_ASSERTING_INT_CAST(long, ringbuffer_used(&ptr->xmitBuffer));
      break;
 
    case BIO_CTRL_PENDING:
      status = 0;
      break;
 
    case BIO_C_READ_BLOCKED:
      status = (int)ptr->readBlocked;
      break;
 
    case BIO_C_WRITE_BLOCKED:
      status = (int)ptr->writeBlocked;
      break;
 
    default:
      status = BIO_ctrl(BIO_next(bio), cmd, arg1, arg2);
      break;
  }
 
  return status;
}
 
static int transport_bio_buffered_new(BIO* bio)
{
  WINPR_BIO_BUFFERED_SOCKET* ptr = nullptr;
  BIO_set_init(bio, 1);
  BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
  ptr = (WINPR_BIO_BUFFERED_SOCKET*)calloc(1, sizeof(WINPR_BIO_BUFFERED_SOCKET));
 
  if (!ptr)
    return -1;
 
  BIO_set_data(bio, (void*)ptr);
 
  if (!ringbuffer_init(&ptr->xmitBuffer, 0x10000))
    return -1;
 
  return 1;
}
 
/* Free the buffered BIO.
 * Do not free other elements in the BIO stack,
 * let BIO_free_all handle that. */
static int transport_bio_buffered_free(BIO* bio)
{
  WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
 
  if (!ptr)
    return 0;
 
  ringbuffer_destroy(&ptr->xmitBuffer);
  free(ptr);
  return 1;
}
 
BIO_METHOD* BIO_s_buffered_socket(void)
{
  static BIO_METHOD* bio_methods = nullptr;
 
  if (bio_methods == nullptr)
  {
    if (!(bio_methods = BIO_meth_new(BIO_TYPE_BUFFERED, "BufferedSocket")))
      return nullptr;
 
    BIO_meth_set_write(bio_methods, transport_bio_buffered_write);
    BIO_meth_set_read(bio_methods, transport_bio_buffered_read);
    BIO_meth_set_puts(bio_methods, transport_bio_buffered_puts);
    BIO_meth_set_gets(bio_methods, transport_bio_buffered_gets);
    BIO_meth_set_ctrl(bio_methods, transport_bio_buffered_ctrl);
    BIO_meth_set_create(bio_methods, transport_bio_buffered_new);
    BIO_meth_set_destroy(bio_methods, transport_bio_buffered_free);
  }
 
  return bio_methods;
}
 
char* freerdp_tcp_address_to_string(const struct sockaddr_storage* addr, BOOL* pIPv6)
{
  char ipAddress[INET6_ADDRSTRLEN + 1] = WINPR_C_ARRAY_INIT;
  const struct sockaddr_in6* sockaddr_ipv6 = (const struct sockaddr_in6*)addr;
  const struct sockaddr_in* sockaddr_ipv4 = (const struct sockaddr_in*)addr;
 
  if (addr == nullptr)
  {
    return nullptr;
  }
 
  switch (sockaddr_ipv4->sin_family)
  {
    case AF_INET:
      if (!inet_ntop(sockaddr_ipv4->sin_family, &sockaddr_ipv4->sin_addr, ipAddress,
                     sizeof(ipAddress)))
        return nullptr;
 
      break;
 
    case AF_INET6:
      if (!inet_ntop(sockaddr_ipv6->sin6_family, &sockaddr_ipv6->sin6_addr, ipAddress,
                     sizeof(ipAddress)))
        return nullptr;
 
      break;
 
    case AF_UNIX:
      (void)sprintf_s(ipAddress, ARRAYSIZE(ipAddress), "127.0.0.1");
      break;
 
    default:
      return nullptr;
  }
 
  if (pIPv6 != nullptr)
  {
    *pIPv6 = (sockaddr_ipv4->sin_family == AF_INET6);
  }
 
  return _strdup(ipAddress);
}
 
static bool freerdp_tcp_get_ip_address(rdpSettings* settings, int sockfd)
{
  WINPR_ASSERT(settings);
 
  struct sockaddr_storage saddr = WINPR_C_ARRAY_INIT;
  socklen_t length = sizeof(struct sockaddr_storage);
 
  if (!freerdp_settings_set_string(settings, FreeRDP_ClientAddress, nullptr))
    return false;
  if (sockfd < 0)
    return false;
  if (getsockname(sockfd, (struct sockaddr*)&saddr, &length) != 0)
    return false;
  settings->ClientAddress = freerdp_tcp_address_to_string(&saddr, &settings->IPv6Enabled);
  return settings->ClientAddress != nullptr;
}
 
char* freerdp_tcp_get_peer_address(SOCKET sockfd)
{
  struct sockaddr_storage saddr = WINPR_C_ARRAY_INIT;
  socklen_t length = sizeof(struct sockaddr_storage);
 
  if (getpeername((int)sockfd, (struct sockaddr*)&saddr, &length) != 0)
  {
    return nullptr;
  }
 
  return freerdp_tcp_address_to_string(&saddr, nullptr);
}
 
static int freerdp_uds_connect(const char* path)
{
#ifndef _WIN32
  int status = 0;
  int sockfd = 0;
  struct sockaddr_un addr = WINPR_C_ARRAY_INIT;
  sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
 
  if (sockfd == -1)
  {
    WLog_ERR(TAG, "socket");
    return -1;
  }
 
  addr.sun_family = AF_UNIX;
  strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
  status = connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));
 
  if (status < 0)
  {
    WLog_ERR(TAG, "connect");
    close(sockfd);
    return -1;
  }
 
  return sockfd;
#else /* ifndef _WIN32 */
  return -1;
#endif
}
 
struct addrinfo* freerdp_tcp_resolve_host(const char* hostname, int port, int ai_flags)
{
  char* service = nullptr;
  char port_str[16] = WINPR_C_ARRAY_INIT;
  int status = 0;
 
  struct addrinfo* result = nullptr;
  struct addrinfo hints = { .ai_family = AF_UNSPEC,
                          .ai_socktype = SOCK_STREAM,
                          .ai_flags = ai_flags };
 
  if (port >= 0)
  {
    (void)sprintf_s(port_str, sizeof(port_str) - 1, "%d", port);
    service = port_str;
  }
 
  status = getaddrinfo(hostname, service, &hints, &result);
 
  if (status)
  {
    WLog_WARN(TAG, "getaddrinfo(%s) failed with %s", hostname, gai_strerror(status));
    return nullptr;
  }
 
  return result;
}
 
static BOOL freerdp_tcp_is_hostname_resolvable(rdpContext* context, const char* hostname)
{
  struct addrinfo* result = freerdp_tcp_resolve_host(hostname, -1, 0);
 
  if (!result)
  {
    freerdp_set_last_error_if_not(context, FREERDP_ERROR_DNS_NAME_NOT_FOUND);
 
    return FALSE;
  }
 
  freerdp_set_last_error_log(context, 0);
  freeaddrinfo(result);
  return TRUE;
}
 
static BOOL freerdp_tcp_connect_timeout(rdpContext* context, int sockfd, struct sockaddr* addr,
                                        size_t addrlen, UINT32 timeout)
{
  BOOL rc = FALSE;
  HANDLE handles[2] = WINPR_C_ARRAY_INIT;
  DWORD count = 0;
  u_long arg = 0;
  DWORD tout = (timeout > 0) ? timeout : INFINITE;
 
  handles[count] = CreateEvent(nullptr, TRUE, FALSE, nullptr);
 
  if (!handles[count])
    return FALSE;
 
  const int wsastatus = WSAEventSelect((SOCKET)sockfd, handles[count++],
                                       FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE);
 
  if (wsastatus < 0)
  {
    WLog_ERR(TAG, "WSAEventSelect failed with %d", WSAGetLastError());
    goto fail;
  }
 
  handles[count++] = utils_get_abort_event(context->rdp);
 
  {
    const int constatus =
        _connect((SOCKET)sockfd, addr, WINPR_ASSERTING_INT_CAST(int, addrlen));
    if (constatus < 0)
    {
      const int estatus = WSAGetLastError();
 
      switch (estatus)
      {
        case WSAEINPROGRESS:
        case WSAEWOULDBLOCK:
          break;
 
        default:
          goto fail;
      }
    }
  }
 
  {
    const DWORD wstatus = WaitForMultipleObjects(count, handles, FALSE, tout);
    if (WAIT_OBJECT_0 != wstatus)
      goto fail;
  }
 
  {
    const int status = WSAEventSelect((SOCKET)sockfd, handles[0], 0);
    if (status < 0)
    {
      WLog_ERR(TAG, "WSAEventSelect failed with %d", WSAGetLastError());
      goto fail;
    }
  }
 
  if (_ioctlsocket((SOCKET)sockfd, FIONBIO, &arg) != 0)
    goto fail;
 
  rc = TRUE;
fail:
{
  INT32 optval = 0;
  socklen_t optlen = sizeof(optval);
  if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)&optval, &optlen) >= 0)
  {
    if (optval != 0)
    {
      char ebuffer[256] = WINPR_C_ARRAY_INIT;
      char hostname[512] = WINPR_C_ARRAY_INIT;
      char serv[512] = WINPR_C_ARRAY_INIT;
 
      getnameinfo(addr, WINPR_ASSERTING_INT_CAST(socklen_t, addrlen), hostname,
                  WINPR_ASSERTING_INT_CAST(socklen_t, sizeof(hostname)), serv,
                  WINPR_ASSERTING_INT_CAST(socklen_t, sizeof(serv)), NI_NUMERICSERV);
      WLog_WARN(TAG, "connect to %s:%s failed with error: %s [%" PRId32 "]", hostname, serv,
                winpr_strerror(optval, ebuffer, sizeof(ebuffer)), optval);
      rc = FALSE;
    }
  }
}
 
  (void)CloseHandle(handles[0]);
  return rc;
}
 
typedef struct
{
  SOCKET s;
  struct addrinfo* addr;
  struct addrinfo* result;
} t_peer;
 
static void peer_free(t_peer* peer)
{
  if (peer->s != INVALID_SOCKET)
    closesocket(peer->s);
 
  freeaddrinfo(peer->addr);
  memset(peer, 0, sizeof(t_peer));
  peer->s = INVALID_SOCKET;
}
 
static int freerdp_tcp_connect_multi(rdpContext* context, char** hostnames, const UINT32* ports,
                                     UINT32 count, UINT16 port, WINPR_ATTR_UNUSED UINT32 timeout)
{
  UINT32 sindex = count;
  SOCKET sockfd = INVALID_SOCKET;
  struct addrinfo* addr = nullptr;
  struct addrinfo* result = nullptr;
 
  HANDLE* events = (HANDLE*)calloc(count + 1, sizeof(HANDLE));
  t_peer* peers = (t_peer*)calloc(count, sizeof(t_peer));
 
  if (!peers || !events || (count < 1))
  {
    free(peers);
    free((void*)events);
    return -1;
  }
 
  for (UINT32 index = 0; index < count; index++)
  {
    int curPort = port;
 
    if (ports)
      curPort = WINPR_ASSERTING_INT_CAST(int, ports[index]);
 
    result = freerdp_tcp_resolve_host(hostnames[index], curPort, 0);
 
    if (!result)
      continue;
 
    addr = result;
 
    if ((addr->ai_family == AF_INET6) && (addr->ai_next != nullptr))
    {
      while ((addr = addr->ai_next))
      {
        if (addr->ai_family == AF_INET)
          break;
      }
 
      if (!addr)
        addr = result;
    }
 
    peers[index].s = _socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
 
    if (peers[index].s == INVALID_SOCKET)
    {
      freeaddrinfo(result);
      continue;
    }
 
    peers[index].addr = addr;
    peers[index].result = result;
  }
 
  for (UINT32 index = 0; index < count; index++)
  {
    sockfd = peers[index].s;
    addr = peers[index].addr;
 
    if ((sockfd == INVALID_SOCKET) || (!addr))
      continue;
 
    /* blocking tcp connect */
    const int rc =
        _connect(sockfd, addr->ai_addr, WINPR_ASSERTING_INT_CAST(int, addr->ai_addrlen));
 
    if (rc >= 0)
    {
      /* connection success */
      sindex = index;
      break;
    }
  }
 
  if (sindex < count)
  {
    sockfd = peers[sindex].s;
    peers[sindex].s = INVALID_SOCKET;
  }
  else
    freerdp_set_last_error_log(context, FREERDP_ERROR_CONNECT_CANCELLED);
 
  for (UINT32 index = 0; index < count; index++)
    peer_free(&peers[index]);
 
  free(peers);
  free((void*)events);
  return (int)sockfd;
}
 
BOOL freerdp_tcp_set_keep_alive_mode(const rdpSettings* settings, int sockfd)
{
  const BOOL keepalive = (freerdp_settings_get_bool(settings, FreeRDP_TcpKeepAlive));
  UINT32 optval = 0;
  socklen_t optlen = 0;
  BOOL isTcp = FALSE;
 
  int xoptval = 0;
  socklen_t xoptlen = sizeof(xoptval);
  const int rc = getsockopt(sockfd, SOL_SOCKET, SO_TYPE, (void*)&xoptval, &xoptlen);
 
  if (rc == 0)
    isTcp = xoptval == SOCK_STREAM;
 
  optval = keepalive ? 1 : 0;
  optlen = sizeof(optval);
 
  if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (void*)&optval, optlen) < 0)
  {
    WLog_WARN(TAG, "setsockopt() SOL_SOCKET, SO_KEEPALIVE");
  }
 
  if (!isTcp)
    return TRUE;
 
#ifndef _WIN32
#ifdef TCP_KEEPIDLE
  optval = keepalive ? freerdp_settings_get_uint32(settings, FreeRDP_TcpKeepAliveDelay) : 0;
  optlen = sizeof(optval);
 
  if (setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, (void*)&optval, optlen) < 0)
  {
    WLog_WARN(TAG, "setsockopt() IPPROTO_TCP, TCP_KEEPIDLE");
  }
 
#endif
#ifndef SOL_TCP
  /* "tcp" from /etc/protocols as getprotobyname(3C) */
#define SOL_TCP 6
#endif
#ifdef TCP_KEEPCNT
  optval = keepalive ? freerdp_settings_get_uint32(settings, FreeRDP_TcpKeepAliveRetries) : 0;
  optlen = sizeof(optval);
 
  if (setsockopt(sockfd, SOL_TCP, TCP_KEEPCNT, (void*)&optval, optlen) < 0)
  {
    WLog_WARN(TAG, "setsockopt() SOL_TCP, TCP_KEEPCNT");
  }
 
#endif
#ifdef TCP_KEEPINTVL
  optval = keepalive ? freerdp_settings_get_uint32(settings, FreeRDP_TcpKeepAliveInterval) : 0;
  optlen = sizeof(optval);
 
  if (setsockopt(sockfd, SOL_TCP, TCP_KEEPINTVL, (void*)&optval, optlen) < 0)
  {
    WLog_WARN(TAG, "setsockopt() SOL_TCP, TCP_KEEPINTVL");
  }
 
#endif
#endif
#if defined(__MACOSX__) || defined(__IOS__)
  optval = 1;
  optlen = sizeof(optval);
 
  if (setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&optval, optlen) < 0)
  {
    WLog_WARN(TAG, "setsockopt() SOL_SOCKET, SO_NOSIGPIPE");
  }
 
#endif
#ifdef TCP_USER_TIMEOUT
  optval = freerdp_settings_get_uint32(settings, FreeRDP_TcpAckTimeout);
  optlen = sizeof(optval);
 
  if (setsockopt(sockfd, SOL_TCP, TCP_USER_TIMEOUT, (void*)&optval, optlen) < 0)
  {
    WLog_WARN(TAG, "setsockopt() SOL_TCP, TCP_USER_TIMEOUT");
  }
 
#endif
  return TRUE;
}
 
int freerdp_tcp_connect(rdpContext* context, const char* hostname, int port, DWORD timeout)
{
  rdpTransport* transport = nullptr;
  if (!context || !context->rdp)
    return -1;
  transport = context->rdp->transport;
  if (!transport)
    return -1;
  return transport_tcp_connect(context->rdp->transport, hostname, port, timeout);
}
 
static struct addrinfo* reorder_addrinfo_by_preference(rdpContext* context, struct addrinfo* addr)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(addr);
 
  const BOOL preferIPv6 =
      freerdp_settings_get_bool(context->settings, FreeRDP_PreferIPv6OverIPv4);
  if (!preferIPv6)
    return addr;
 
  struct addrinfo* ipv6Head = nullptr;
  struct addrinfo* ipv6Tail = nullptr;
  struct addrinfo* otherHead = nullptr;
  struct addrinfo* otherTail = nullptr;
 
  /* Partition the list into IPv6 and other addresses */
  while (addr)
  {
    struct addrinfo* next = addr->ai_next;
    addr->ai_next = nullptr;
 
    if (addr->ai_family == AF_INET6)
    {
      if (!ipv6Head)
        ipv6Head = addr;
      else
        ipv6Tail->ai_next = addr;
      ipv6Tail = addr;
    }
    else
    {
      if (!otherHead)
        otherHead = addr;
      else
        otherTail->ai_next = addr;
      otherTail = addr;
    }
    addr = next;
  }
 
  /* Concatenate the lists */
  if (ipv6Tail)
    ipv6Tail->ai_next = otherHead;
 
  return ipv6Head ? ipv6Head : otherHead;
}
 
static int get_next_addrinfo(rdpContext* context, struct addrinfo* input, struct addrinfo** result,
                             UINT32 errorCode)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(result);
 
  struct addrinfo* addr = input;
  if (!addr)
    goto fail;
 
  /* We want to force IPvX, abort if not detected */
  {
    const UINT32 IPvX = freerdp_settings_get_uint32(context->settings, FreeRDP_ForceIPvX);
    switch (IPvX)
    {
      case 4:
      case 6:
      {
        const int family = (IPvX == 4) ? AF_INET : AF_INET6;
        while (addr && (addr->ai_family != family))
          addr = addr->ai_next;
      }
      break;
      default:
        break;
    }
  }
 
  if (!addr)
    goto fail;
 
  *result = addr;
  return 0;
 
fail:
  freerdp_set_last_error_if_not(context, errorCode);
  *result = nullptr;
  return -1;
}
 
static int freerdp_vsock_connect(rdpContext* context, const char* hostname, int port)
{
#if defined(HAVE_AF_VSOCK_H)
  int sockfd = socket(AF_VSOCK, SOCK_STREAM, 0);
  if (sockfd < 0)
  {
    char buffer[256] = WINPR_C_ARRAY_INIT;
    WLog_WARN(TAG, "socket(AF_VSOCK, SOCK_STREAM, 0) failed with %s",
              winpr_strerror(errno, buffer, sizeof(buffer)));
    freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
    return -1;
  }
 
  struct sockaddr_vm addr = WINPR_C_ARRAY_INIT;
 
  addr.svm_family = AF_VSOCK;
  addr.svm_port = WINPR_ASSERTING_INT_CAST(typeof(addr.svm_port), port);
 
  errno = 0;
  char* ptr = nullptr;
  unsigned long val = strtoul(hostname, &ptr, 10);
  if (errno || (val > UINT32_MAX))
  {
    char ebuffer[256] = WINPR_C_ARRAY_INIT;
    WLog_ERR(TAG, "could not extract port from '%s', value=%lu, error=%s", hostname, val,
             winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
    close(sockfd);
    return -1;
  }
  addr.svm_cid = WINPR_ASSERTING_INT_CAST(typeof(addr.svm_cid), val);
  if (addr.svm_cid == 2)
  {
    addr.svm_flags = VMADDR_FLAG_TO_HOST;
  }
  if ((connect(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_vm))) == -1)
  {
    WLog_ERR(TAG, "failed to connect to %s", hostname);
    close(sockfd);
    return -1;
  }
  return sockfd;
#else
  WLog_ERR(TAG, "Compiled without AF_VSOCK, '%s' not supported", hostname);
  return -1;
#endif
}
 
static void log_connection_address(const char* hostname, struct addrinfo* addr)
{
  WINPR_ASSERT(addr);
 
  char* peerAddress = freerdp_tcp_address_to_string(
      WINPR_PACKED_ALIGN_CAST(const struct sockaddr_storage*, addr->ai_addr), nullptr);
  if (peerAddress)
    WLog_DBG(TAG, "resolved %s: try to connect to %s", hostname, peerAddress);
  free(peerAddress);
}
 
static int freerdp_host_connect(rdpContext* context, const char* hostname, int port, DWORD timeout)
{
  int sockfd = -1;
  struct addrinfo* addr = nullptr;
  struct addrinfo* result = freerdp_tcp_resolve_host(hostname, port, 0);
 
  if (!result)
  {
    freerdp_set_last_error_if_not(context, FREERDP_ERROR_DNS_NAME_NOT_FOUND);
    return -1;
  }
  freerdp_set_last_error_log(context, 0);
 
  /* By default we take the first returned entry.
   * If PreferIPv6OverIPv4 = TRUE we reorder addresses by preference:
   * IPv6 addresses come first, then other addresses.
   */
  result = reorder_addrinfo_by_preference(context, result);
 
  const int rc = get_next_addrinfo(context, result, &addr, FREERDP_ERROR_DNS_NAME_NOT_FOUND);
  if (rc < 0)
    goto fail;
 
  do
  {
    sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
    if (sockfd >= 0)
    {
      log_connection_address(hostname, addr);
 
      if (!freerdp_tcp_connect_timeout(context, sockfd, addr->ai_addr, addr->ai_addrlen,
                                       timeout))
      {
        close(sockfd);
        sockfd = -1;
      }
    }
 
    if (sockfd < 0)
    {
      const int lrc =
          get_next_addrinfo(context, addr->ai_next, &addr, FREERDP_ERROR_CONNECT_FAILED);
      if (lrc < 0)
        goto fail;
    }
  } while (sockfd < 0);
 
fail:
  freeaddrinfo(result);
  return sockfd;
}
 
int freerdp_tcp_default_connect(rdpContext* context, rdpSettings* settings, const char* hostname,
                                int port, DWORD timeout)
{
  int sockfd = -1;
  BOOL ipcSocket = FALSE;
  BOOL useExternalDefinedSocket = FALSE;
 
  if (!hostname)
  {
    freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
 
    return -1;
  }
 
  if (hostname[0] == '/')
    ipcSocket = TRUE;
 
  if (hostname[0] == '|')
    useExternalDefinedSocket = TRUE;
 
  const char* vsock = utils_is_vsock(hostname);
  if (ipcSocket)
  {
    sockfd = freerdp_uds_connect(hostname);
 
    if (sockfd < 0)
    {
      freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
      return -1;
    }
  }
  else if (useExternalDefinedSocket)
    sockfd = port;
  else if (vsock)
    sockfd = freerdp_vsock_connect(context, vsock, port);
  else
  {
    if (!settings->GatewayEnabled)
    {
      if (!freerdp_tcp_is_hostname_resolvable(context, hostname) ||
          settings->RemoteAssistanceMode)
      {
        if (settings->TargetNetAddressCount > 0)
        {
          WINPR_ASSERT(port <= UINT16_MAX);
          sockfd = freerdp_tcp_connect_multi(
              context, settings->TargetNetAddresses, settings->TargetNetPorts,
              settings->TargetNetAddressCount, (UINT16)port, timeout);
        }
      }
    }
 
    if (sockfd <= 0)
      sockfd = freerdp_host_connect(context, hostname, port, timeout);
  }
 
  if (!vsock)
  {
    if (!freerdp_tcp_get_ip_address(settings, sockfd))
    {
      if (!useExternalDefinedSocket)
        close(sockfd);
 
      freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
 
      WLog_ERR(TAG, "Couldn't get socket ip address");
      return -1;
    }
  }
 
  if (!ipcSocket && !useExternalDefinedSocket)
  {
    (void)freerdp_tcp_set_nodelay(WLog_Get(TAG), WLOG_ERROR, sockfd);
  }
 
  /* receive buffer must be a least 32 K */
  UINT32 optval = 1;
  socklen_t optlen = sizeof(optval);
  if (getsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (void*)&optval, &optlen) == 0)
  {
    if (optval < (1024 * 32))
    {
      optval = 1024 * 32;
      optlen = sizeof(optval);
 
      if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (void*)&optval, optlen) < 0)
      {
        close(sockfd);
 
        freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
 
        WLog_ERR(TAG, "unable to set receive buffer len");
        return -1;
      }
    }
  }
 
  if (!ipcSocket && !useExternalDefinedSocket)
  {
    if (!freerdp_tcp_set_keep_alive_mode(settings, sockfd))
    {
      close(sockfd);
 
      freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
 
      WLog_ERR(TAG, "Couldn't set keep alive mode.");
      return -1;
    }
  }
 
  if (WaitForSingleObject(utils_get_abort_event(context->rdp), 0) == WAIT_OBJECT_0)
  {
    close(sockfd);
    return -1;
  }
 
  return sockfd;
}
 
struct rdp_tcp_layer
{
  int sockfd;
  HANDLE hEvent;
};
typedef struct rdp_tcp_layer rdpTcpLayer;
 
static int freerdp_tcp_layer_read(void* userContext, void* data, int bytes)
{
  if (!userContext)
    return -1;
  if (!data || !bytes)
    return 0;
 
  rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
 
  (void)WSAResetEvent(tcpLayer->hEvent);
  const int status = _recv((SOCKET)tcpLayer->sockfd, data, bytes, 0);
 
  if (status > 0)
    return status;
 
  const int error = WSAGetLastError();
 
  if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
      (error == WSAEALREADY))
    errno = EAGAIN;
 
  return status;
}
 
static int freerdp_tcp_layer_write(void* userContext, const void* data, int bytes)
{
  if (!userContext)
    return -1;
  if (!data || !bytes)
    return 0;
 
  rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
 
  const int status = _send((SOCKET)tcpLayer->sockfd, data, bytes, 0);
  if (status > 0)
    return status;
 
  const int error = WSAGetLastError();
 
  if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
      (error == WSAEALREADY))
    errno = EAGAIN;
 
  return status;
}
 
static BOOL freerdp_tcp_layer_close(void* userContext)
{
  if (!userContext)
    return FALSE;
 
  rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
 
  if (tcpLayer->sockfd >= 0)
    closesocket((SOCKET)tcpLayer->sockfd);
  if (tcpLayer->hEvent)
    (void)CloseHandle(tcpLayer->hEvent);
 
  return TRUE;
}
 
static BOOL freerdp_tcp_layer_wait(void* userContext, BOOL waitWrite, DWORD timeout)
{
  if (!userContext)
    return FALSE;
 
  rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
 
  int status = -1;
  int sockfd = tcpLayer->sockfd;
#ifdef WINPR_HAVE_POLL_H
  struct pollfd pollset = WINPR_C_ARRAY_INIT;
  pollset.fd = sockfd;
  pollset.events = waitWrite ? POLLOUT : POLLIN;
 
  do
  {
    status = poll(&pollset, 1, (int)timeout);
  } while ((status < 0) && (errno == EINTR));
 
#else
  fd_set rset = WINPR_C_ARRAY_INIT;
  struct timeval tv = WINPR_C_ARRAY_INIT;
  FD_ZERO(&rset);
  FD_SET(sockfd, &rset);
 
  if (timeout)
  {
    tv.tv_sec = timeout / 1000;
    tv.tv_usec = (timeout % 1000) * 1000;
  }
 
  do
  {
    if (waitWrite)
      status = select(sockfd + 1, nullptr, &rset, nullptr, timeout ? &tv : nullptr);
    else
      status = select(sockfd + 1, &rset, nullptr, nullptr, timeout ? &tv : nullptr);
  } while ((status < 0) && (errno == EINTR));
 
#endif
 
  return status != 0;
}
 
static HANDLE freerdp_tcp_layer_get_event(void* userContext)
{
  if (!userContext)
    return nullptr;
 
  rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
 
  return tcpLayer->hEvent;
}
 
rdpTransportLayer* freerdp_tcp_connect_layer(rdpContext* context, const char* hostname, int port,
                                             DWORD timeout)
{
  WINPR_ASSERT(context);
 
  const rdpSettings* settings = context->settings;
  WINPR_ASSERT(settings);
 
  rdpTransportLayer* layer = nullptr;
  rdpTcpLayer* tcpLayer = nullptr;
 
  int sockfd = freerdp_tcp_connect(context, hostname, port, timeout);
  if (sockfd < 0)
    goto fail;
  if (!freerdp_tcp_set_keep_alive_mode(settings, sockfd))
    goto fail;
 
  layer = transport_layer_new(freerdp_get_transport(context), sizeof(rdpTcpLayer));
  if (!layer)
    goto fail;
 
  layer->Read = freerdp_tcp_layer_read;
  layer->Write = freerdp_tcp_layer_write;
  layer->Close = freerdp_tcp_layer_close;
  layer->Wait = freerdp_tcp_layer_wait;
  layer->GetEvent = freerdp_tcp_layer_get_event;
 
  tcpLayer = (rdpTcpLayer*)layer->userContext;
  WINPR_ASSERT(tcpLayer);
 
  tcpLayer->sockfd = -1;
  tcpLayer->hEvent = WSACreateEvent();
  if (!tcpLayer->hEvent)
    goto fail;
 
  /* WSAEventSelect automatically sets the socket in non-blocking mode */
  if (WSAEventSelect((SOCKET)sockfd, tcpLayer->hEvent, FD_READ | FD_ACCEPT | FD_CLOSE))
  {
    WLog_ERR(TAG, "WSAEventSelect returned 0x%08x", (unsigned)WSAGetLastError());
    goto fail;
  }
 
  tcpLayer->sockfd = sockfd;
 
  return layer;
 
fail:
  if (sockfd >= 0)
    closesocket((SOCKET)sockfd);
  transport_layer_free(layer);
  return nullptr;
}
 
BOOL freerdp_tcp_set_nodelay(wLog* log, DWORD level, int sockfd)
{
  WINPR_ASSERT(log);
 
  int type = -1;
  socklen_t typelen = sizeof(type);
  char* ptype = (char*)&type;
  const int rc = getsockopt(sockfd, SOL_SOCKET, SO_TYPE, ptype, &typelen);
  if (rc < 0)
  {
    char buffer[128] = WINPR_C_ARRAY_INIT;
    WLog_Print(log, level, "can't get SOL_SOCKET|SO_TYPE (%s)",
               winpr_strerror(errno, buffer, sizeof(buffer)));
    return FALSE;
  }
  else if (type == SOCK_STREAM)
  {
    int option_value = -1;
    const socklen_t option_len = sizeof(option_value);
    const int sr =
        setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (void*)&option_value, option_len);
    if (sr < 0)
    {
      /* local unix sockets don't have the TCP_NODELAY implemented, so don't make this
       * error fatal */
      char buffer[128] = WINPR_C_ARRAY_INIT;
      WLog_Print(log, level, "can't set TCP_NODELAY (%s)",
                 winpr_strerror(errno, buffer, sizeof(buffer)));
      return FALSE;
    }
  }
  else
  {
    WLog_Print(log, level, "Socket SOL_SOCKET|SO_TYPE %d unsupported", type);
    return FALSE;
  }
  return TRUE;
}