Merge branch 'busybox' into merge

12 files changed, 561 insertions, 53 deletions

diff --git a/Config.in b/Config.in
index 6b3d98b37..2da0a6aec 100644
--- a/Config.in
+++ b/Config.in
@@ -122,6 +122,17 @@ config LFS
         programs that can benefit from large file support include dd, gzip,
         cp, mount, tar.
 
+config TIME64
+        bool "Support 64bit wide time types"
+        default y
+        depends on LFS
+        help
+        Make times later than 2038 representable for several libc syscalls
+        (stat, clk_gettime etc.). Note this switch is specific to glibc
+        and has no effect on platforms that already use 64bit wide time types
+        (i.e. all 64bit archs and some selected 32bit archs (currently riscv
+        and x32)).
+
 config PAM
         bool "Support PAM (Pluggable Authentication Modules)"
         default n
diff --git a/Makefile.flags b/Makefile.flags
index aa6565cf7..1a2923854 100644
--- a/Makefile.flags
+++ b/Makefile.flags
@@ -15,6 +15,7 @@ CPPFLAGS += \
         -include include/autoconf.h \
         -D_GNU_SOURCE -DNDEBUG \
         $(if $(CONFIG_LFS),-D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64) \
+        $(if $(CONFIG_TIME64),-D_TIME_BITS=64) \
         -DMINGW_VER=$(squote)$(quote)$(MINGW_VER)$(quote)$(squote) \
         -DBB_VER=$(squote)$(quote)$(BB_VER)$(quote)$(squote)
 
diff --git a/archival/cpio.c b/archival/cpio.c
index 388ba7c4f..167931bdb 100644
--- a/archival/cpio.c
+++ b/archival/cpio.c
@@ -62,7 +62,7 @@
 //usage:       " [-ti"IF_FEATURE_CPIO_O("o")"]" IF_FEATURE_CPIO_P(" [-p DIR]")
 //usage:       " [EXTR_FILE]..."
 //usage:#define cpio_full_usage "\n\n"
-//usage:       "Extract (-i) or list (-t) files from a cpio archive"
+//usage:       "Extract (-i) or list (-t) files from a cpio archive on stdin"
 //usage:        IF_FEATURE_CPIO_O(", or"
 //usage:     "\ntake file list from stdin and create an archive (-o)"
 //usage:                IF_FEATURE_CPIO_P(" or copy files (-p)")
diff --git a/coreutils/factor.c b/coreutils/factor.c
index a7a5a5030..f909a0d96 100644
--- a/coreutils/factor.c
+++ b/coreutils/factor.c
@@ -48,38 +48,40 @@ typedef unsigned long half_t;
  * Larger wheels improve sieving only slightly, but quickly grow in size
  * (adding just one prime, 13, results in 5766 element sieve).
  */
