Fri Apr 17 21:38:36 UTC 202020200417213836

a/kernel-firmware-20200417_6314fa0-noarch-1.txz:  Upgraded.
a/kernel-generic-5.4.33-x86_64-1.txz:  Upgraded.
a/kernel-huge-5.4.33-x86_64-1.txz:  Upgraded.
a/kernel-modules-5.4.33-x86_64-1.txz:  Upgraded.
d/kernel-headers-5.4.33-x86-1.txz:  Upgraded.
k/kernel-source-5.4.33-noarch-1.txz:  Upgraded.
l/adwaita-icon-theme-3.36.1-noarch-1.txz:  Upgraded.
l/libuv-1.36.0-x86_64-2.txz:  Rebuilt.
  Revert commits that cause BIND to crash. Thanks to Markus Wiesner.
l/wavpack-5.3.0-x86_64-1.txz:  Upgraded.
isolinux/initrd.img:  Rebuilt.
kernels/*:  Upgraded.
usb-and-pxe-installers/usbboot.img:  Rebuilt.

2 files changed, 488 insertions, 1 deletions

diff --git a/source/l/libuv/libuv.977be04762b9bda29a88d39bb3e2cb7c44b2ad22.patch b/source/l/libuv/libuv.977be04762b9bda29a88d39bb3e2cb7c44b2ad22.patch
new file mode 100644
index 00000000..f0dae9cb
--- /dev/null
+++ b/source/l/libuv/libuv.977be04762b9bda29a88d39bb3e2cb7c44b2ad22.patch
@@ -0,0 +1,484 @@
+From 977be04762b9bda29a88d39bb3e2cb7c44b2ad22 Mon Sep 17 00:00:00 2001
+From: Ben Noordhuis <info@bnoordhuis.nl>
+Date: Thu, 16 Apr 2020 09:59:03 +0200
+Subject: [PATCH] Revert "freebsd,linux: add recvmmsg() + sendmmsg() udp
+ implementation"
+
+This reverts commit 3d7136639a39db46bc4a9074922559a564e49514.
+This reverts commit d9cd7d437d6bcea56355b6e0ef215aa64687d7a1.
+
+The first reverted commit is the sendmmsg/recvmmsg support, the second
+one a fix-up to deliver datagrams in order. The second commit has been
+implicated in causing bind9 to crash on freebsd.
+
+A quick review of the code suggests that downstream code written against
+pre-v1.35.0 libuv can't safely deal with multi-datagram support because
+they are unaware of the `UV_UDP_MMSG_CHUNK` flag and what that implies
+for buffer management, hence I'm moving to revert it.
+
+The `UV_UDP_MMSG_CHUNK` flag remains part of `uv_udp_flags` for
+API/ABI backwards compatibility reasons but it is no longer used.
+
+Fixes: https://github.com/libuv/libuv/issues/2791
+Refs: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=245653
+---
+ docs/src/udp.rst          |  18 +---
+ include/uv.h              |   5 +-
+ src/unix/freebsd.c        |  25 -----
+ src/unix/internal.h       |  24 -----
+ src/unix/linux-syscalls.c |   1 -
+ src/unix/linux-syscalls.h |  14 +++
+ src/unix/udp.c            | 207 +-------------------------------------
+ 7 files changed, 22 insertions(+), 272 deletions(-)
+
+diff --git a/docs/src/udp.rst b/docs/src/udp.rst
+index 786a28b030..53b1fea493 100644
+--- a/docs/src/udp.rst
++++ b/docs/src/udp.rst
+@@ -42,11 +42,6 @@ Data types
+             * any traffic, in effect "stealing" the port from the previous listener.
+             */
+             UV_UDP_REUSEADDR = 4
+-            /*
+-             * Indicates that the message was received by recvmmsg, so the buffer provided
+-             * must not be freed by the recv_cb callback.
+-             */
+-            UV_UDP_MMSG_CHUNK = 8
+         };
+ 
+ .. c:type:: void (*uv_udp_send_cb)(uv_udp_send_t* req, int status)
+@@ -67,18 +62,13 @@ Data types
+     * `buf`: :c:type:`uv_buf_t` with the received data.
+     * `addr`: ``struct sockaddr*`` containing the address of the sender.
+       Can be NULL. Valid for the duration of the callback only.
+-    * `flags`: One or more or'ed UV_UDP_* constants.
++    * `flags`: One or more or'ed UV_UDP_* constants. Right now only
++      ``UV_UDP_PARTIAL`` is used.
+ 
+     The callee is responsible for freeing the buffer, libuv does not reuse it.
+     The buffer may be a null buffer (where `buf->base` == NULL and `buf->len` == 0)
+     on error.
+ 
+-    When using :man:`recvmmsg(2)`, chunks will have the `UV_UDP_MMSG_CHUNK` flag set,
+-    those must not be freed. There will be a final callback with `nread` set to 0,
+-    `addr` set to NULL and the buffer pointing at the initially allocated data with
+-    the `UV_UDP_MMSG_CHUNK` flag cleared. This is a good chance for the callee to
+-    free the provided buffer.
+-
+     .. note::
+         The receive callback will be called with `nread` == 0 and `addr` == NULL when there is
+         nothing to read, and with `nread` == 0 and `addr` != NULL when an empty UDP packet is
+@@ -376,10 +366,6 @@ API
+ 
+     :returns: 0 on success, or an error code < 0 on failure.
+ 
+-    .. versionchanged:: 1.35.0 added support for :man:`recvmmsg(2)` on supported platforms).
+-                        The use of this feature requires a buffer larger than
+-                        2 * 64KB to be passed to `alloc_cb`.
+-
+ .. c:function:: int uv_udp_recv_stop(uv_udp_t* handle)
+ 
+     Stop listening for incoming datagrams.
+diff --git a/include/uv.h b/include/uv.h
+index 2e8072fdae..dd8c8a40b0 100644
+--- a/include/uv.h
++++ b/include/uv.h
+@@ -1,4 +1,4 @@
+-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
++/* COPYRIGHT JOYENT, INC. AND OTHER NODE CONTRIBUTORS. ALL RIGHTS RESERVED.
+  *
+  * Permission is hereby granted, free of charge, to any person obtaining a copy
+  * of this software and associated documentation files (the "Software"), to
+@@ -607,8 +607,7 @@ enum uv_udp_flags {
+    */
+   UV_UDP_REUSEADDR = 4,
+   /*
+-   * Indicates that the message was received by recvmmsg, so the buffer provided
+-   * must not be freed by the recv_cb callback.
++   * Unused. Here for API/ABI compatibility.
+    */
+   UV_UDP_MMSG_CHUNK = 8
+ };
+diff --git a/src/unix/freebsd.c b/src/unix/freebsd.c
+index ef77e127c2..57bd04e240 100644
+--- a/src/unix/freebsd.c
++++ b/src/unix/freebsd.c
+@@ -288,28 +288,3 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
+   uv__free(cp_times);
+   return 0;
+ }
+-
+-
+-int uv__sendmmsg(int fd,
+-                 struct uv__mmsghdr* mmsg,
+-                 unsigned int vlen,
+-                 unsigned int flags) {
+-#if __FreeBSD__ >= 11
+-  return sendmmsg(fd, mmsg, vlen, flags);
+-#else
+-  return errno = ENOSYS, -1;
+-#endif
+-}
+-
+-
+-int uv__recvmmsg(int fd,
+-                 struct uv__mmsghdr* mmsg,
+-                 unsigned int vlen,
+-                 unsigned int flags,
+-                 struct timespec* timeout) {
+-#if __FreeBSD__ >= 11
+-  return recvmmsg(fd, mmsg, vlen, flags, timeout);
+-#else
+-  return errno = ENOSYS, -1;
+-#endif
+-}
+diff --git a/src/unix/internal.h b/src/unix/internal.h
+index 598554b607..469fd7d2b8 100644
+--- a/src/unix/internal.h
++++ b/src/unix/internal.h
+@@ -31,7 +31,6 @@
+ #include <fcntl.h>  /* O_CLOEXEC and O_NONBLOCK, if supported. */
+ #include <stdio.h>
+ #include <errno.h>
+-#include <sys/socket.h>
+ 
+ #if defined(__STRICT_ANSI__)
+ # define inline __inline
+@@ -328,27 +327,4 @@ int uv__getsockpeername(const uv_handle_t* handle,
+                         struct sockaddr* name,
+                         int* namelen);
+ 
+-#if defined(__linux__)            ||                                      \
+-    defined(__FreeBSD__)          ||                                      \
+-    defined(__FreeBSD_kernel__)
+-#define HAVE_MMSG 1
+-struct uv__mmsghdr {
+-  struct msghdr msg_hdr;
+-  unsigned int msg_len;
+-};
+-
+-int uv__recvmmsg(int fd,
+-                 struct uv__mmsghdr* mmsg,
+-                 unsigned int vlen,
+-                 unsigned int flags,
+-                 struct timespec* timeout);
+-int uv__sendmmsg(int fd,
+-                 struct uv__mmsghdr* mmsg,
+-                 unsigned int vlen,
+-                 unsigned int flags);
+-#else
+-#define HAVE_MMSG 0
+-#endif
+-
+-
+ #endif /* UV_UNIX_INTERNAL_H_ */
+diff --git a/src/unix/linux-syscalls.c b/src/unix/linux-syscalls.c
+index 742f26ada8..eb5a8fd274 100644
+--- a/src/unix/linux-syscalls.c
++++ b/src/unix/linux-syscalls.c
+@@ -126,7 +126,6 @@
+ # endif
+ #endif /* __NR_getrandom */
+ 
+-struct uv__mmsghdr;
+ 
+ int uv__sendmmsg(int fd,
+                  struct uv__mmsghdr* mmsg,
+diff --git a/src/unix/linux-syscalls.h b/src/unix/linux-syscalls.h
+index 2e8fa2a519..7ee1511a45 100644
+--- a/src/unix/linux-syscalls.h
++++ b/src/unix/linux-syscalls.h
+@@ -61,6 +61,20 @@ struct uv__statx {
+   uint64_t unused1[14];
+ };
+ 
++struct uv__mmsghdr {
++  struct msghdr msg_hdr;
++  unsigned int msg_len;
++};
++
++int uv__recvmmsg(int fd,
++                 struct uv__mmsghdr* mmsg,
++                 unsigned int vlen,
++                 unsigned int flags,
++                 struct timespec* timeout);
++int uv__sendmmsg(int fd,
++                 struct uv__mmsghdr* mmsg,
++                 unsigned int vlen,
++                 unsigned int flags);
+ ssize_t uv__preadv(int fd, const struct iovec *iov, int iovcnt, int64_t offset);
+ ssize_t uv__pwritev(int fd, const struct iovec *iov, int iovcnt, int64_t offset);
+ int uv__dup3(int oldfd, int newfd, int flags);
+diff --git a/src/unix/udp.c b/src/unix/udp.c
+index f2fcae1760..982059ff48 100644
+--- a/src/unix/udp.c
++++ b/src/unix/udp.c
+@@ -32,8 +32,6 @@
+ #endif
+ #include <sys/un.h>
+ 
+-#define UV__UDP_DGRAM_MAXSIZE (64 * 1024)
+-
+ #if defined(IPV6_JOIN_GROUP) && !defined(IPV6_ADD_MEMBERSHIP)
+ # define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
+ #endif
+@@ -51,36 +49,6 @@ static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
+                                        int domain,
+                                        unsigned int flags);
+ 
+-#if HAVE_MMSG
+-
+-#define UV__MMSG_MAXWIDTH 20
+-
+-static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf);
+-static void uv__udp_sendmmsg(uv_udp_t* handle);
+-
+-static int uv__recvmmsg_avail;
+-static int uv__sendmmsg_avail;
+-static uv_once_t once = UV_ONCE_INIT;
+-
+-static void uv__udp_mmsg_init(void) {
+-  int ret;
+-  int s;
+-  s = uv__socket(AF_INET, SOCK_DGRAM, 0);
+-  if (s < 0)
+-    return;
+-  ret = uv__sendmmsg(s, NULL, 0, 0);
+-  if (ret == 0 || errno != ENOSYS) {
+-    uv__sendmmsg_avail = 1;
+-    uv__recvmmsg_avail = 1;
+-  } else {
+-    ret = uv__recvmmsg(s, NULL, 0, 0, NULL);
+-    if (ret == 0 || errno != ENOSYS)
+-      uv__recvmmsg_avail = 1;
+-  }
+-  uv__close(s);
+-}
+-
+-#endif
+ 
+ void uv__udp_close(uv_udp_t* handle) {
+   uv__io_close(handle->loop, &handle->io_watcher);
+@@ -180,61 +148,6 @@ static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents) {
+   }
+ }
+ 
+-#if HAVE_MMSG
+-static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf) {
+-  struct sockaddr_in6 peers[UV__MMSG_MAXWIDTH];
+-  struct iovec iov[UV__MMSG_MAXWIDTH];
+-  struct uv__mmsghdr msgs[UV__MMSG_MAXWIDTH];
+-  ssize_t nread;
+-  uv_buf_t chunk_buf;
+-  size_t chunks;
+-  int flags;
+-  size_t k;
+-
+-  /* prepare structures for recvmmsg */
+-  chunks = buf->len / UV__UDP_DGRAM_MAXSIZE;
+-  if (chunks > ARRAY_SIZE(iov))
+-    chunks = ARRAY_SIZE(iov);
+-  for (k = 0; k < chunks; ++k) {
+-    iov[k].iov_base = buf->base + k * UV__UDP_DGRAM_MAXSIZE;
+-    iov[k].iov_len = UV__UDP_DGRAM_MAXSIZE;
+-    msgs[k].msg_hdr.msg_iov = iov + k;
+-    msgs[k].msg_hdr.msg_iovlen = 1;
+-    msgs[k].msg_hdr.msg_name = peers + k;
+-    msgs[k].msg_hdr.msg_namelen = sizeof(peers[0]);
+-  }
+-
+-  do
+-    nread = uv__recvmmsg(handle->io_watcher.fd, msgs, chunks, 0, NULL);
+-  while (nread == -1 && errno == EINTR);
+-
+-  if (nread < 1) {
+-    if (nread == 0 || errno == EAGAIN || errno == EWOULDBLOCK)
+-      handle->recv_cb(handle, 0, buf, NULL, 0);
+-    else
+-      handle->recv_cb(handle, UV__ERR(errno), buf, NULL, 0);
+-  } else {
+-    /* pass each chunk to the application */
+-    for (k = 0; k < (size_t) nread && handle->recv_cb != NULL; k++) {
+-      flags = UV_UDP_MMSG_CHUNK;
+-      if (msgs[k].msg_hdr.msg_flags & MSG_TRUNC)
+-        flags |= UV_UDP_PARTIAL;
+-
+-      chunk_buf = uv_buf_init(iov[k].iov_base, iov[k].iov_len);
+-      handle->recv_cb(handle,
+-                      msgs[k].msg_len,
+-                      &chunk_buf,
+-                      msgs[k].msg_hdr.msg_name,
+-                      flags);
+-    }
+-
+-    /* one last callback so the original buffer is freed */
+-    if (handle->recv_cb != NULL)
+-      handle->recv_cb(handle, 0, buf, NULL, 0);
+-  }
+-  return nread;
+-}
+-#endif
+ 
+ static void uv__udp_recvmsg(uv_udp_t* handle) {
+   struct sockaddr_storage peer;
+@@ -254,27 +167,13 @@ static void uv__udp_recvmsg(uv_udp_t* handle) {
+ 
+   do {
+     buf = uv_buf_init(NULL, 0);
+-    handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &buf);
++    handle->alloc_cb((uv_handle_t*) handle, 64 * 1024, &buf);
+     if (buf.base == NULL || buf.len == 0) {
+       handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
+       return;
+     }
+     assert(buf.base != NULL);
+ 
+-#if HAVE_MMSG
+-    uv_once(&once, uv__udp_mmsg_init);
+-    if (uv__recvmmsg_avail) {
+-      /* Returned space for more than 1 datagram, use it to receive
+-       * multiple datagrams. */
+-      if (buf.len >= 2 * UV__UDP_DGRAM_MAXSIZE) {
+-        nread = uv__udp_recvmmsg(handle, &buf);
+-        if (nread > 0)
+-          count -= nread;
+-        continue;
+-      }
+-    }
+-#endif
+-
+     memset(&h, 0, sizeof(h));
+     memset(&peer, 0, sizeof(peer));
+     h.msg_name = &peer;
+@@ -300,120 +199,21 @@ static void uv__udp_recvmsg(uv_udp_t* handle) {
+ 
+       handle->recv_cb(handle, nread, &buf, (const struct sockaddr*) &peer, flags);
+     }
+-    count--;
+   }
+   /* recv_cb callback may decide to pause or close the handle */
+   while (nread != -1
+-      && count > 0
++      && count-- > 0
+       && handle->io_watcher.fd != -1
+       && handle->recv_cb != NULL);
+ }
+ 
+-#if HAVE_MMSG
+-static void uv__udp_sendmmsg(uv_udp_t* handle) {
+-  uv_udp_send_t* req;
+-  struct uv__mmsghdr h[UV__MMSG_MAXWIDTH];
+-  struct uv__mmsghdr *p;
+-  QUEUE* q;
+-  ssize_t npkts;
+-  size_t pkts;
+-  size_t i;
+-
+-  if (QUEUE_EMPTY(&handle->write_queue))
+-    return;
+-
+-write_queue_drain:
+-  for (pkts = 0, q = QUEUE_HEAD(&handle->write_queue);
+-       pkts < UV__MMSG_MAXWIDTH && q != &handle->write_queue;
+-       ++pkts, q = QUEUE_HEAD(q)) {
+-    assert(q != NULL);
+-    req = QUEUE_DATA(q, uv_udp_send_t, queue);
+-    assert(req != NULL);
+-
+-    p = &h[pkts];
+-    memset(p, 0, sizeof(*p));
+-    if (req->addr.ss_family == AF_UNSPEC) {
+-      p->msg_hdr.msg_name = NULL;
+-      p->msg_hdr.msg_namelen = 0;
+-    } else {
+-      p->msg_hdr.msg_name = &req->addr;
+-      if (req->addr.ss_family == AF_INET6)
+-        p->msg_hdr.msg_namelen = sizeof(struct sockaddr_in6);
+-      else if (req->addr.ss_family == AF_INET)
+-        p->msg_hdr.msg_namelen = sizeof(struct sockaddr_in);
+-      else if (req->addr.ss_family == AF_UNIX)
+-        p->msg_hdr.msg_namelen = sizeof(struct sockaddr_un);
+-      else {
+-        assert(0 && "unsupported address family");
+-        abort();
+-      }
+-    }
+-    h[pkts].msg_hdr.msg_iov = (struct iovec*) req->bufs;
+-    h[pkts].msg_hdr.msg_iovlen = req->nbufs;
+-  }
+-
+-  do
+-    npkts = uv__sendmmsg(handle->io_watcher.fd, h, pkts, 0);
+-  while (npkts == -1 && errno == EINTR);
+-
+-  if (npkts < 1) {
+-    if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS)
+-      return;
+-    for (i = 0, q = QUEUE_HEAD(&handle->write_queue);
+-         i < pkts && q != &handle->write_queue;
+-         ++i, q = QUEUE_HEAD(q)) {
+-      assert(q != NULL);
+-      req = QUEUE_DATA(q, uv_udp_send_t, queue);
+-      assert(req != NULL);
+-
+-      req->status = UV__ERR(errno);
+-      QUEUE_REMOVE(&req->queue);
+-      QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
+-    }
+-    uv__io_feed(handle->loop, &handle->io_watcher);
+-    return;
+-  }
+-
+-  for (i = 0, q = QUEUE_HEAD(&handle->write_queue);
+-       i < pkts && q != &handle->write_queue;
+-       ++i, q = QUEUE_HEAD(&handle->write_queue)) {
+-    assert(q != NULL);
+-    req = QUEUE_DATA(q, uv_udp_send_t, queue);
+-    assert(req != NULL);
+-
+-    req->status = req->bufs[0].len;
+-
+-    /* Sending a datagram is an atomic operation: either all data
+-     * is written or nothing is (and EMSGSIZE is raised). That is
+-     * why we don't handle partial writes. Just pop the request
+-     * off the write queue and onto the completed queue, done.
+-     */
+-    QUEUE_REMOVE(&req->queue);
+-    QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
+-  }
+-
+-  /* couldn't batch everything, continue sending (jump to avoid stack growth) */
+-  if (!QUEUE_EMPTY(&handle->write_queue))
+-    goto write_queue_drain;
+-  uv__io_feed(handle->loop, &handle->io_watcher);
+-  return;
+-}
+-#endif
+ 
+ static void uv__udp_sendmsg(uv_udp_t* handle) {
+   uv_udp_send_t* req;
+-  struct msghdr h;
+   QUEUE* q;
++  struct msghdr h;
+   ssize_t size;
+ 
+-#if HAVE_MMSG
+-  uv_once(&once, uv__udp_mmsg_init);
+-  if (uv__sendmmsg_avail) {
+-    uv__udp_sendmmsg(handle);
+-    return;
+-  }
+-#endif
+-
+   while (!QUEUE_EMPTY(&handle->write_queue)) {
+     q = QUEUE_HEAD(&handle->write_queue);
+     assert(q != NULL);
+@@ -463,6 +263,7 @@ static void uv__udp_sendmsg(uv_udp_t* handle) {
+   }
+ }
+ 
++
+ /* On the BSDs, SO_REUSEPORT implies SO_REUSEADDR but with some additional
+  * refinements for programs that use multicast.
+  *
+
diff --git a/source/l/libuv/libuv.SlackBuild b/source/l/libuv/libuv.SlackBuild
index 716c1c92..4e182fa9 100755
--- a/source/l/libuv/libuv.SlackBuild
+++ b/source/l/libuv/libuv.SlackBuild
@@ -24,7 +24,7 @@ cd $(dirname $0) ; CWD=$(pwd)
 
 PKGNAM=libuv
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
-BUILD=${BUILD:-1}
+BUILD=${BUILD:-2}
 
 # Automatically determine the architecture we're building on:
 if [ -z "$ARCH" ]; then
@@ -85,6 +85,9 @@ find . \
   \( -perm 666 -o -perm 664 -o -perm 600 -o -perm 444 -o -perm 440 -o -perm 400 \) \
   -exec chmod 644 {} \+
 
+# Revert commits that cause BIND to crash:
+zcat $CWD/libuv.977be04762b9bda29a88d39bb3e2cb7c44b2ad22.patch.gz | patch -p1 --verbose || exit 1
+
 if [ ! -r configure ]; then
   NOCONFIGURE=1 ./autogen.sh
 fi