Adding upstream version 4.5.upstream/4.5upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1803 insertions, 0 deletions

diff --git a/socket.c b/socket.c
new file mode 100644
index 0000000..5b22db5
--- /dev/null
+++ b/socket.c
@@ -0,0 +1,1803 @@
+/*
+  chronyd/chronyc - Programs for keeping computer clocks accurate.
+
+ **********************************************************************
+ * Copyright (C) Richard P. Curnow  1997-2003
+ * Copyright (C) Timo Teras  2009
+ * Copyright (C) Miroslav Lichvar  2009, 2013-2020
+ * Copyright (C) Luke Valenta  2023
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ * 
+ * This program 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
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ * 
+ **********************************************************************
+
+  =======================================================================
+
+  This file implements socket operations.
+
+  */
+
+#include "config.h"
+
+#include "sysincl.h"
+
+#ifdef HAVE_LINUX_TIMESTAMPING
+#include <linux/errqueue.h>
+#include <linux/net_tstamp.h>
+#endif
+
+#include "socket.h"
+#include "array.h"
+#include "logging.h"
+#include "privops.h"
+#include "ptp.h"
+#include "util.h"
+
+#define INVALID_SOCK_FD (-4)
+#define CMSG_BUF_SIZE 256
+
+union sockaddr_all {
+  struct sockaddr_in in4;
+#ifdef FEAT_IPV6
+  struct sockaddr_in6 in6;
+#endif
+  struct sockaddr_un un;
+  struct sockaddr sa;
+};
+
+struct Message {
+  union sockaddr_all name;
+  struct iovec iov;
+  /* Buffer of sufficient length for all expected messages */
+  struct {
+    /* Extra space for Ethernet, IPv4/IPv6, and UDP headers in
+       timestamped messages received from the Linux error queue */
+    uint8_t l234_headers[64];
+    union {
+      NTP_Packet ntp_msg;
+      PTP_NtpMessage ptp_msg;
+      CMD_Request cmd_request;
+      CMD_Reply cmd_reply;
+    } msg;
+  } msg_buf;
+  /* Aligned buffer for control messages */
+  struct cmsghdr cmsg_buf[CMSG_BUF_SIZE / sizeof (struct cmsghdr)];
+};
+
+#ifdef HAVE_RECVMMSG
+#define MAX_RECV_MESSAGES 16
+#define MessageHeader mmsghdr
+#else
+/* Compatible with mmsghdr */
+struct MessageHeader {
+  struct msghdr msg_hdr;
+  unsigned int msg_len;
+};
+
+#define MAX_RECV_MESSAGES 1
+#endif
+
+static int initialised;
+
+static int first_reusable_fd;
+static int reusable_fds;
+
+/* Flags indicating in which IP families sockets can be requested */
+static int ip4_enabled;
+static int ip6_enabled;
+
+/* Flags supported by socket() */
+static int supported_socket_flags;
+
+/* Arrays of Message, MessageHeader, and SCK_Message */
+static ARR_Instance recv_messages;
+static ARR_Instance recv_headers;
+static ARR_Instance recv_sck_messages;
+
+static unsigned int received_messages;
+
+static int (*priv_bind_function)(int sock_fd, struct sockaddr *address,
+                                 socklen_t address_len);
+
+/* ================================================== */
+
+static void
+prepare_buffers(unsigned int n)
+{
+  struct MessageHeader *hdr;
+  struct Message *msg;
+  unsigned int i;
+
+  for (i = 0; i < n; i++) {
+    msg = ARR_GetElement(recv_messages, i);
+    hdr = ARR_GetElement(recv_headers, i);
+
+    msg->iov.iov_base = &msg->msg_buf;
+    msg->iov.iov_len = sizeof (msg->msg_buf);
+    hdr->msg_hdr.msg_name = &msg->name;
+    hdr->msg_hdr.msg_namelen = sizeof (msg->name);
+    hdr->msg_hdr.msg_iov = &msg->iov;
+    hdr->msg_hdr.msg_iovlen = 1;
+    hdr->msg_hdr.msg_control = msg->cmsg_buf;
+    hdr->msg_hdr.msg_controllen = sizeof (msg->cmsg_buf);
+    hdr->msg_hdr.msg_flags = 0;
+    hdr->msg_len = 0;
+  }
+}
+
+/* ================================================== */
+
+static const char *
+domain_to_string(int domain)
+{
+  switch (domain) {
+    case AF_INET:
+      return "IPv4";
+#ifdef AF_INET6
+    case AF_INET6:
+      return "IPv6";
+#endif
+    case AF_UNIX:
+      return "Unix";
+    case AF_UNSPEC:
+      return "UNSPEC";
+    default:
+      return "?";
+  }
+}
+
+/* ================================================== */
+
+static int
+get_reusable_socket(int type, IPSockAddr *spec)
+{
+#ifdef LINUX
+  union sockaddr_all sa;
+  IPSockAddr ip_sa;
+  int sock_fd, opt;
+  socklen_t l;
+
+  /* Abort early if not an IPv4/IPv6 server socket */
+  if (!spec || spec->ip_addr.family == IPADDR_UNSPEC || spec->port == 0)
+    return INVALID_SOCK_FD;
+
+  /* Loop over available reusable sockets */
+  for (sock_fd = first_reusable_fd; sock_fd < first_reusable_fd + reusable_fds; sock_fd++) {
+
+    /* Check that types match */
+    l = sizeof (opt);
+    if (getsockopt(sock_fd, SOL_SOCKET, SO_TYPE, &opt, &l) < 0 ||
+        l != sizeof (opt) || opt != type)
+      continue;
+
+    /* Get sockaddr for reusable socket */
+    l = sizeof (sa);
+    if (getsockname(sock_fd, &sa.sa, &l) < 0 || l < sizeof (sa_family_t))
+      continue;
+    SCK_SockaddrToIPSockAddr(&sa.sa, l, &ip_sa);
+
+    /* Check that reusable socket matches specification */
+    if (ip_sa.port != spec->port || UTI_CompareIPs(&ip_sa.ip_addr, &spec->ip_addr, NULL) != 0)
+      continue;
+
+    /* Check that STREAM socket is listening */
+    l = sizeof (opt);
+    if (type == SOCK_STREAM && (getsockopt(sock_fd, SOL_SOCKET, SO_ACCEPTCONN, &opt, &l) < 0 ||
+                                l != sizeof (opt) || opt == 0))
+      continue;
+
+#if defined(FEAT_IPV6) && defined(IPV6_V6ONLY)
+    if (spec->ip_addr.family == IPADDR_INET6 &&
+        (!SCK_GetIntOption(sock_fd, IPPROTO_IPV6, IPV6_V6ONLY, &opt) || opt != 1))
+      LOG(LOGS_WARN, "Reusable IPv6 socket missing IPV6_V6ONLY option");
+#endif
+
+    return sock_fd;
+  }
+#endif
+
+  return INVALID_SOCK_FD;
+}
+
+/* ================================================== */
+
+#if defined(SOCK_CLOEXEC) || defined(SOCK_NONBLOCK)
+static int
+check_socket_flag(int sock_flag, int fd_flag, int fs_flag)
+{
+  int sock_fd, fd_flags, fs_flags;
+
+  sock_fd = socket(AF_INET, SOCK_DGRAM | sock_flag, 0);
+  if (sock_fd < 0)
+    return 0;
+
+  fd_flags = fcntl(sock_fd, F_GETFD);
+  fs_flags = fcntl(sock_fd, F_GETFL);
+
+  close(sock_fd);
+
+  if (fd_flags == -1 || (fd_flags & fd_flag) != fd_flag ||
+      fs_flags == -1 || (fs_flags & fs_flag) != fs_flag)
+    return 0;
+
+  return 1;
+}
+#endif
+
+/* ================================================== */
+
+static int
+set_socket_nonblock(int sock_fd)
+{
+  if (fcntl(sock_fd, F_SETFL, O_NONBLOCK) < 0) {
+    DEBUG_LOG("Could not set O_NONBLOCK : %s", strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+get_open_flags(int flags)
+{
+  int r = supported_socket_flags;
+
+#ifdef SOCK_NONBLOCK
+  if (flags & SCK_FLAG_BLOCK)
+    r &= ~SOCK_NONBLOCK;
+#endif
+
+  return r;
+}
+
+/* ================================================== */
+
+static int
+set_socket_flags(int sock_fd, int flags)
+{
+  /* Close the socket automatically on exec */
+  if (!SCK_IsReusable(sock_fd) &&
+#ifdef SOCK_CLOEXEC
+      (supported_socket_flags & SOCK_CLOEXEC) == 0 &&
+#endif
+      !UTI_FdSetCloexec(sock_fd))
+    return 0;
+
+  /* Enable non-blocking mode */
+  if ((flags & SCK_FLAG_BLOCK) == 0 &&
+#ifdef SOCK_NONBLOCK
+      (SCK_IsReusable(sock_fd) || (supported_socket_flags & SOCK_NONBLOCK) == 0) &&
+#endif
+      !set_socket_nonblock(sock_fd))
+    return 0;
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+open_socket(int domain, int type, int flags)
+{
+  int sock_fd;
+
+  sock_fd = socket(domain, type | get_open_flags(flags), 0);
+
+  if (sock_fd < 0) {
+    DEBUG_LOG("Could not open %s socket : %s",
+              domain_to_string(domain), strerror(errno));
+    return INVALID_SOCK_FD;
+  }
+
+  if (!set_socket_flags(sock_fd, flags)) {
+    close(sock_fd);
+    return INVALID_SOCK_FD;
+  }
+
+  return sock_fd;
+}
+
+/* ================================================== */
+
+static int
+open_socket_pair(int domain, int type, int flags, int *other_fd)
+{
+  int sock_fds[2];
+
+  if (socketpair(domain, type | get_open_flags(flags), 0, sock_fds) < 0) {
+    DEBUG_LOG("Could not open %s socket : %s",
+              domain_to_string(domain), strerror(errno));
+    return INVALID_SOCK_FD;
+  }
+
+  if (!set_socket_flags(sock_fds[0], flags) || !set_socket_flags(sock_fds[1], flags)) {
+    close(sock_fds[0]);
+    close(sock_fds[1]);
+    return INVALID_SOCK_FD;
+  }
+
+  *other_fd = sock_fds[1];
+
+  return sock_fds[0];
+}
+
+/* ================================================== */
+
+static int
+get_ip_socket(int domain, int type, int flags, IPSockAddr *ip_sa)
+{
+  int sock_fd;
+
+  /* Check if there is a matching reusable socket */
+  sock_fd = get_reusable_socket(type, ip_sa);
+
+  if (sock_fd < 0) {
+    sock_fd = open_socket(domain, type, flags);
+
+    /* Unexpected, but make sure the new socket is not in the reusable range */
+    if (SCK_IsReusable(sock_fd))
+      LOG_FATAL("Could not open %s socket : file descriptor in reusable range",
+                domain_to_string(domain));
+  } else {
+    /* Set socket flags on reusable socket */
+    if (!set_socket_flags(sock_fd, flags))
+      return INVALID_SOCK_FD;
+  }
+
+  return sock_fd;
+}
+
+/* ================================================== */
+
+static int
+set_socket_options(int sock_fd, int flags)
+{
+  /* Make the socket capable of sending broadcast packets if requested */
+  if (flags & SCK_FLAG_BROADCAST && !SCK_SetIntOption(sock_fd, SOL_SOCKET, SO_BROADCAST, 1))
+    ;
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+set_ip_options(int sock_fd, int family, int flags)
+{
+#if defined(FEAT_IPV6) && defined(IPV6_V6ONLY)
+  /* Receive only IPv6 packets on an IPv6 socket, but do not attempt
+     to set this option on pre-initialised reuseable sockets */
+  if (family == IPADDR_INET6 && !SCK_IsReusable(sock_fd) &&
+      !SCK_SetIntOption(sock_fd, IPPROTO_IPV6, IPV6_V6ONLY, 1))
+    return 0;
+#endif
+
+  /* Provide destination address of received packets if requested */
+  if (flags & SCK_FLAG_RX_DEST_ADDR) {
+    if (family == IPADDR_INET4) {
+#ifdef HAVE_IN_PKTINFO
+      if (!SCK_SetIntOption(sock_fd, IPPROTO_IP, IP_PKTINFO, 1))
+        ;
+#elif defined(IP_RECVDSTADDR)
+      if (!SCK_SetIntOption(sock_fd, IPPROTO_IP, IP_RECVDSTADDR, 1))
+        ;
+#endif
+    }
+#ifdef FEAT_IPV6
+    else if (family == IPADDR_INET6) {
+#ifdef HAVE_IN6_PKTINFO
+#ifdef IPV6_RECVPKTINFO
+      if (!SCK_SetIntOption(sock_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, 1))
+        ;
+#else
+      if (!SCK_SetIntOption(sock_fd, IPPROTO_IPV6, IPV6_PKTINFO, 1))
+        ;
+#endif
+#endif
+    }
+#endif
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+is_any_address(IPAddr *addr)
+{
+  IPAddr any_addr;
+
+  SCK_GetAnyLocalIPAddress(addr->family, &any_addr);
+
+  return UTI_CompareIPs(&any_addr, addr, NULL) == 0;
+}
+
+/* ================================================== */
+
+static int
+bind_device(int sock_fd, const char *iface)
+{
+#ifdef SO_BINDTODEVICE
+  if (setsockopt(sock_fd, SOL_SOCKET, SO_BINDTODEVICE, iface, strlen(iface) + 1) < 0) {
+    DEBUG_LOG("Could not bind socket to %s : %s", iface, strerror(errno));
+    return 0;
+  }
+  return 1;
+#else
+  DEBUG_LOG("Could not bind socket to %s : %s", iface, "Not supported");
+  return 0;
+#endif
+}
+
+/* ================================================== */
+
+static int
+bind_ip_address(int sock_fd, IPSockAddr *addr, int flags)
+{
+  union sockaddr_all saddr;
+  socklen_t saddr_len;
+  int s;
+
+  /* Make the socket capable of re-using an old address if binding to a specific port */
+  if (addr->port > 0 && !SCK_SetIntOption(sock_fd, SOL_SOCKET, SO_REUSEADDR, 1))
+    ;
+
+#if defined(LINUX) && defined(SO_REUSEPORT)
+  /* Allow multiple instances to bind to the same port in order to enable load
+     balancing.  Don't enable this option on non-Linux systems as it has
+     a slightly different meaning there (with some important implications). */
+  if (addr->port > 0 && !SCK_SetIntOption(sock_fd, SOL_SOCKET, SO_REUSEPORT, 1))
+    ;
+#endif
+
+#ifdef IP_FREEBIND
+  /* Allow binding to an address that doesn't exist yet */
+  if (!SCK_SetIntOption(sock_fd, IPPROTO_IP, IP_FREEBIND, 1))
+    ;
+#endif
+
+  /* Do not attempt to bind pre-initialised reusable socket */
+  if (SCK_IsReusable(sock_fd))
+    return 1;
+
+  saddr_len = SCK_IPSockAddrToSockaddr(addr, (struct sockaddr *)&saddr, sizeof (saddr));
+  if (saddr_len == 0)
+    return 0;
+
+  if (flags & SCK_FLAG_PRIV_BIND && priv_bind_function)
+    s = priv_bind_function(sock_fd, &saddr.sa, saddr_len);
+  else
+    s = bind(sock_fd, &saddr.sa, saddr_len);
+
+  if (s < 0) {
+    DEBUG_LOG("Could not bind socket to %s : %s",
+              UTI_IPSockAddrToString(addr), strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+connect_ip_address(int sock_fd, IPSockAddr *addr)
+{
+  union sockaddr_all saddr;
+  socklen_t saddr_len;
+
+  saddr_len = SCK_IPSockAddrToSockaddr(addr, (struct sockaddr *)&saddr, sizeof (saddr));
+  if (saddr_len == 0)
+    return 0;
+
+  if (connect(sock_fd, &saddr.sa, saddr_len) < 0 && errno != EINPROGRESS) {
+    DEBUG_LOG("Could not connect socket to %s : %s",
+              UTI_IPSockAddrToString(addr), strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+open_ip_socket(IPSockAddr *remote_addr, IPSockAddr *local_addr, const char *iface,
+               int type, int flags)
+{
+  int domain, family, sock_fd;
+
+  if (local_addr)
+    family = local_addr->ip_addr.family;
+  else if (remote_addr)
+    family = remote_addr->ip_addr.family;
+  else
+    family = IPADDR_INET4;
+
+  switch (family) {
+    case IPADDR_INET4:
+      if (!ip4_enabled)
+        return INVALID_SOCK_FD;
+      domain = AF_INET;
+      break;
+#ifdef FEAT_IPV6
+    case IPADDR_INET6:
+      if (!ip6_enabled)
+        return INVALID_SOCK_FD;
+      domain = AF_INET6;
+      break;
+#endif
+    default:
+      DEBUG_LOG("Unspecified family");
+      return INVALID_SOCK_FD;
+  }
+
+  sock_fd = get_ip_socket(domain, type, flags, local_addr);
+  if (sock_fd < 0)
+    return INVALID_SOCK_FD;
+
+  if (!set_socket_options(sock_fd, flags))
+    goto error;
+
+  if (!set_ip_options(sock_fd, family, flags))
+    goto error;
+
+  if (iface && !bind_device(sock_fd, iface))
+    goto error;
+
+  /* Bind the socket if a non-any local address/port was specified */
+  if (local_addr && local_addr->ip_addr.family != IPADDR_UNSPEC &&
+      (local_addr->port != 0 || !is_any_address(&local_addr->ip_addr)) &&
+      !bind_ip_address(sock_fd, local_addr, flags))
+    goto error;
+
+  /* Connect the socket if a remote address was specified */
+  if (remote_addr && remote_addr->ip_addr.family != IPADDR_UNSPEC &&
+      !connect_ip_address(sock_fd, remote_addr))
+    goto error;
+
+  if (remote_addr || local_addr)
+    DEBUG_LOG("%s %s%s socket fd=%d%s%s%s%s",
+              SCK_IsReusable(sock_fd) ? "Reusing" : "Opened",
+              type == SOCK_DGRAM ? "UDP" : type == SOCK_STREAM ? "TCP" : "?",
+              family == IPADDR_INET4 ? "v4" : "v6",
+              sock_fd,
+              remote_addr ? " remote=" : "",
+              remote_addr ? UTI_IPSockAddrToString(remote_addr) : "",
+              local_addr ? " local=" : "",
+              local_addr ? UTI_IPSockAddrToString(local_addr) : "");
+
+  return sock_fd;
+
+error:
+  SCK_CloseSocket(sock_fd);
+  return INVALID_SOCK_FD;
+}
+
+/* ================================================== */
+
+static int
+bind_unix_address(int sock_fd, const char *addr, int flags)
+{
+  union sockaddr_all saddr;
+
+  memset(&saddr, 0, sizeof (saddr));
+
+  if (snprintf(saddr.un.sun_path, sizeof (saddr.un.sun_path), "%s", addr) >=
+      sizeof (saddr.un.sun_path)) {
+    DEBUG_LOG("Unix socket path %s too long", addr);
+    return 0;
+  }
+  saddr.un.sun_family = AF_UNIX;
+
+  if (unlink(addr) < 0)
+    DEBUG_LOG("Could not remove %s : %s", addr, strerror(errno));
+
+  /* PRV_BindSocket() doesn't support Unix sockets yet */
+  if (bind(sock_fd, &saddr.sa, sizeof (saddr.un)) < 0) {
+    DEBUG_LOG("Could not bind Unix socket to %s : %s", addr, strerror(errno));
+    return 0;
+  }
+
+  /* Allow access to everyone with access to the directory if requested */
+  if (flags & SCK_FLAG_ALL_PERMISSIONS && chmod(addr, 0666) < 0) {
+    DEBUG_LOG("Could not change permissions of %s : %s", addr, strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+connect_unix_address(int sock_fd, const char *addr)
+{
+  union sockaddr_all saddr;
+
+  memset(&saddr, 0, sizeof (saddr));
+
+  if (snprintf(saddr.un.sun_path, sizeof (saddr.un.sun_path), "%s", addr) >=
+      sizeof (saddr.un.sun_path)) {
+    DEBUG_LOG("Unix socket path %s too long", addr);
+    return 0;
+  }
+  saddr.un.sun_family = AF_UNIX;
+
+  if (connect(sock_fd, &saddr.sa, sizeof (saddr.un)) < 0) {
+    DEBUG_LOG("Could not connect Unix socket to %s : %s", addr, strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+static int
+open_unix_socket(const char *remote_addr, const char *local_addr, int type, int flags)
+{
+  int sock_fd;
+
+  sock_fd = open_socket(AF_UNIX, type, flags);
+  if (sock_fd < 0)
+    return INVALID_SOCK_FD;
+
+  if (!set_socket_options(sock_fd, flags))
+    goto error;
+
+  /* Bind the socket if a local address was specified */
+  if (local_addr && !bind_unix_address(sock_fd, local_addr, flags))
+    goto error;
+
+  /* Connect the socket if a remote address was specified */
+  if (remote_addr && !connect_unix_address(sock_fd, remote_addr))
+    goto error;
+
+  DEBUG_LOG("Opened Unix socket fd=%d%s%s%s%s",
+            sock_fd,
+            remote_addr ? " remote=" : "", remote_addr ? remote_addr : "",
+            local_addr ? " local=" : "", local_addr ? local_addr : "");
+
+  return sock_fd;
+
+error:
+  SCK_RemoveSocket(sock_fd);
+  SCK_CloseSocket(sock_fd);
+  return INVALID_SOCK_FD;
+}
+
+/* ================================================== */
+
+static int
+open_unix_socket_pair(int type, int flags, int *other_fd)
+{
+  int sock_fd;
+
+  sock_fd = open_socket_pair(AF_UNIX, type, flags, other_fd);
+  if (sock_fd < 0)
+    return INVALID_SOCK_FD;
+
+  DEBUG_LOG("Opened Unix socket pair fd1=%d fd2=%d", sock_fd, *other_fd);
+
+  return sock_fd;
+}
+
+/* ================================================== */
+
+static int
+get_recv_flags(int flags)
+{
+  int recv_flags = 0;
+
+  if (flags & SCK_FLAG_MSG_ERRQUEUE) {
+#ifdef MSG_ERRQUEUE
+    recv_flags |= MSG_ERRQUEUE;
+#else
+    assert(0);
+#endif
+  }
+
+  return recv_flags;
+}
+
+/* ================================================== */
+
+static void
+handle_recv_error(int sock_fd, int flags)
+{
+#ifdef MSG_ERRQUEUE
+  /* If reading from the error queue failed, the select() exception should
+     be for a socket error.  Clear the error to avoid a busy loop. */
+  if (flags & SCK_FLAG_MSG_ERRQUEUE) {
+    int error = 0;
+
+    if (SCK_GetIntOption(sock_fd, SOL_SOCKET, SO_ERROR, &error))
+      errno = error;
+  }
+#endif
+
+  DEBUG_LOG("Could not receive message fd=%d : %s", sock_fd, strerror(errno));
+}
+
+/* ================================================== */
+
+static void
+log_message(int sock_fd, int direction, SCK_Message *message, const char *prefix,
+            const char *error)
+{
+  const char *local_addr, *remote_addr;
+  char if_index[20], tss[10], tsif[20], tslen[20];
+
+  if (DEBUG <= 0 || log_min_severity > LOGS_DEBUG)
+    return;
+
+  remote_addr = NULL;
+  local_addr = NULL;
+  if_index[0] = '\0';
+  tss[0] = '\0';
+  tsif[0] = '\0';
+  tslen[0] = '\0';
+
+  switch (message->addr_type) {
+    case SCK_ADDR_IP:
+      if (message->remote_addr.ip.ip_addr.family != IPADDR_UNSPEC)
+        remote_addr = UTI_IPSockAddrToString(&message->remote_addr.ip);
+      if (message->local_addr.ip.family != IPADDR_UNSPEC)
+        local_addr = UTI_IPToString(&message->local_addr.ip);
+      break;
+    case SCK_ADDR_UNIX:
+      remote_addr = message->remote_addr.path;
+      break;
+    default:
+      break;
+  }
+
+  if (message->if_index != INVALID_IF_INDEX)
+    snprintf(if_index, sizeof (if_index), " if=%d", message->if_index);
+
+  if (direction > 0) {
+    if (!UTI_IsZeroTimespec(&message->timestamp.kernel) ||
+        !UTI_IsZeroTimespec(&message->timestamp.hw))
+      snprintf(tss, sizeof (tss), " tss=%s%s",
+               !UTI_IsZeroTimespec(&message->timestamp.kernel) ? "K" : "",
+               !UTI_IsZeroTimespec(&message->timestamp.hw) ? "H" : "");
+
+    if (message->timestamp.if_index != INVALID_IF_INDEX)
+      snprintf(tsif, sizeof (tsif), " tsif=%d", message->timestamp.if_index);
+
+    if (message->timestamp.l2_length != 0)
+      snprintf(tslen, sizeof (tslen), " tslen=%d", message->timestamp.l2_length);
+  }
+
+  DEBUG_LOG("%s message%s%s%s%s fd=%d len=%d%s%s%s%s%s%s",
+            prefix,
+            remote_addr ? (direction > 0 ? " from " : " to ") : "",
+            remote_addr ? remote_addr : "",
+            local_addr ? (direction > 0 ? " to " : " from ") : "",
+            local_addr ? local_addr : "",
+            sock_fd, message->length, if_index,
+            tss, tsif, tslen,
+            error ? " : " : "", error ? error : "");
+}
+
+/* ================================================== */
+
+static void
+init_message_addresses(SCK_Message *message, SCK_AddressType addr_type)
+{
+  message->addr_type = addr_type;
+
+  switch (addr_type) {
+    case SCK_ADDR_UNSPEC:
+      break;
+    case SCK_ADDR_IP:
+      message->remote_addr.ip.ip_addr.family = IPADDR_UNSPEC;
+      message->remote_addr.ip.port = 0;
+      message->local_addr.ip.family = IPADDR_UNSPEC;
+      break;
+    case SCK_ADDR_UNIX:
+      message->remote_addr.path = NULL;
+      break;
+    default:
+      assert(0);
+  }
+}
+
+/* ================================================== */
+
+static void
+init_message_nonaddress(SCK_Message *message)
+{
+  message->data = NULL;
+  message->length = 0;
+  message->if_index = INVALID_IF_INDEX;
+
+  UTI_ZeroTimespec(&message->timestamp.kernel);
+  UTI_ZeroTimespec(&message->timestamp.hw);
+  message->timestamp.if_index = INVALID_IF_INDEX;
+  message->timestamp.l2_length = 0;
+  message->timestamp.tx_flags = 0;
+
+  message->descriptor = INVALID_SOCK_FD;
+}
+
+/* ================================================== */
+
+static int
+match_cmsg(struct cmsghdr *cmsg, int level, int type, size_t length)
+{
+  if (cmsg->cmsg_type == type && cmsg->cmsg_level == level &&
+      (length == 0 || cmsg->cmsg_len == CMSG_LEN(length)))
+    return 1;
+  return 0;
+}
+
+/* ================================================== */
+
+static int
+process_header(struct msghdr *msg, int msg_length, int sock_fd, int flags,
+               SCK_Message *message)
+{
+  struct cmsghdr *cmsg;
+  int r = 1;
+
+  if (msg->msg_namelen <= sizeof (union sockaddr_all) &&
+      msg->msg_namelen > sizeof (((struct sockaddr *)msg->msg_name)->sa_family)) {
+    switch (((struct sockaddr *)msg->msg_name)->sa_family) {
+      case AF_INET:
+#ifdef FEAT_IPV6
+      case AF_INET6:
+#endif
+        init_message_addresses(message, SCK_ADDR_IP);
+        SCK_SockaddrToIPSockAddr(msg->msg_name, msg->msg_namelen, &message->remote_addr.ip);
+        break;
+      case AF_UNIX:
+        init_message_addresses(message, SCK_ADDR_UNIX);
+        message->remote_addr.path = ((struct sockaddr_un *)msg->msg_name)->sun_path;
+        break;
+      default:
+        init_message_addresses(message, SCK_ADDR_UNSPEC);
+        DEBUG_LOG("Unexpected address");
+        r = 0;
+        break;
+    }
+  } else {
+    init_message_addresses(message, SCK_ADDR_UNSPEC);
+
+    if (msg->msg_namelen > sizeof (union sockaddr_all)) {
+      DEBUG_LOG("Truncated source address");
+      r = 0;
+    }
+  }
+
+  init_message_nonaddress(message);
+
+  if (msg->msg_iovlen == 1) {
+    message->data = msg->msg_iov[0].iov_base;
+    message->length = msg_length;
+  } else {
+    DEBUG_LOG("Unexpected iovlen");
+    r = 0;
+  }
+
+  if (msg->msg_flags & MSG_TRUNC) {
+    log_message(sock_fd, 1, message, "Truncated", NULL);
+    r = 0;
+  }
+
+  if (msg->msg_flags & MSG_CTRUNC) {
+    log_message(sock_fd, 1, message, "Truncated cmsg in", NULL);
+    r = 0;
+  }
+
+  for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
+    if (0) {
+    }
+#ifdef HAVE_IN_PKTINFO
+    else if (match_cmsg(cmsg, IPPROTO_IP, IP_PKTINFO, sizeof (struct in_pktinfo))) {
+      struct in_pktinfo ipi;
+
+      if (message->addr_type != SCK_ADDR_IP)
+        init_message_addresses(message, SCK_ADDR_IP);
+
+      memcpy(&ipi, CMSG_DATA(cmsg), sizeof (ipi));
+      message->local_addr.ip.addr.in4 = ntohl(ipi.ipi_addr.s_addr);
+      message->local_addr.ip.family = IPADDR_INET4;
+      message->if_index = ipi.ipi_ifindex;
+    }
+#elif defined(IP_RECVDSTADDR)
+    else if (match_cmsg(cmsg, IPPROTO_IP, IP_RECVDSTADDR, sizeof (struct in_addr))) {
+      struct in_addr addr;
+
+      if (message->addr_type != SCK_ADDR_IP)
+        init_message_addresses(message, SCK_ADDR_IP);
+
+      memcpy(&addr, CMSG_DATA(cmsg), sizeof (addr));
+      message->local_addr.ip.addr.in4 = ntohl(addr.s_addr);
+      message->local_addr.ip.family = IPADDR_INET4;
+    }
+#endif
+#ifdef HAVE_IN6_PKTINFO
+    else if (match_cmsg(cmsg, IPPROTO_IPV6, IPV6_PKTINFO, sizeof (struct in6_pktinfo))) {
+      struct in6_pktinfo ipi;
+
+      if (message->addr_type != SCK_ADDR_IP)
+        init_message_addresses(message, SCK_ADDR_IP);
+
+      memcpy(&ipi, CMSG_DATA(cmsg), sizeof (ipi));
+      memcpy(&message->local_addr.ip.addr.in6, &ipi.ipi6_addr.s6_addr,
+             sizeof (message->local_addr.ip.addr.in6));
+      message->local_addr.ip.family = IPADDR_INET6;
+      message->if_index = ipi.ipi6_ifindex;
+    }
+#endif
+#ifdef SCM_TIMESTAMP
+    else if (match_cmsg(cmsg, SOL_SOCKET, SCM_TIMESTAMP, sizeof (struct timeval))) {
+      struct timeval tv;
+
+      memcpy(&tv, CMSG_DATA(cmsg), sizeof (tv));
+      UTI_TimevalToTimespec(&tv, &message->timestamp.kernel);
+    }
+#endif
+#ifdef SCM_TIMESTAMPNS
+    else if (match_cmsg(cmsg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof (message->timestamp.kernel))) {
+      memcpy(&message->timestamp.kernel, CMSG_DATA(cmsg), sizeof (message->timestamp.kernel));
+    }
+#endif
+#ifdef SCM_REALTIME
+    else if (match_cmsg(cmsg, SOL_SOCKET, SCM_REALTIME, sizeof (message->timestamp.kernel))) {
+      memcpy(&message->timestamp.kernel, CMSG_DATA(cmsg), sizeof (message->timestamp.kernel));
+    }
+#endif
+#ifdef HAVE_LINUX_TIMESTAMPING
+#ifdef HAVE_LINUX_TIMESTAMPING_OPT_PKTINFO
+    else if (match_cmsg(cmsg, SOL_SOCKET, SCM_TIMESTAMPING_PKTINFO,
+                        sizeof (struct scm_ts_pktinfo))) {
+      struct scm_ts_pktinfo ts_pktinfo;
+
+      memcpy(&ts_pktinfo, CMSG_DATA(cmsg), sizeof (ts_pktinfo));
+      message->timestamp.if_index = ts_pktinfo.if_index;
+      message->timestamp.l2_length = ts_pktinfo.pkt_length;
+    }
+#endif
+    else if (match_cmsg(cmsg, SOL_SOCKET, SCM_TIMESTAMPING,
+                        sizeof (struct scm_timestamping))) {
+      struct scm_timestamping ts3;
+
+      memcpy(&ts3, CMSG_DATA(cmsg), sizeof (ts3));
+      message->timestamp.kernel = ts3.ts[0];
+      message->timestamp.hw = ts3.ts[2];
+    }
+    else if ((match_cmsg(cmsg, SOL_IP, IP_RECVERR, 0) ||
+              match_cmsg(cmsg, SOL_IPV6, IPV6_RECVERR, 0)) &&
+             cmsg->cmsg_len >= CMSG_LEN(sizeof (struct sock_extended_err))) {
+      struct sock_extended_err err;
+
+      memcpy(&err, CMSG_DATA(cmsg), sizeof (err));
+
+      if (err.ee_errno != ENOMSG || err.ee_info != SCM_TSTAMP_SND ||
+          err.ee_origin != SO_EE_ORIGIN_TIMESTAMPING) {
+        log_message(sock_fd, 1, message, "Unexpected extended error in", NULL);
+        r = 0;
+      }
+    }
+#endif
+    else if (match_cmsg(cmsg, SOL_SOCKET, SCM_RIGHTS, 0)) {
+      if (!(flags & SCK_FLAG_MSG_DESCRIPTOR) || cmsg->cmsg_len != CMSG_LEN(sizeof (int))) {
+        int i, fd;
+
+        DEBUG_LOG("Unexpected SCM_RIGHTS");
+        for (i = 0; CMSG_LEN((i + 1) * sizeof (int)) <= cmsg->cmsg_len; i++) {
+          memcpy(&fd, (char *)CMSG_DATA(cmsg) + i * sizeof (int), sizeof (fd));
+          close(fd);
+        }
+        r = 0;
+      } else {
+        memcpy(&message->descriptor, CMSG_DATA(cmsg), sizeof (message->descriptor));
+      }
+    }
+    else {
+      DEBUG_LOG("Unexpected control message level=%d type=%d len=%d",
+                cmsg->cmsg_level, cmsg->cmsg_type, (int)cmsg->cmsg_len);
+    }
+  }
+
+  if (!r && message->descriptor != INVALID_SOCK_FD)
+    close(message->descriptor);
+
+  return r;
+}
+
+/* ================================================== */
+
+static SCK_Message *
+receive_messages(int sock_fd, int flags, int max_messages, int *num_messages)
+{
+  struct MessageHeader *hdr;
+  SCK_Message *messages;
+  unsigned int i, n, n_ok;
+  int ret, recv_flags = 0;
+
+  assert(initialised);
+
+  *num_messages = 0;
+
+  if (max_messages < 1)
+    return NULL;
+
+  /* Prepare used buffers for new messages */
+  prepare_buffers(received_messages);
+  received_messages = 0;
+
+  messages = ARR_GetElements(recv_sck_messages);
+
+  hdr = ARR_GetElements(recv_headers);
+  n = ARR_GetSize(recv_headers);
+  n = MIN(n, max_messages);
+
+  if (n < 1 || n > MAX_RECV_MESSAGES ||
+      n > ARR_GetSize(recv_messages) || n > ARR_GetSize(recv_sck_messages))
+    assert(0);
+
+  recv_flags = get_recv_flags(flags);
+
+#ifdef HAVE_RECVMMSG
+  ret = recvmmsg(sock_fd, hdr, n, recv_flags, NULL);
+  if (ret >= 0)
+    n = ret;
+#else
+  n = 1;
+  ret = recvmsg(sock_fd, &hdr[0].msg_hdr, recv_flags);
+  if (ret >= 0)
+    hdr[0].msg_len = ret;
+#endif
+
+  if (ret < 0) {
+    handle_recv_error(sock_fd, flags);
+    return NULL;
+  }
+
+  received_messages = n;
+
+  for (i = n_ok = 0; i < n; i++) {
+    hdr = ARR_GetElement(recv_headers, i);
+    if (!process_header(&hdr->msg_hdr, hdr->msg_len, sock_fd, flags, &messages[n_ok]))
+      continue;
+
+    log_message(sock_fd, 1, &messages[n_ok],
+                flags & SCK_FLAG_MSG_ERRQUEUE ? "Received error" : "Received", NULL);
+
+    n_ok++;
+  }
+
+  *num_messages = n_ok;
+
+  return n_ok > 0 ? messages : NULL;
+}
+
+/* ================================================== */
+
+static void *
+add_control_message(struct msghdr *msg, int level, int type, size_t length, size_t buf_length)
+{
+  struct cmsghdr *cmsg;
+  size_t cmsg_space;
+
+  /* Avoid using CMSG_NXTHDR as the one in glibc does not support adding
+     control messages: https://sourceware.org/bugzilla/show_bug.cgi?id=13500 */
+
+  cmsg = msg->msg_control;
+  cmsg_space = CMSG_SPACE(length);
+
+  if (!cmsg || length > buf_length || msg->msg_controllen + cmsg_space > buf_length) {
+    DEBUG_LOG("Could not add control message level=%d type=%d", level, type);
+    return NULL;
+  }
+
+  cmsg = (struct cmsghdr *)((char *)cmsg + msg->msg_controllen);
+
+  memset(cmsg, 0, cmsg_space);
+
+  cmsg->cmsg_level = level;
+  cmsg->cmsg_type = type;
+  cmsg->cmsg_len = CMSG_LEN(length);
+
+  msg->msg_controllen += cmsg_space;
+
+  return CMSG_DATA(cmsg);
+}
+
+/* ================================================== */
+
+static int
+send_message(int sock_fd, SCK_Message *message, int flags)
+{
+  struct cmsghdr cmsg_buf[CMSG_BUF_SIZE / sizeof (struct cmsghdr)];
+  union sockaddr_all saddr;
+  socklen_t saddr_len;
+  struct msghdr msg;
+  struct iovec iov;
+
+  switch (message->addr_type) {
+    case SCK_ADDR_UNSPEC:
+      saddr_len = 0;
+      break;
+    case SCK_ADDR_IP:
+      saddr_len = SCK_IPSockAddrToSockaddr(&message->remote_addr.ip,
+                                           (struct sockaddr *)&saddr, sizeof (saddr));
+      break;
+    case SCK_ADDR_UNIX:
+      memset(&saddr, 0, sizeof (saddr));
+      if (snprintf(saddr.un.sun_path, sizeof (saddr.un.sun_path), "%s",
+                   message->remote_addr.path) >= sizeof (saddr.un.sun_path)) {
+        DEBUG_LOG("Unix socket path %s too long", message->remote_addr.path);
+        return 0;
+      }
+      saddr.un.sun_family = AF_UNIX;
+      saddr_len = sizeof (saddr.un);
+      break;
+    default:
+      assert(0);
+  }
+
+  if (saddr_len) {
+    msg.msg_name = &saddr.un;
+    msg.msg_namelen = saddr_len;
+  } else {
+    msg.msg_name = NULL;
+    msg.msg_namelen = 0;
+  }
+
+  if (message->length < 0) {
+    DEBUG_LOG("Invalid length %d", message->length);
+    return 0;
+  }
+
+  iov.iov_base = message->data;
+  iov.iov_len = message->length;
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = cmsg_buf;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+
+  if (message->addr_type == SCK_ADDR_IP) {
+    if (message->local_addr.ip.family == IPADDR_INET4) {
+#ifdef HAVE_IN_PKTINFO
+      struct in_pktinfo *ipi;
+
+      ipi = add_control_message(&msg, IPPROTO_IP, IP_PKTINFO, sizeof (*ipi),
+                                sizeof (cmsg_buf));
+      if (!ipi)
+        return 0;
+
+      ipi->ipi_spec_dst.s_addr = htonl(message->local_addr.ip.addr.in4);
+      if (message->if_index != INVALID_IF_INDEX)
+        ipi->ipi_ifindex = message->if_index;
+
+#elif defined(IP_SENDSRCADDR)
+      struct in_addr *addr;
+
+      addr = add_control_message(&msg, IPPROTO_IP, IP_SENDSRCADDR, sizeof (*addr),
+                                 sizeof (cmsg_buf));
+      if (!addr)
+        return 0;
+
+      addr->s_addr = htonl(message->local_addr.ip.addr.in4);
+#endif
+    }
+
+#ifdef HAVE_IN6_PKTINFO
+    if (message->local_addr.ip.family == IPADDR_INET6) {
+      struct in6_pktinfo *ipi;
+
+      ipi = add_control_message(&msg, IPPROTO_IPV6, IPV6_PKTINFO, sizeof (*ipi),
+                                sizeof (cmsg_buf));
+      if (!ipi)
+        return 0;
+
+      memcpy(&ipi->ipi6_addr.s6_addr, &message->local_addr.ip.addr.in6,
+             sizeof(ipi->ipi6_addr.s6_addr));
+      if (message->if_index != INVALID_IF_INDEX)
+        ipi->ipi6_ifindex = message->if_index;
+    }
+#endif
+  }
+
+#ifdef HAVE_LINUX_TIMESTAMPING
+  if (message->timestamp.tx_flags) {
+    int *ts_tx_flags;
+
+    /* Set timestamping flags for this message */
+
+    ts_tx_flags = add_control_message(&msg, SOL_SOCKET, SO_TIMESTAMPING,
+                                      sizeof (*ts_tx_flags), sizeof (cmsg_buf));
+    if (!ts_tx_flags)
+      return 0;
+
+    *ts_tx_flags = message->timestamp.tx_flags;
+  }
+#endif
+
+  if (flags & SCK_FLAG_MSG_DESCRIPTOR) {
+    int *fd;
+
+    fd = add_control_message(&msg, SOL_SOCKET, SCM_RIGHTS, sizeof (*fd), sizeof (cmsg_buf));
+    if (!fd)
+      return 0;
+
+    *fd = message->descriptor;
+  }
+
+  /* This is apparently required on some systems */
+  if (msg.msg_controllen == 0)
+    msg.msg_control = NULL;
+
+  if (sendmsg(sock_fd, &msg, 0) < 0) {
+    log_message(sock_fd, -1, message, "Could not send", strerror(errno));
+    return 0;
+  }
+
+  log_message(sock_fd, -1, message, "Sent", NULL);
+
+  return 1;
+}
+
+/* ================================================== */
+
+void
+SCK_PreInitialise(void)
+{
+#ifdef LINUX
+  char *s, *ptr;
+
+  /* On Linux systems, the systemd service manager may pass file descriptors
+     for pre-initialised sockets to the chronyd daemon.  The service manager
+     allocates and binds the file descriptors, and passes a copy to each
+     spawned instance of the service.  This allows for zero-downtime service
+     restarts as the sockets buffer client requests until the service is able
+     to handle them.  The service manager sets the LISTEN_FDS environment
+     variable to the number of passed file descriptors, and the integer file
+     descriptors start at 3 (see SD_LISTEN_FDS_START in
+     https://www.freedesktop.org/software/systemd/man/latest/sd_listen_fds.html). */
+  first_reusable_fd = 3;
+  reusable_fds = 0;
+
+  s = getenv("LISTEN_FDS");
+  if (s) {
+    errno = 0;
+    reusable_fds = strtol(s, &ptr, 10);
+    if (errno != 0 || *ptr != '\0' || reusable_fds < 0)
+      reusable_fds = 0;
+  }
+#else
+  first_reusable_fd = 0;
+  reusable_fds = 0;
+#endif
+}
+
+/* ================================================== */
+
+void
+SCK_Initialise(int family)
+{
+  int fd;
+
+  ip4_enabled = family == IPADDR_INET4 || family == IPADDR_UNSPEC;
+#ifdef FEAT_IPV6
+  ip6_enabled = family == IPADDR_INET6 || family == IPADDR_UNSPEC;
+#else
+  ip6_enabled = 0;
+#endif
+
+  recv_messages = ARR_CreateInstance(sizeof (struct Message));
+  ARR_SetSize(recv_messages, MAX_RECV_MESSAGES);
+  recv_headers = ARR_CreateInstance(sizeof (struct MessageHeader));
+  ARR_SetSize(recv_headers, MAX_RECV_MESSAGES);
+  recv_sck_messages = ARR_CreateInstance(sizeof (SCK_Message));
+  ARR_SetSize(recv_sck_messages, MAX_RECV_MESSAGES);
+
+  received_messages = MAX_RECV_MESSAGES;
+
+  priv_bind_function = NULL;
+
+  supported_socket_flags = 0;
+#ifdef SOCK_CLOEXEC
+  if (check_socket_flag(SOCK_CLOEXEC, FD_CLOEXEC, 0))
+    supported_socket_flags |= SOCK_CLOEXEC;
+#endif
+#ifdef SOCK_NONBLOCK
+  if (check_socket_flag(SOCK_NONBLOCK, 0, O_NONBLOCK))
+    supported_socket_flags |= SOCK_NONBLOCK;
+#endif
+
+  for (fd = first_reusable_fd; fd < first_reusable_fd + reusable_fds; fd++)
+    UTI_FdSetCloexec(fd);
+
+  initialised = 1;
+}
+
+/* ================================================== */
+
+void
+SCK_Finalise(void)
+{
+  ARR_DestroyInstance(recv_sck_messages);
+  ARR_DestroyInstance(recv_headers);
+  ARR_DestroyInstance(recv_messages);
+
+  SCK_CloseReusableSockets();
+
+  initialised = 0;
+}
+
+/* ================================================== */
+
+int
+SCK_IsIpFamilyEnabled(int family)
+{
+  switch (family) {
+    case IPADDR_INET4:
+      return ip4_enabled;
+    case IPADDR_INET6:
+      return ip6_enabled;
+    default:
+      return 0;
+  }
+}
+
+/* ================================================== */
+
+void
+SCK_GetAnyLocalIPAddress(int family, IPAddr *local_addr)
+{
+  local_addr->family = family;
+
+  switch (family) {
+    case IPADDR_INET4:
+      local_addr->addr.in4 = INADDR_ANY;
+      break;
+    case IPADDR_INET6:
+#ifdef FEAT_IPV6
+      memcpy(&local_addr->addr.in6, &in6addr_any, sizeof (local_addr->addr.in6));
+#else
+      memset(&local_addr->addr.in6, 0, sizeof (local_addr->addr.in6));
+#endif
+      break;
+  }
+}
+
+/* ================================================== */
+
+void
+SCK_GetLoopbackIPAddress(int family, IPAddr *local_addr)
+{
+  local_addr->family = family;
+
+  switch (family) {
+    case IPADDR_INET4:
+      local_addr->addr.in4 = INADDR_LOOPBACK;
+      break;
+    case IPADDR_INET6:
+#ifdef FEAT_IPV6
+      memcpy(&local_addr->addr.in6, &in6addr_loopback, sizeof (local_addr->addr.in6));
+#else
+      memset(&local_addr->addr.in6, 0, sizeof (local_addr->addr.in6));
+      local_addr->addr.in6[15] = 1;
+#endif
+      break;
+  }
+}
+
+/* ================================================== */
+
+int
+SCK_IsLinkLocalIPAddress(IPAddr *addr)
+{
+  switch (addr->family) {
+    case IPADDR_INET4:
+      /* 169.254.0.0/16 */
+      return (addr->addr.in4 & 0xffff0000) == 0xa9fe0000;
+    case IPADDR_INET6:
+      /* fe80::/10 */
+      return addr->addr.in6[0] == 0xfe && (addr->addr.in6[1] & 0xc0) == 0x80;
+    default:
+      return 0;
+  }
+}
+
+/* ================================================== */
+
+void
+SCK_SetPrivBind(int (*function)(int sock_fd, struct sockaddr *address,
+                                socklen_t address_len))
+{
+  priv_bind_function = function;
+}
+
+/* ================================================== */
+
+int
+SCK_OpenUdpSocket(IPSockAddr *remote_addr, IPSockAddr *local_addr, const char *iface, int flags)
+{
+  return open_ip_socket(remote_addr, local_addr, iface, SOCK_DGRAM, flags);
+}
+
+/* ================================================== */
+
+int
+SCK_OpenTcpSocket(IPSockAddr *remote_addr, IPSockAddr *local_addr, const char *iface, int flags)
+{
+  return open_ip_socket(remote_addr, local_addr, iface, SOCK_STREAM, flags);
+}
+
+/* ================================================== */
+
+int
+SCK_OpenUnixDatagramSocket(const char *remote_addr, const char *local_addr, int flags)
+{
+  return open_unix_socket(remote_addr, local_addr, SOCK_DGRAM, flags);
+}
+
+/* ================================================== */
+
+int
+SCK_OpenUnixStreamSocket(const char *remote_addr, const char *local_addr, int flags)
+{
+  return open_unix_socket(remote_addr, local_addr, SOCK_STREAM, flags);
+}
+
+/* ================================================== */
+
+int
+SCK_OpenUnixSocketPair(int flags, int *other_fd)
+{
+  int sock_fd;
+
+  /* Prefer SEQPACKET sockets over DGRAM in order to receive a zero-length
+     message (end of file) when the other end is unexpectedly closed */
+  if (
+#ifdef SOCK_SEQPACKET
+      (sock_fd = open_unix_socket_pair(SOCK_SEQPACKET, flags, other_fd)) < 0 &&
+#endif
+      (sock_fd = open_unix_socket_pair(SOCK_DGRAM, flags, other_fd)) < 0)
+    return INVALID_SOCK_FD;
+
+  return sock_fd;
+}
+
+/* ================================================== */
+
+int
+SCK_IsReusable(int fd)
+{
+  return fd >= first_reusable_fd && fd < first_reusable_fd + reusable_fds;
+}
+
+/* ================================================== */
+
+void
+SCK_CloseReusableSockets(void)
+{
+  int fd;
+
+  for (fd = first_reusable_fd; fd < first_reusable_fd + reusable_fds; fd++)
+    close(fd);
+  reusable_fds = 0;
+  first_reusable_fd = 0;
+}
+
+/* ================================================== */
+
+int
+SCK_SetIntOption(int sock_fd, int level, int name, int value)
+{
+  if (setsockopt(sock_fd, level, name, &value, sizeof (value)) < 0) {
+    DEBUG_LOG("setsockopt() failed fd=%d level=%d name=%d value=%d : %s",
+              sock_fd, level, name, value, strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+int
+SCK_GetIntOption(int sock_fd, int level, int name, int *value)
+{
+  socklen_t len = sizeof (*value);
+
+  if (getsockopt(sock_fd, level, name, value, &len) < 0) {
+    DEBUG_LOG("getsockopt() failed fd=%d level=%d name=%d : %s",
+              sock_fd, level, name, strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+int
+SCK_EnableKernelRxTimestamping(int sock_fd)
+{
+#ifdef SO_TIMESTAMPNS
+  if (SCK_SetIntOption(sock_fd, SOL_SOCKET, SO_TIMESTAMPNS, 1))
+    return 1;
+#endif
+#ifdef SO_TIMESTAMP
+  if (SCK_SetIntOption(sock_fd, SOL_SOCKET, SO_TIMESTAMP, 1)) {
+#if defined(SO_TS_CLOCK) && defined(SO_TS_REALTIME)
+    /* We don't care about the return value - we'll get either a
+       SCM_REALTIME (if we succeded) or a SCM_TIMESTAMP (if we failed) */
+    if (!SCK_SetIntOption(sock_fd, SOL_SOCKET, SO_TS_CLOCK, SO_TS_REALTIME))
+      ;
+#endif
+    return 1;
+  }
+#endif
+
+  return 0;
+}
+
+/* ================================================== */
+
+int
+SCK_ListenOnSocket(int sock_fd, int backlog)
+{
+  if (!SCK_IsReusable(sock_fd) && listen(sock_fd, backlog) < 0) {
+    DEBUG_LOG("listen() failed : %s", strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+int
+SCK_AcceptConnection(int sock_fd, IPSockAddr *remote_addr)
+{
+  union sockaddr_all saddr;
+  socklen_t saddr_len = sizeof (saddr);
+  int conn_fd;
+
+  conn_fd = accept(sock_fd, &saddr.sa, &saddr_len);
+  if (conn_fd < 0) {
+    DEBUG_LOG("accept() failed : %s", strerror(errno));
+    return INVALID_SOCK_FD;
+  }
+
+  if (!UTI_FdSetCloexec(conn_fd) || !set_socket_nonblock(conn_fd)) {
+    close(conn_fd);
+    return INVALID_SOCK_FD;
+  }
+
+  SCK_SockaddrToIPSockAddr(&saddr.sa, saddr_len, remote_addr);
+
+  return conn_fd;
+}
+
+/* ================================================== */
+
+int
+SCK_ShutdownConnection(int sock_fd)
+{
+  if (shutdown(sock_fd, SHUT_RDWR) < 0) {
+    DEBUG_LOG("shutdown() failed : %s", strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+int
+SCK_Receive(int sock_fd, void *buffer, int length, int flags)
+{
+  int r;
+
+  if (length < 0) {
+    DEBUG_LOG("Invalid length %d", length);
+    return -1;
+  }
+
+  r = recv(sock_fd, buffer, length, get_recv_flags(flags));
+
+  if (r < 0) {
+    handle_recv_error(sock_fd, flags);
+    return r;
+  }
+
+  DEBUG_LOG("Received data fd=%d len=%d", sock_fd, r);
+
+  return r;
+}
+
+/* ================================================== */
+
+int
+SCK_Send(int sock_fd, const void *buffer, int length, int flags)
+{
+  int r;
+
+  assert(flags == 0);
+
+  if (length < 0) {
+    DEBUG_LOG("Invalid length %d", length);
+    return -1;
+  }
+
+  r = send(sock_fd, buffer, length, 0);
+
+  if (r < 0) {
+    DEBUG_LOG("Could not send data fd=%d len=%d : %s", sock_fd, length, strerror(errno));
+    return r;
+  }
+
+  DEBUG_LOG("Sent data fd=%d len=%d", sock_fd, r);
+
+  return r;
+}
+
+/* ================================================== */
+
+SCK_Message *
+SCK_ReceiveMessage(int sock_fd, int flags)
+{
+  int num_messages;
+
+  return receive_messages(sock_fd, flags, 1, &num_messages);
+}
+
+/* ================================================== */
+
+SCK_Message *
+SCK_ReceiveMessages(int sock_fd, int flags, int *num_messages)
+{
+  return receive_messages(sock_fd, flags, MAX_RECV_MESSAGES, num_messages);
+}
+
+/* ================================================== */
+
+void
+SCK_InitMessage(SCK_Message *message, SCK_AddressType addr_type)
+{
+  init_message_addresses(message, addr_type);
+  init_message_nonaddress(message);
+}
+
+/* ================================================== */
+
+int
+SCK_SendMessage(int sock_fd, SCK_Message *message, int flags)
+{
+  return send_message(sock_fd, message, flags);
+}
+
+/* ================================================== */
+
+int
+SCK_RemoveSocket(int sock_fd)
+{
+  union sockaddr_all saddr;
+  socklen_t saddr_len;
+
+  saddr_len = sizeof (saddr);
+
+  if (getsockname(sock_fd, &saddr.sa, &saddr_len) < 0) {
+    DEBUG_LOG("getsockname() failed : %s", strerror(errno));
+    return 0;
+  }
+
+  if (saddr_len > sizeof (saddr) || saddr_len <= sizeof (saddr.sa.sa_family) ||
+      saddr.sa.sa_family != AF_UNIX)
+    return 0;
+
+  if (unlink(saddr.un.sun_path) < 0) {
+    DEBUG_LOG("Could not remove %s : %s", saddr.un.sun_path, strerror(errno));
+    return 0;
+  }
+
+  return 1;
+}
+
+/* ================================================== */
+
+void
+SCK_CloseSocket(int sock_fd)
+{
+  /* Reusable sockets are closed in finalisation */
+  if (SCK_IsReusable(sock_fd))
+    return;
+
+  close(sock_fd);
+}
+
+/* ================================================== */
+
+void
+SCK_SockaddrToIPSockAddr(struct sockaddr *sa, int sa_length, IPSockAddr *ip_sa)
+{
+  ip_sa->ip_addr.family = IPADDR_UNSPEC;
+  ip_sa->port = 0;
+
+  switch (sa->sa_family) {
+    case AF_INET:
+      if (sa_length < (int)sizeof (struct sockaddr_in))
+        return;
+      ip_sa->ip_addr.family = IPADDR_INET4;
+      ip_sa->ip_addr.addr.in4 = ntohl(((struct sockaddr_in *)sa)->sin_addr.s_addr);
+      ip_sa->port = ntohs(((struct sockaddr_in *)sa)->sin_port);
+      break;
+#ifdef FEAT_IPV6
+    case AF_INET6:
+      if (sa_length < (int)sizeof (struct sockaddr_in6))
+        return;
+      ip_sa->ip_addr.family = IPADDR_INET6;
+      memcpy(&ip_sa->ip_addr.addr.in6, ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr,
+             sizeof (ip_sa->ip_addr.addr.in6));
+      ip_sa->port = ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
+      break;
+#endif
+    default:
+      break;
+  }
+}
+
+/* ================================================== */
+
+int
+SCK_IPSockAddrToSockaddr(IPSockAddr *ip_sa, struct sockaddr *sa, int sa_length)
+{
+  switch (ip_sa->ip_addr.family) {
+    case IPADDR_INET4:
+      if (sa_length < (int)sizeof (struct sockaddr_in))
+        return 0;
+      memset(sa, 0, sizeof (struct sockaddr_in));
+      sa->sa_family = AF_INET;
+      ((struct sockaddr_in *)sa)->sin_addr.s_addr = htonl(ip_sa->ip_addr.addr.in4);
+      ((struct sockaddr_in *)sa)->sin_port = htons(ip_sa->port);
+#ifdef SIN6_LEN
+      ((struct sockaddr_in *)sa)->sin_len = sizeof (struct sockaddr_in);
+#endif
+      return sizeof (struct sockaddr_in);
+#ifdef FEAT_IPV6
+    case IPADDR_INET6:
+      if (sa_length < (int)sizeof (struct sockaddr_in6))
+        return 0;
+      memset(sa, 0, sizeof (struct sockaddr_in6));
+      sa->sa_family = AF_INET6;
+      memcpy(&((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr, ip_sa->ip_addr.addr.in6,
+             sizeof (((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr));
+      ((struct sockaddr_in6 *)sa)->sin6_port = htons(ip_sa->port);
+#ifdef SIN6_LEN
+      ((struct sockaddr_in6 *)sa)->sin6_len = sizeof (struct sockaddr_in6);
+#endif
+      return sizeof (struct sockaddr_in6);
+#endif
+    default:
+      if (sa_length < (int)sizeof (struct sockaddr))
+        return 0;
+      memset(sa, 0, sizeof (struct sockaddr));
+      sa->sa_family = AF_UNSPEC;
+      return 0;
+  }
+}