-#define R(a,b,c,d,e,f,g,h,i,j,A,B,C,D,E,F,G,H,I,J) \
-        (((uint64_t)(a<<0) | (b<<3) | (c<<6) | (d<<9) | (e<<12) | (f<<15) | (g<<18) | (h<<21) | (i<<24) | (j<<27)) << 1) | \
-        (((uint64_t)(A<<0) | (B<<3) | (C<<6) | (D<<9) | (E<<12) | (F<<15) | (G<<18) | (H<<21) | (I<<24) | (J<<27)) << 31)
-#define P(a,b,c,d,e,f,g,h,i,j,A,B,C,D,E,F,G,H,I,J) \
+#define R(a,b,c,d,e,f,g,h,i,j,A,B,C,D,E,F,G,H,I,J,x) \
+        (((uint64_t)(a<<0) | (b<<3) | (c<<6) | (d<<9) | (e<<12) | (f<<15) | (g<<18) | (h<<21) | (i<<24) | (j<<27)) << 1)  | \
+        (((uint64_t)(A<<0) | (B<<3) | (C<<6) | (D<<9) | (E<<12) | (F<<15) | (G<<18) | (H<<21) | (I<<24) | (J<<27)) << 31) | \
+        ((uint64_t)x << 61)
+#define P(a,b,c,d,e,f,g,h,i,j,A,B,C,D,E,F,G,H,I,J,x) \
         R(      (a/2),(b/2),(c/2),(d/2),(e/2),(f/2),(g/2),(h/2),(i/2),(j/2), \
-                (A/2),(B/2),(C/2),(D/2),(E/2),(F/2),(G/2),(H/2),(I/2),(J/2)  )
+                (A/2),(B/2),(C/2),(D/2),(E/2),(F/2),(G/2),(H/2),(I/2),(J/2), \
+                (x/2) \
+        )
 static const uint64_t packed_wheel[] = {
-        /*1, 2, 2, 4, 2,*/
-        P( 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4), //01
-        P( 2, 4, 2, 4,14, 4, 6, 2,10, 2, 6, 6, 4, 2, 4, 6, 2,10, 2, 4), //02
-        P( 2,12,10, 2, 4, 2, 4, 6, 2, 6, 4, 6, 6, 6, 2, 6, 4, 2, 6, 4), //03
-        P( 6, 8, 4, 2, 4, 6, 8, 6,10, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2), //04
-        P( 6, 4, 2, 6,10, 2,10, 2, 4, 2, 4, 6, 8, 4, 2, 4,12, 2, 6, 4), //05
-        P( 2, 6, 4, 6,12, 2, 4, 2, 4, 8, 6, 4, 6, 2, 4, 6, 2, 6,10, 2), //06
-        P( 4, 6, 2, 6, 4, 2, 4, 2,10, 2,10, 2, 4, 6, 6, 2, 6, 6, 4, 6), //07
-        P( 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 6, 4, 8, 6, 4, 6, 2, 4, 6), //08
-        P( 8, 6, 4, 2,10, 2, 6, 4, 2, 4, 2,10, 2,10, 2, 4, 2, 4, 8, 6), //09
-        P( 4, 2, 4, 6, 6, 2, 6, 4, 8, 4, 6, 8, 4, 2, 4, 2, 4, 8, 6, 4), //10
-        P( 6, 6, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4, 2,10, 2,10, 2), //11
-        P( 6, 4, 6, 2, 6, 4, 2, 4, 6, 6, 8, 4, 2, 6,10, 8, 4, 2, 4, 2), //12
-        P( 4, 8,10, 6, 2, 4, 8, 6, 6, 4, 2, 4, 6, 2, 6, 4, 6, 2,10, 2), //13
-        P(10, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 6, 6, 4, 6, 8), //14
-        P( 4, 2, 4, 2, 4, 8, 6, 4, 8, 4, 6, 2, 6, 6, 4, 2, 4, 6, 8, 4), //15
-        P( 2, 4, 2,10, 2,10, 2, 4, 2, 4, 6, 2,10, 2, 4, 6, 8, 6, 4, 2), //16
-        P( 6, 4, 6, 8, 4, 6, 2, 4, 8, 6, 4, 6, 2, 4, 6, 2, 6, 6, 4, 6), //17
-        P( 6, 2, 6, 6, 4, 2,10, 2,10, 2, 4, 2, 4, 6, 2, 6, 4, 2,10, 6), //18
-        P( 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2,12, 6, 4, 6, 2, 4, 6, 2), //19
-        P(12, 4, 2, 4, 8, 6, 4, 2, 4, 2,10, 2,10, 6, 2, 4, 6, 2, 6, 4), //20
-        P( 2, 4, 6, 6, 2, 6, 4, 2,10, 6, 8, 6, 4, 2, 4, 8, 6, 4, 6, 2), //21
-        P( 4, 6, 2, 6, 6, 6, 4, 6, 2, 6, 4, 2, 4, 2,10,12, 2, 4, 2,10), //22
-        P( 2, 6, 4, 2, 4, 6, 6, 2,10, 2, 6, 4,14, 4, 2, 4, 2, 4, 8, 6), //23
-        P( 4, 6, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4,12, 2,12), //24
+        /* 1, 2, */
+        P( 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6),
+        P( 8, 4, 2, 4, 2, 4,14, 4, 6, 2,10, 2, 6, 6, 4, 2, 4, 6, 2,10, 2),
+        P( 4, 2,12,10, 2, 4, 2, 4, 6, 2, 6, 4, 6, 6, 6, 2, 6, 4, 2, 6, 4),
+        P( 6, 8, 4, 2, 4, 6, 8, 6,10, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6),
+        P( 4, 2, 6,10, 2,10, 2, 4, 2, 4, 6, 8, 4, 2, 4,12, 2, 6, 4, 2, 6),
+        P( 4, 6,12, 2, 4, 2, 4, 8, 6, 4, 6, 2, 4, 6, 2, 6,10, 2, 4, 6, 2),
+        P( 6, 4, 2, 4, 2,10, 2,10, 2, 4, 6, 6, 2, 6, 6, 4, 6, 6, 2, 6, 4),
+        P( 2, 6, 4, 6, 8, 4, 2, 6, 4, 8, 6, 4, 6, 2, 4, 6, 8, 6, 4, 2,10),
+        P( 2, 6, 4, 2, 4, 2,10, 2,10, 2, 4, 2, 4, 8, 6, 4, 2, 4, 6, 6, 2),
+        P( 6, 4, 8, 4, 6, 8, 4, 2, 4, 2, 4, 8, 6, 4, 6, 6, 6, 2, 6, 6, 4),
+        P( 2, 4, 6, 2, 6, 4, 2, 4, 2,10, 2,10, 2, 6, 4, 6, 2, 6, 4, 2, 4),
+        P( 6, 6, 8, 4, 2, 6,10, 8, 4, 2, 4, 2, 4, 8,10, 6, 2, 4, 8, 6, 6),
+        P( 4, 2, 4, 6, 2, 6, 4, 6, 2,10, 2,10, 2, 4, 2, 4, 6, 2, 6, 4, 2),
+        P( 4, 6, 6, 2, 6, 6, 6, 4, 6, 8, 4, 2, 4, 2, 4, 8, 6, 4, 8, 4, 6),
+        P( 2, 6, 6, 4, 2, 4, 6, 8, 4, 2, 4, 2,10, 2,10, 2, 4, 2, 4, 6, 2),
+        P(10, 2, 4, 6, 8, 6, 4, 2, 6, 4, 6, 8, 4, 6, 2, 4, 8, 6, 4, 6, 2),
+        P( 4, 6, 2, 6, 6, 4, 6, 6, 2, 6, 6, 4, 2,10, 2,10, 2, 4, 2, 4, 6),
+        P( 2, 6, 4, 2,10, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2,12, 6, 4),
+        P( 6, 2, 4, 6, 2,12, 4, 2, 4, 8, 6, 4, 2, 4, 2,10, 2,10, 6, 2, 4),
+        P( 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2,10, 6, 8, 6, 4, 2, 4, 8, 6),
+        P( 4, 6, 2, 4, 6, 2, 6, 6, 6, 4, 6, 2, 6, 4, 2, 4, 2,10,12, 2, 4),
+        P( 2,10, 2, 6, 4, 2, 4, 6, 6, 2,10, 2, 6, 4,14, 4, 2, 4, 2, 4, 8),
+        P( 6, 4, 6, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4,12, 2,12),
 };
 #undef P
 #undef R
@@ -93,8 +95,8 @@ static const uint64_t packed_wheel[] = {
  *      function                old     new   delta
  *      wheel_tab                 -     485    +485
  * 3-bit-packed insanity:
- *      packed_wheel              -     192    +192
- *      factor_main             108     171     +63
+ *      packed_wheel              -     184    +184
+ *      factor_main             108     163     +55
  */
 static void unpack_wheel(void)
 {
@@ -104,10 +106,7 @@ static void unpack_wheel(void)
         setup_common_bufsiz();
         wheel_tab[0] = 1;
         wheel_tab[1] = 2;
-        wheel_tab[2] = 2;
-        wheel_tab[3] = 4;
-        wheel_tab[4] = 2;
-        p = &wheel_tab[5];
+        p = &wheel_tab[2];
         for (i = 0; i < ARRAY_SIZE(packed_wheel); i++) {
                 uint64_t v = packed_wheel[i];
                 while ((v & 0xe) != 0) {
diff --git a/coreutils/readlink.c b/coreutils/readlink.c
index 0a9aa957e..e17fc3b1e 100644
--- a/coreutils/readlink.c
+++ b/coreutils/readlink.c
@@ -68,12 +68,11 @@ int readlink_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int readlink_main(int argc UNUSED_PARAM, char **argv)
 {
         char *buf;
-        char *fname;
         unsigned opt;
 
+        /* -n must use bit 0 (see printf below) */
         opt = getopt32(argv, "^" "n" IF_FEATURE_READLINK_FOLLOW("fvsq")
                        "\0" "=1");
-        fname = argv[optind];
 
         /* compat: coreutils readlink reports errors silently via exit code */
         if (!(opt & 4)) /* not -v */
@@ -81,14 +80,14 @@ int readlink_main(int argc UNUSED_PARAM, char **argv)
 
         /* NOFORK: only one alloc is allowed; must free */
         if (opt & 2) { /* -f */
-                buf = xmalloc_realpath_coreutils(fname);
+                buf = xmalloc_realpath_coreutils(argv[optind]);
         } else {
-                buf = xmalloc_readlink_or_warn(fname);
+                buf = xmalloc_readlink_or_warn(argv[optind]);
         }
 
         if (!buf)
                 return EXIT_FAILURE;
-        printf((opt & 1) ? "%s" : "%s\n", buf);
+        printf("%s%s", buf, &"\n"[opt & 1]);
         free(buf);
 
         fflush_stdout_and_exit_SUCCESS();
diff --git a/examples/var_service/README b/examples/var_service/README
index 15a1bc9d2..02d987515 100644
--- a/examples/var_service/README
+++ b/examples/var_service/README
@@ -43,7 +43,7 @@ directory, running one child runsv process for the service in each
 subdirectory. A typical choice is to start an instance of runsvdir
 which supervises services in subdirectories of /var/service/.
 
-If /var/service/log/ exists, runsv will supervise two services,
+If /var/service/SERVICE_DIR/log/ exists, runsv will supervise two services,
 and will connect stdout of main service to the stdin of log service.
 This is primarily used for logging.
 
diff --git a/networking/libiproute/ip_parse_common_args.c b/networking/libiproute/ip_parse_common_args.c
index d693c54fa..eccd7e670 100644
--- a/networking/libiproute/ip_parse_common_args.c
+++ b/networking/libiproute/ip_parse_common_args.c
@@ -14,6 +14,83 @@
 #include "ip_common.h"  /* #include "libbb.h" is inside */
 #include "utils.h"
 
+/* iproute2-5.17.0:
+-V, -Version
+       Print the version of the ip utility and exit.
+-h, -human, -human-readable
+       output statistics with human readable values followed by suffix.
+-b, -batch FILENAME
+       Read commands from provided file or standard input and invoke them.
+       First failure will cause termination of ip.
+-force Don't terminate ip on errors in batch mode.  If there were any errors
+       during execution of the commands, the application return code will be
+       non zero.
+-s, -stats, -statistics
+       Output more information. If the option appears twice or more,
+       the amount of information increases.  As a rule, the information
+       is statistics or some time values.
+-d, -details
+       Output more detailed information.
+-l, -loops COUNT
+       Specify maximum number of loops the 'ip address flush' logic will
+       attempt before giving up. The default is 10.  Zero (0) means loop
+       until all addresses are removed.
+-f, -family FAMILY
+       Specifies the protocol family to use. The protocol family identifier
+       can be one of inet, inet6, bridge, mpls or link.  If this option is
+       not present, the protocol family is guessed from other arguments.
+       If the rest of the command line does not give enough information
+       to guess the family, ip falls back to the default one, usually inet
+       or any.  link is a special family identifier meaning that
+       no networking protocol is involved.
+-4     shortcut for -family inet.
+-6     shortcut for -family inet6.
+-B     shortcut for -family bridge.
+-M     shortcut for -family mpls.
+-0     shortcut for -family link.
+-o, -oneline
+       output each record on a single line, replacing line feeds with the '\'
+       character. This is convenient when you want to count records with wc(1)
+       or to grep(1) the output.
+-r, -resolve
+       use the system's name resolver to print DNS names instead of addresses.
+-n, -netns NETNS
+       switches ip to the specified network namespace NETNS.  Actually it just
+       simplifies executing of:
+       ip netns exec NETNS ip [ OPTIONS ] OBJECT { COMMAND | help }
+       to
+       ip -n[etns] NETNS [ OPTIONS ] OBJECT { COMMAND | help }
+-N, -Numeric
+       Print the number of protocol, scope, dsfield, etc directly instead of
+       converting it to human readable name.
+-a, -all
+       executes specified command over all objects, it depends if command
+       supports this option.
+-c[color][={always|auto|never}
+       Configure color output. If parameter is omitted or always, color output
+       is enabled regardless of stdout state. If parameter is auto, stdout is
+       checked to be a terminal before enabling color output. If parameter is
+       never, color output is disabled. If specified multiple times, the last
+       one takes precedence. This flag is ignored if -json is also given.
+       Used color palette can be influenced by COLORFGBG environment variable.
+-t, -timestamp
+       display current time when using monitor option.
+-ts, -tshort
+       Like -timestamp, but use shorter format.
+-rc, -rcvbuf SIZE
+       Set the netlink socket receive buffer size, defaults to 1MB.
+-iec   print human readable rates in IEC units (e.g. 1Ki = 1024).
+-br, -brief
+       Print only basic information in a tabular format for better readability.
+       This option is currently only supported by ip addr show , ip link show
+       & ip neigh show commands.
+-j, -json
+       Output results in JavaScript Object Notation (JSON).
+-p, -pretty
+       The default JSON format is compact and more efficient to parse but hard
+       for most users to read.  This flag adds indentation for readability.
+*/
+
 family_t preferred_family = AF_UNSPEC;
 smallint oneline;
 char _SL_;
diff --git a/networking/libiproute/ipaddress.c b/networking/libiproute/ipaddress.c
index ecc3848ff..c8d77422c 100644
--- a/networking/libiproute/ipaddress.c
+++ b/networking/libiproute/ipaddress.c
@@ -44,7 +44,7 @@ struct filter_t {
         int ifindex;
         family_t family;
         smallint showqueue;
-        smallint oneline;
+        /*smallint oneline; - redundant, global "oneline" flag is enough */
         smallint up;
         /* Misnomer. Does not mean "flushed something" */
         /* More like "flush commands were constructed by print_addrinfo()" */
@@ -297,7 +297,7 @@ static int FAST_FUNC print_addrinfo(const struct sockaddr_nl *who UNUSED_PARAM,
         if (n->nlmsg_type == RTM_DELADDR)
                 printf("Deleted ");
 
-        if (G_filter.oneline)
+        if (/*G_filter.*/ oneline)
                 printf("%u: %s", ifa->ifa_index, ll_index_to_name(ifa->ifa_index));
         if (ifa->ifa_family == AF_INET)
                 printf("    inet ");
@@ -427,10 +427,10 @@ static int FAST_FUNC store_nlmsg(const struct sockaddr_nl *who, struct nlmsghdr
         return 0;
 }
 
-static void ipaddr_reset_filter(int _oneline)
+static void ipaddr_reset_filter(void /*int _oneline*/)
 {
         memset(&G_filter, 0, sizeof(G_filter));
-        G_filter.oneline = _oneline;
+        /*G_filter.oneline = _oneline;*/
 }
 
 /* Return value becomes exitcode. It's okay to not return at all */
@@ -444,7 +444,7 @@ int FAST_FUNC ipaddr_list_or_flush(char **argv, int flush)
         struct rtnl_handle rth;
         char *filter_dev = NULL;
 
-        ipaddr_reset_filter(oneline);
+        ipaddr_reset_filter(/*oneline*/);
         G_filter.showqueue = 1;
 
         if (G_filter.family == AF_UNSPEC)
diff --git a/networking/nslookup.c b/networking/nslookup.c
index 6da97baf4..249083e24 100644
--- a/networking/nslookup.c
+++ b/networking/nslookup.c
@@ -34,16 +34,14 @@
 //usage:       "Name:       debian\n"
 //usage:       "Address:    127.0.0.1\n"
 
+#if !ENABLE_FEATURE_NSLOOKUP_BIG
+
 #include <resolv.h>
-#include <net/if.h>     /* for IFNAMSIZ */
 //#include <arpa/inet.h>
 //#include <netdb.h>
 #include "libbb.h"
 #include "common_bufsiz.h"
 
-
-#if !ENABLE_FEATURE_NSLOOKUP_BIG
-
 /*
  * Mini nslookup implementation for busybox
  *
@@ -248,12 +246,386 @@ int nslookup_main(int argc, char **argv)
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include "libbb.h"
+#include "common_bufsiz.h"
+
 #if 0
 # define dbg(...) fprintf(stderr, __VA_ARGS__)
 #else
 # define dbg(...) ((void)0)
 #endif
 
+/* Instead of using ancient libc DNS query support,
+ * we can carry our own, independent code.
+ * E.g. res_mkquery() loses
+ * three of its paramemters (they are unused!).
+ * Unfortunately, while it does eliminate
+ *      ns_get16
+ *      ns_get32
+ *      ns_name_uncompress
+ *      dn_skipname
+ *      ns_skiprr
+ *      ns_initparse
+ *      ns_parserr
+ * libc functions from a static binary, libc versions of
+ * dn_expand and res_mkquery are still linked in
+ * - they are used by getnameinfo(). Each is ~230 bytes of code.
+ * This makes USE_LIBC_RESOLV = 0 code _bigger_ (by about 27 bytes),
+ * despite inlining and constant propagation.
+ */
+#define USE_LIBC_RESOLV 1
+
+#if USE_LIBC_RESOLV
+
+#include <resolv.h>
+
+#else
+
+#define RESOLVFUNC      /*nothing*/
+#define BIGRESOLVFUNC   /*nothing*/
+#define TINYRESOLVFUNC  ALWAYS_INLINE
+
+/* This one is taken from musl 1.2.4 */
+
+#define NS_MAXDNAME     1025
+#define NS_INT32SZ      4
+#define NS_INT16SZ      2
+
+#define MAXDNAME        NS_MAXDNAME
+
+typedef enum __ns_opcode {
+        ns_o_query = 0,
+} ns_opcode;
+typedef enum __ns_class {
+        ns_c_in = 1,
+} ns_class;
+typedef enum __ns_sect {
+        ns_s_qd = 0,
+        ns_s_zn = 0,
+        ns_s_an = 1,
+        ns_s_pr = 1,
+        ns_s_ns = 2,
+        ns_s_ud = 2,
+        ns_s_ar = 3,
+        ns_s_max = 4
+} ns_sect;
+typedef enum __ns_type {
+        ns_t_a = 1,
+        ns_t_ns = 2,
+        ns_t_cname = 5,
+        ns_t_soa = 6,
+        ns_t_ptr = 12,
+        ns_t_mx = 15,
+        ns_t_txt = 16,
+        ns_t_aaaa = 28,
+        ns_t_srv = 33,
+        ns_t_any = 255,
+} ns_type;
+#define QUERY           ns_o_query
+#define T_A             ns_t_a
+#define T_PTR           ns_t_ptr
+#define T_AAAA          ns_t_aaaa
+#define C_IN            ns_c_in
+
+typedef struct __ns_msg {
+        const unsigned char *_msg, *_eom;
+        uint16_t _id, _flags, _counts[ns_s_max];
+        const unsigned char *_sections[ns_s_max];
+        ns_sect _sect;
+        int _rrnum;
+        const unsigned char *_msg_ptr;
+} ns_msg;
+#define ns_msg_id(handle) ((handle)._id + 0)
+#define ns_msg_base(handle) ((handle)._msg + 0)
+#define ns_msg_end(handle) ((handle)._eom + 0)
+#define ns_msg_size(handle) ((handle)._eom - (handle)._msg)
+#define ns_msg_count(handle, section) ((handle)._counts[section] + 0)
+#define ns_msg_getflag(handle, flag) \
+        (((handle)._flags & _ns_flagdata[flag].mask) >> _ns_flagdata[flag].shift)
+
+typedef struct __ns_rr {
+        char            name[NS_MAXDNAME];
+        uint16_t        type;
+        uint16_t        rr_class;
+        uint32_t        ttl;
+        uint16_t        rdlength;
+        const unsigned char *rdata;
+} ns_rr;
+#define ns_rr_name(rr)  (((rr).name[0] != '\0') ? (rr).name : ".")
+#define ns_rr_type(rr)  ((ns_type)((rr).type + 0))
+#define ns_rr_class(rr) ((ns_class)((rr).rr_class + 0))
+#define ns_rr_ttl(rr)   ((rr).ttl + 0)
+#define ns_rr_rdlen(rr) ((rr).rdlength + 0)
+#define ns_rr_rdata(rr) ((rr).rdata + 0)
+
+typedef struct {
+        unsigned        id :16;
+#if __BYTE_ORDER == __BIG_ENDIAN
+        unsigned        qr: 1;
+        unsigned        opcode: 4;
+        unsigned        aa: 1;
+        unsigned        tc: 1;
+        unsigned        rd: 1;
+        unsigned        ra: 1;
+        unsigned        unused :1;
+        unsigned        ad: 1;
+        unsigned        cd: 1;
+        unsigned        rcode :4;
+#else
+        unsigned        rd :1;
+        unsigned        tc :1;
+        unsigned        aa :1;
+        unsigned        opcode :4;
+        unsigned        qr :1;
+        unsigned        rcode :4;
+        unsigned        cd: 1;
+        unsigned        ad: 1;
+        unsigned        unused :1;
+        unsigned        ra :1;
+#endif
+        unsigned        qdcount :16;
+        unsigned        ancount :16;
+        unsigned        nscount :16;
+        unsigned        arcount :16;
+} HEADER;
+
+#define dn_ns_get16 bb_ns_get16
+static unsigned TINYRESOLVFUNC ns_get16(const unsigned char *cp)
+{
+        return cp[0]<<8 | cp[1];
+}
+#define ns_get32 bb_ns_get32
+static unsigned long TINYRESOLVFUNC ns_get32(const unsigned char *cp)
+{
+        return (unsigned)cp[0]<<24 | cp[1]<<16 | cp[2]<<8 | cp[3];
+}
+#define NS_GET16(s, cp) (void)((s) = ns_get16(((cp)+=2)-2))
+#define NS_GET32(l, cp) (void)((l) = ns_get32(((cp)+=4)-4))
+
+#define dn_expand bb_dn_expand
+static int BIGRESOLVFUNC dn_expand(const unsigned char *base, const unsigned char *end, const unsigned char *src, char *dest, int space)
+{
+        const unsigned char *p = src;
+        char *dend, *dbegin = dest;
+        int len = -1, i, j;
+        if (p==end || space <= 0) return -1;
+        dend = dest + (space > 254 ? 254 : space);
+        /* detect reference loop using an iteration counter */
+        for (i=0; i < end-base; i+=2) {
+                /* loop invariants: p<end, dest<dend */
+                if (*p & 0xc0) {
+                        if (p+1==end) return -1;
+                        j = ((p[0] & 0x3f) << 8) | p[1];
+                        if (len < 0) len = p+2-src;
+                        if (j >= end-base) return -1;
+                        p = base+j;
+                } else if (*p) {
+                        if (dest != dbegin) *dest++ = '.';
+                        j = *p++;
+                        if (j >= end-p || j >= dend-dest) return -1;
+                        while (j--) *dest++ = *p++;
+                } else {
+                        *dest = 0;
+                        if (len < 0) len = p+1-src;
+                        return len;
+                }
+        }
+        return -1;
+}
+
+#define ns_name_uncompress bb_ns_name_uncompress
+static int RESOLVFUNC ns_name_uncompress(const unsigned char *msg, const unsigned char *eom,
+                       const unsigned char *src, char *dst, size_t dstsiz)
+{
+        int r;
+        r = dn_expand(msg, eom, src, dst, dstsiz);
+        if (r < 0) errno = EMSGSIZE;
+        return r;
+}
+
+#define dn_skipname bb_dn_skipname
+static int RESOLVFUNC dn_skipname(const unsigned char *s, const unsigned char *end)
+{
+        const unsigned char *p = s;
+        while (p < end)
+                if (!*p) return p-s+1;
+                else if (*p>=192)
+                        if (p+1<end) return p-s+2;
+                        else break;
+                else
+                        if (end-p<*p+1) break;
+                        else p += *p + 1;
+        return -1;
+}
+#define ns_skiprr bb_ns_skiprr
+static int BIGRESOLVFUNC ns_skiprr(const unsigned char *ptr, const unsigned char *eom, ns_sect section, int count)
+{
+        const unsigned char *p = ptr;
+        int r;
+
+        while (count--) {
+                r = dn_skipname(p, eom);
+                if (r < 0) goto bad;
+                if (r + 2 * NS_INT16SZ > eom - p) goto bad;
+                p += r + 2 * NS_INT16SZ;
+                if (section != ns_s_qd) {
+                        if (NS_INT32SZ + NS_INT16SZ > eom - p) goto bad;
+                        p += NS_INT32SZ;
+                        NS_GET16(r, p);
+                        if (r > eom - p) goto bad;
+                        p += r;
+                }
+        }
+        return p - ptr;
+bad:
+        errno = EMSGSIZE;
+        return -1;
+}
+
+#define ns_parserr bb_ns_parserr
+static int BIGRESOLVFUNC ns_parserr(ns_msg *handle, ns_sect section, int rrnum, ns_rr *rr)
+{
+        int r;
+
+        if (section < 0 || section >= ns_s_max) goto bad;
+        if (section != handle->_sect) {
+                handle->_sect = section;
+                handle->_rrnum = 0;
+                handle->_msg_ptr = handle->_sections[section];
+        }
+        if (rrnum == -1) rrnum = handle->_rrnum;
+        if (rrnum < 0 || rrnum >= handle->_counts[section]) goto bad;
+        if (rrnum < handle->_rrnum) {
+                handle->_rrnum = 0;
+                handle->_msg_ptr = handle->_sections[section];
+        }
+        if (rrnum > handle->_rrnum) {
+                r = ns_skiprr(handle->_msg_ptr, handle->_eom, section, rrnum - handle->_rrnum);
+                if (r < 0) return -1;
+                handle->_msg_ptr += r;
+                handle->_rrnum = rrnum;
+        }
+        r = ns_name_uncompress(handle->_msg, handle->_eom, handle->_msg_ptr, rr->name, NS_MAXDNAME);
+        if (r < 0) return -1;
+        handle->_msg_ptr += r;
+        if (2 * NS_INT16SZ > handle->_eom - handle->_msg_ptr) goto size;
+        NS_GET16(rr->type, handle->_msg_ptr);
+        NS_GET16(rr->rr_class, handle->_msg_ptr);
+        if (section != ns_s_qd) {
+                if (NS_INT32SZ + NS_INT16SZ > handle->_eom - handle->_msg_ptr) goto size;
+                NS_GET32(rr->ttl, handle->_msg_ptr);
+                NS_GET16(rr->rdlength, handle->_msg_ptr);
+                if (rr->rdlength > handle->_eom - handle->_msg_ptr) goto size;
+                rr->rdata = handle->_msg_ptr;
+                handle->_msg_ptr += rr->rdlength;
+        } else {
+                rr->ttl = 0;
+                rr->rdlength = 0;
+                rr->rdata = NULL;
+        }
+        handle->_rrnum++;
+        if (handle->_rrnum > handle->_counts[section]) {
+                handle->_sect = section + 1;
+                if (handle->_sect == ns_s_max) {
+                        handle->_rrnum = -1;
+                        handle->_msg_ptr = NULL;
+                } else {
+                        handle->_rrnum = 0;
+                }
+        }
+        return 0;
+bad:
+        errno = ENODEV;
+        return -1;
+size:
+        errno = EMSGSIZE;
+        return -1;
+}
+
+#define ns_initparse bb_ns_initparse
+static int BIGRESOLVFUNC ns_initparse(const unsigned char *msg, int msglen, ns_msg *handle)
+{
+        int i, r;
+
+        handle->_msg = msg;
+        handle->_eom = msg + msglen;
+        if (msglen < (2 + ns_s_max) * NS_INT16SZ) goto bad;
+        NS_GET16(handle->_id, msg);
+        NS_GET16(handle->_flags, msg);
+        for (i = 0; i < ns_s_max; i++) NS_GET16(handle->_counts[i], msg);
+        for (i = 0; i < ns_s_max; i++) {
+                if (handle->_counts[i]) {
+                        handle->_sections[i] = msg;
+                        r = ns_skiprr(msg, handle->_eom, i, handle->_counts[i]);
+                        if (r < 0) return -1;
+                        msg += r;
+                } else {
+                        handle->_sections[i] = NULL;
+                }
+        }
+        if (msg != handle->_eom) goto bad;
+        handle->_sect = ns_s_max;
+        handle->_rrnum = -1;
+        handle->_msg_ptr = NULL;
+        return 0;
+bad:
+        errno = EMSGSIZE;
+        return -1;
+}
+
+#define res_mkquery bb_res_mkquery
+static int RESOLVFUNC res_mkquery(int op, const char *dname, int class, int type,
+        const unsigned char *data UNUSED_PARAM, int datalen UNUSED_PARAM,
+        const unsigned char *newrr UNUSED_PARAM, unsigned char *buf, int buflen)
+{
+        int i, j;
+        unsigned char q[280];
+        size_t l = strnlen(dname, 255);
+        int n;
+
+        if (l && dname[l-1]=='.') l--;
+        if (l && dname[l-1]=='.') return -1;
+        n = 17+l+!!l;
+        if (l>253 || buflen<n || op>15u || class>255u || type>255u)
+                return -1;
+
+//TODO: why do we even have the q[] array? Use buf[] directly!
+        /* Construct query template - ID will be filled later */
+        memset(q, 0, n);
+        q[2] = op*8 + 1;
+        q[3] = 32; /* AD */
+        q[5] = 1;
+        memcpy((char *)q+13, dname, l);
+        for (i=13; q[i]; i=j+1) {
+                for (j=i; q[j] && q[j] != '.'; j++);
+                if (j-i-1u > 62u) return -1;
+                q[i-1] = j-i;
+        }
+        q[i+1] = type;
+        q[i+3] = class;
+#if 0
+//For some machines (here: a TP-Link RE200 powered by a MediaTek MT7620A)
+//the monotonic clock has a coarse resolution (here: 20us) and it can happen
+//that the requests for A and AAAA share the same transaction ID.
+
+//In that case the mapping from received responses to the sent queries
+//doesn't work and name resolution fails because the AAAA reply
+//is dropped as a duplicate reply to the A query.
+        /* Make a reasonably unpredictable id */
+        unsigned id;
+        struct timespec ts;
+        clock_gettime(CLOCK_REALTIME, &ts);
+        id = ts.tv_nsec + ((uint32_t)(ts.tv_nsec) >> 16);
+        q[0] = id/256;
+        q[1] = id;
+#endif
+        memcpy(buf, q, n);
+        return n;
+}
+
+#endif /* !USE_LIBC_RESOLV */
+
+
 struct ns {
         const char *name;
         len_and_sockaddr *lsa;
@@ -266,7 +638,12 @@ struct query {
         unsigned qlen;
 //      unsigned latency;
 //      uint8_t rcode;
-        unsigned char query[512];
+        /* res_mkquery() balks on names > 253 chars.
+         * The formed query is 253+18 chars at max.
+         * Real hostnames are nowhere near that long anyway.
+         * Use of power-of-2 size means smaller code.
+         */
+        unsigned char query[512 - sizeof(int) - sizeof(char*)];
 //      unsigned char reply[512];
 };
 
@@ -978,6 +1355,21 @@ int nslookup_main(int argc UNUSED_PARAM, char **argv)
                 }
         }
 
+        /* Ensure the Transaction IDs are unique.
+         * See, for example, musl source of res_mkquery() where
+         * it risks using current time (same value!) for ALL queries.
+         */
+        {
+                struct timeval tv;
+                unsigned id;
+                xgettimeofday(&tv);
+                id = tv.tv_sec + tv.tv_usec;
+                for (rc = 0; rc < G.query_count; rc++) {
+                        G.query[rc].query[0] = id >> 8;
+                        G.query[rc].query[1] = id++;
+                }
+        }
+
         for (rc = 0; rc < G.serv_count;) {
                 int c;
 
diff --git a/procps/nmeter.c b/procps/nmeter.c
index e52c868df..4197174ba 100644
--- a/procps/nmeter.c
+++ b/procps/nmeter.c
@@ -985,6 +985,15 @@ int nmeter_main(int argc UNUSED_PARAM, char **argv)
 
         xgettimeofday(&G.start);
         G.tv = G.start;
+
+        // Move back start of monotonic time a bit, to syncronize fractionals of %T and %t:
+        // nmeter -d500 '%6T %6t'
+        // 00:00:00.000161 12:32:07.500161
+        // 00:00:00.500282 12:32:08.000282
+        // 00:00:01.000286 12:32:08.500286
+        if (G.delta > 0)
+                G.start.tv_usec -= (G.start.tv_usec % (unsigned)G.delta);
+
         while (1) {
                 collect_info(first);
                 put_c(G.final_char);
@@ -999,6 +1008,15 @@ int nmeter_main(int argc UNUSED_PARAM, char **argv)
                         int rem;
                         // can be commented out, will sacrifice sleep time precision a bit
                         xgettimeofday(&G.tv);
+
+        // TODO: nmeter -d10000 '%6T %6t'
+        // 00:00:00.770333 12:34:44.770333
+        // 00:00:06.000088 12:34:50.000088
+        // 00:00:16.000094 12:35:00.000094
+        // 00:00:26.000275 12:35:10.000275
+        // we can't syncronize interval to start close to 10 seconds for both
+        // %T and %t (as shown above), but what if there is only %T
+        // in format string? Maybe sync _it_ instead of %t in this case?
                         if (need_seconds)
                                 rem = G.delta - ((ullong)G.tv.tv_sec*1000000 + G.tv.tv_usec) % G.deltanz;
                         else
diff --git a/shell/ash.c b/shell/ash.c
index 87df555dd..09e8725bf 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -8096,6 +8096,8 @@ subevalvar(char *start, char *str, int strloc,
                                 char *restart_detect = stackblock();
                                 if (quotes && *loc == '\\') {
                                         STPUTC(CTLESC, expdest);
+                                        if (stackblock() != restart_detect)
+                                                goto restart;
                                         len++;
                                 }
                                 STPUTC(*loc, expdest);
diff --git a/shell/hush.c b/shell/hush.c
index f8951d084..810dafd35 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -1429,6 +1429,7 @@ static void syntax_error_unterm_str(unsigned lineno UNUSED_PARAM, const char *s)
 {
         bb_error_msg("syntax error: unterminated %s", s);
 //? source4.tests fails: in bash, echo ${^} in script does not terminate the script
+// (but bash --posix, or if bash is run as "sh", does terminate in script, so maybe uncomment this?)
 //      die_if_script();
 }
 
@@ -7589,6 +7590,14 @@ static void parse_and_run_stream(struct in_str *inp, int end_trigger)
                                 }
                                 /* Force prompt */
                                 inp->p = NULL;
+                                /* Clear "peeked" EOF. Without this,
+                                 *  $ { cmd }<Enter>
+                                 *  > ^D
+                                 *  hush: syntax error: unterminated {
+                                 * exits interactive shell:
+                                 */
+                                if (inp->peek_buf[0] == EOF)
+                                        inp->peek_buf[0] = 0;
                                 /* This stream isn't empty */
                                 empty = 0;
                                 continue;