Merge branch busybox (up to "ash: comment out free(p) just before...")

11 files changed, 238 insertions, 73 deletions

diff --git a/libbb/appletlib.c b/libbb/appletlib.c
index 28adf2740..4aa40454f 100644
--- a/libbb/appletlib.c
+++ b/libbb/appletlib.c
@@ -930,7 +930,9 @@ void FAST_FUNC run_applet_no_and_exit(int applet_no, char **argv)
         }
         if (ENABLE_FEATURE_SUID)
                 check_suid(applet_no);
-        exit(applet_main[applet_no](argc, argv));
+        xfunc_error_retval = applet_main[applet_no](argc, argv);
+        /* Note: applet_main() may also not return (die on a xfunc or such) */
+        xfunc_die();
 }
 # endif /* NUM_APPLETS > 0 */
 
@@ -993,6 +995,14 @@ int main(int argc UNUSED_PARAM, char **argv)
          */
         mallopt(M_MMAP_THRESHOLD, 32 * 1024 - 256);
 #endif
+#if 0 /*def M_TOP_PAD*/
+        /* When the program break is increased, then M_TOP_PAD bytes are added
+         * to the sbrk(2) request. When the heap is trimmed because of free(3),
+         * this much free space is preserved at the top of the heap.
+         * glibc default seems to be way too big: 128k, but need to verify.
+         */
+        mallopt(M_TOP_PAD, 8 * 1024);
+#endif
 
 #if !BB_MMU
         /* NOMMU re-exec trick sets high-order bit in first byte of name */
diff --git a/libbb/copy_file.c b/libbb/copy_file.c
index c52297376..cb6d12359 100644
--- a/libbb/copy_file.c
+++ b/libbb/copy_file.c
@@ -299,11 +299,16 @@ int FAST_FUNC copy_file(const char *source, const char *dest, int flags)
                 if (!S_ISREG(source_stat.st_mode))
                         new_mode = 0666;
 
-                // POSIX way is a security problem versus (sym)link attacks
-                if (!ENABLE_FEATURE_NON_POSIX_CP) {
-                        dst_fd = open(dest, O_WRONLY|O_CREAT|O_TRUNC, new_mode);
-                } else { /* safe way: */
+                if (ENABLE_FEATURE_NON_POSIX_CP || (flags & FILEUTILS_INTERACTIVE)) {
+                        /*
+                         * O_CREAT|O_EXCL: require that file did not exist before creation
+                         */
                         dst_fd = open(dest, O_WRONLY|O_CREAT|O_EXCL, new_mode);
+                } else { /* POSIX, and not "cp -i" */
+                        /*
+                         * O_CREAT|O_TRUNC: create, or truncate (security problem versus (sym)link attacks)
+                         */
+                        dst_fd = open(dest, O_WRONLY|O_CREAT|O_TRUNC, new_mode);
                 }
                 if (dst_fd == -1) {
                         ovr = ask_and_unlink(dest, flags);
@@ -378,7 +383,7 @@ int FAST_FUNC copy_file(const char *source, const char *dest, int flags)
                 }
                 /* _Not_ jumping to preserve_mode_ugid_time:
                  * symlinks don't have those */
-                return 0;
+                goto verb_and_exit;
         }
         if (S_ISBLK(source_stat.st_mode) || S_ISCHR(source_stat.st_mode)
          || S_ISSOCK(source_stat.st_mode) || S_ISFIFO(source_stat.st_mode)
@@ -413,6 +418,7 @@ int FAST_FUNC copy_file(const char *source, const char *dest, int flags)
                         bb_perror_msg("can't preserve %s of '%s'", "permissions", dest);
         }
 
+ verb_and_exit:
         if (flags & FILEUTILS_VERBOSE) {
                 printf("'%s' -> '%s'\n", source, dest);
         }
diff --git a/libbb/dump.c b/libbb/dump.c
index 566881a78..154be5d80 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -157,7 +157,7 @@ static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
                         /*
                          * figure out the byte count for each conversion;
                          * rewrite the format as necessary, set up blank-
-                         * pbb_dump_adding for end of data.
+                         * padding for end of data.
                          */
                         if (*p1 == 'c') {
                                 pr->flags = F_CHAR;
@@ -466,14 +466,14 @@ static void bpad(PR *pr)
 }
 
 static const char conv_str[] ALIGN1 =
-        "\0\\0\0"
-        "\007\\a\0"  /* \a */
-        "\b\\b\0"
-        "\f\\b\0"
-        "\n\\n\0"
-        "\r\\r\0"
-        "\t\\t\0"
-        "\v\\v\0"
+        "\0"  "\\""0""\0"
+        "\007""\\""a""\0"  /* \a */
+        "\b"  "\\""b""\0"
+        "\f"  "\\""f""\0"
+        "\n"  "\\""n""\0"
+        "\r"  "\\""r""\0"
+        "\t"  "\\""t""\0"
+        "\v"  "\\""v""\0"
         ;
 
 
@@ -485,7 +485,7 @@ static void conv_c(PR *pr, unsigned char *p)
         do {
                 if (*p == *str) {
                         ++str;
-                        goto strpr;
+                        goto strpr; /* map e.g. '\n' to "\\n" */
                 }
                 str += 4;
         } while (*str);
@@ -702,8 +702,6 @@ int FAST_FUNC bb_dump_dump(dumper_t *pub_dumper, char **argv)
 void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
 {
         const char *p;
-        char *p1;
-        char *p2;
         FS *tfs;
         FU *tfu, **nextfupp;
         const char *savep;
@@ -779,29 +777,42 @@ void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
                         }
                 }
                 tfu->fmt = xstrndup(savep, p - savep);
-/*      escape(tfu->fmt); */
-
-                p1 = tfu->fmt;
 
                 /* alphabetic escape sequences have to be done in place */
+                strcpy_and_process_escape_sequences(tfu->fmt, tfu->fmt);
+                /* unknown mappings are not changed: "\z" -> '\\' 'z' */
+                /* trailing backslash, if any, is preserved */
+#if 0
+                char *p1;
+                char *p2;
+                p1 = tfu->fmt;
                 for (p2 = p1;; ++p1, ++p2) {
-                        if (*p1 == '\0') {
-                                *p2 = *p1;
+                        *p2 = *p1;
+                        if (*p1 == '\0')
                                 break;
-                        }
+
                         if (*p1 == '\\') {
-                                const char *cs = conv_str + 4;
-                                ++p1;
+                                const char *cs;
+
+                                p1++;
                                 *p2 = *p1;
+                                if (*p1 == '\0') {
+                                        /* "...\" trailing backslash. Eaten. */
+                                        break;
+                                }
+                                cs = conv_str + 4; /* skip NUL element */
                                 do {
+                                        /* map e.g. "\n" -> '\n' */
                                         if (*p1 == cs[2]) {
                                                 *p2 = cs[0];
                                                 break;
                                         }
                                         cs += 4;
                                 } while (*cs);
+                                /* unknown mappings remove bkslash: "\z" -> 'z' */
                         }
                 }
+#endif
 
                 p++;
         }
diff --git a/libbb/hash_md5_sha.c b/libbb/hash_md5_sha.c
index d08c6b2f7..7e7d8da2f 100644
--- a/libbb/hash_md5_sha.c
+++ b/libbb/hash_md5_sha.c
@@ -941,10 +941,6 @@ void FAST_FUNC sha512_end(sha512_ctx_t *ctx, void *resbuf)
 # define OPTIMIZE_SHA3_FOR_32 1
 #endif
 
-enum {
-        SHA3_IBLK_BYTES = 72, /* 576 bits / 8 */
-};
-
 #if OPTIMIZE_SHA3_FOR_32
 /* This splits every 64-bit word into a pair of 32-bit words,
  * even bits go into first word, odd bits go to second one.
@@ -1352,6 +1348,8 @@ static void sha3_process_block72(uint64_t *state)
 void FAST_FUNC sha3_begin(sha3_ctx_t *ctx)
 {
         memset(ctx, 0, sizeof(*ctx));
+        /* SHA3-512, user can override */
+        ctx->input_block_bytes = (1600 - 512*2) / 8; /* 72 bytes */
 }
 
 void FAST_FUNC sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len)
@@ -1361,7 +1359,7 @@ void FAST_FUNC sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len)
         unsigned bufpos = ctx->bytes_queued;
 
         while (1) {
-                unsigned remaining = SHA3_IBLK_BYTES - bufpos;
+                unsigned remaining = ctx->input_block_bytes - bufpos;
                 if (remaining > len)
                         remaining = len;
                 len -= remaining;
@@ -1373,38 +1371,41 @@ void FAST_FUNC sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len)
                         remaining--;
                 }
                 /* Clever way to do "if (bufpos != N) break; ... ; bufpos = 0;" */
-                bufpos -= SHA3_IBLK_BYTES;
+                bufpos -= ctx->input_block_bytes;
                 if (bufpos != 0)
                         break;
                 /* Buffer is filled up, process it */
                 sha3_process_block72(ctx->state);
                 /*bufpos = 0; - already is */
         }
-        ctx->bytes_queued = bufpos + SHA3_IBLK_BYTES;
+        ctx->bytes_queued = bufpos + ctx->input_block_bytes;
 #else
         /* +50 bytes code size, but a bit faster because of long-sized XORs */
         const uint8_t *data = buffer;
         unsigned bufpos = ctx->bytes_queued;
+        unsigned iblk_bytes = ctx->input_block_bytes;
 
         /* If already data in queue, continue queuing first */
-        while (len != 0 && bufpos != 0) {
-                uint8_t *buf = (uint8_t*)ctx->state;
-                buf[bufpos] ^= *data++;
-                len--;
-                bufpos++;
-                if (bufpos == SHA3_IBLK_BYTES) {
-                        bufpos = 0;
-                        goto do_block;
+        if (bufpos != 0) {
+                while (len != 0) {
+                        uint8_t *buf = (uint8_t*)ctx->state;
+                        buf[bufpos] ^= *data++;
+                        len--;
+                        bufpos++;
+                        if (bufpos == iblk_bytes) {
+                                bufpos = 0;
+                                goto do_block;
+                        }
                 }
         }
 
         /* Absorb complete blocks */
-        while (len >= SHA3_IBLK_BYTES) {
+        while (len >= iblk_bytes) {
                 /* XOR data onto beginning of state[].
                  * We try to be efficient - operate one word at a time, not byte.
                  * Careful wrt unaligned access: can't just use "*(long*)data"!
                  */
-                unsigned count = SHA3_IBLK_BYTES / sizeof(long);
+                unsigned count = iblk_bytes / sizeof(long);
                 long *buf = (long*)ctx->state;
                 do {
                         long v;
@@ -1412,7 +1413,7 @@ void FAST_FUNC sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len)
                         *buf++ ^= v;
                         data += sizeof(long);
                 } while (--count);
-                len -= SHA3_IBLK_BYTES;
+                len -= iblk_bytes;
  do_block:
                 sha3_process_block72(ctx->state);
         }
@@ -1433,8 +1434,22 @@ void FAST_FUNC sha3_end(sha3_ctx_t *ctx, void *resbuf)
 {
         /* Padding */
         uint8_t *buf = (uint8_t*)ctx->state;
-        buf[ctx->bytes_queued]   ^= 1;
-        buf[SHA3_IBLK_BYTES - 1] ^= 0x80;
+        /*
+         * Keccak block padding is: add 1 bit after last bit of input,
+         * then add zero bits until the end of block, and add the last 1 bit
+         * (the last bit in the block) - the "10*1" pattern.
+         * SHA3 standard appends additional two bits, 01,  before that padding:
+         *
+         * SHA3-224(M) = KECCAK[448](M||01, 224)
+         * SHA3-256(M) = KECCAK[512](M||01, 256)
+         * SHA3-384(M) = KECCAK[768](M||01, 384)
+         * SHA3-512(M) = KECCAK[1024](M||01, 512)
+         * (M is the input, || is bit concatenation)
+         *
+         * The 6 below contains 01 "SHA3" bits and the first 1 "Keccak" bit:
+         */
+        buf[ctx->bytes_queued]          ^= 6; /* bit pattern 00000110 */
+        buf[ctx->input_block_bytes - 1] ^= 0x80;
 
         sha3_process_block72(ctx->state);
 
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index 2566abd38..34eb16e6b 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -81,7 +81,9 @@
 # define CHAR_T wchar_t
 static bool BB_isspace(CHAR_T c) { return ((unsigned)c < 256 && isspace(c)); }
 # if ENABLE_FEATURE_EDITING_VI
-static bool BB_isalnum(CHAR_T c) { return ((unsigned)c < 256 && isalnum(c)); }
+static bool BB_isalnum_or_underscore(CHAR_T c) {
+        return ((unsigned)c < 256 && isalnum(c)) || c == '_';
+}
 # endif
 static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); }
 # undef isspace
@@ -96,7 +98,11 @@ static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); }
 # define BB_NUL '\0'
 # define CHAR_T char
 # define BB_isspace(c) isspace(c)
-# define BB_isalnum(c) isalnum(c)
+# if ENABLE_FEATURE_EDITING_VI
+static bool BB_isalnum_or_underscore(CHAR_T c) {
+        return ((unsigned)c < 256 && isalnum(c)) || c == '_';
+}
+# endif
 # define BB_ispunct(c) ispunct(c)
 #endif
 #if ENABLE_UNICODE_PRESERVE_BROKEN
@@ -1647,9 +1653,9 @@ vi_word_motion(int eat)
 {
         CHAR_T *command = command_ps;
 
-        if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
+        if (BB_isalnum_or_underscore(command[cursor])) {
                 while (cursor < command_len
-                 && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_')
+                 && (BB_isalnum_or_underscore(command[cursor+1]))
                 ) {
                         input_forward();
                 }
@@ -1691,9 +1697,9 @@ vi_end_motion(void)
                 input_forward();
         if (cursor >= command_len-1)
                 return;
-        if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
+        if (BB_isalnum_or_underscore(command[cursor])) {
                 while (cursor < command_len-1
-                 && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_')
+                 && (BB_isalnum_or_underscore(command[cursor+1]))
                 ) {
                         input_forward();
                 }
@@ -1726,9 +1732,9 @@ vi_back_motion(void)
                 input_backward(1);
         if (cursor <= 0)
                 return;
-        if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
+        if (BB_isalnum_or_underscore(command[cursor])) {
                 while (cursor > 0
-                 && (BB_isalnum(command[cursor-1]) || command[cursor-1] == '_')
+                 && (BB_isalnum_or_underscore(command[cursor-1]))
                 ) {
                         input_backward(1);
                 }
diff --git a/libbb/login.c b/libbb/login.c
index 8f080b775..5a7acfcf0 100644
--- a/libbb/login.c
+++ b/libbb/login.c
@@ -45,6 +45,45 @@ void FAST_FUNC print_login_issue(const char *issue_file, const char *tty)
                 if (c == '\\' || c == '%') {
                         c = fgetc(fp);
                         switch (c) {
+//From getty manpage (* - supported by us)
+//========================================
+//4 or 4{interface}
+//  Insert the IPv4 address of the network interface (example: \4{eth0}).
+//  If the interface argument is not specified, then select the first
+//  fully configured (UP, non-LOOPBACK, RUNNING) interface.
+//6 or 6{interface} -- The same as \4 but for IPv6.
+//b -- Insert the baudrate of the current line.
+//*d -- Insert the current date.
+//*t -- Insert the current time.
+//e or e{name}
+//  Translate the human-readable name to an escape sequence and insert it
+//  (for example: \e{red}Alert text.\e{reset}).  If the name argument
+//  is not specified, then insert \033. The currently supported names are:
+//  black, blink, blue, bold, brown, cyan, darkgray, gray, green, halfbright,
+//  lightblue, lightcyan, lightgray, lightgreen, lightmagenta, lightred,
+//  magenta, red, reset, reverse, and yellow. Unknown names are ignored.
+//*s
+//  Insert the system name (the name of the operating system - `uname -s`)
+//*S or S{VARIABLE}
+//  Insert the VARIABLE data from /etc/os-release.
+//  If the VARIABLE argument is not specified, use PRETTY_NAME.
+//  If PRETTY_NAME is not in /etc/os-release, \S is the same as \s.
+//*l -- Insert the name of the current tty line.
+//*m -- Insert the architecture identifier of the machine: `uname -m`.
+//*n -- Insert the nodename of the machine: `uname -n`.
+//*o -- Insert the NIS domainname of the machine.  Same as `hostname -d'.
+//*O -- Insert the DNS domainname of the machine.
+//*r -- Insert the release number of the OS: `uname -r`.
+//u -- Insert the number of current users logged in.
+//U -- Insert the string "1 user" or "N users" (current users logged in).
+//*v -- Insert the version of the OS, e.g. the build-date etc: `uname -v`.
+//We also implement:
+//*D -- same as \O "DNS domainname"
+//*h -- same as \n "nodename"
+
+                        case 'S':
+                                /* minimal implementation, not reading /etc/os-release */
+                                /*FALLTHROUGH*/
                         case 's':
                                 outbuf = uts.sysname;
                                 break;
@@ -65,6 +104,7 @@ void FAST_FUNC print_login_issue(const char *issue_file, const char *tty)
 #if defined(__linux__)
                         case 'D':
                         case 'o':
+                        case 'O':
                                 outbuf = uts.domainname;
                                 break;
 #endif
diff --git a/libbb/speed_table.c b/libbb/speed_table.c
index 174d531b2..11ced01d0 100644
--- a/libbb/speed_table.c
+++ b/libbb/speed_table.c
@@ -10,7 +10,16 @@
 #include "libbb.h"
 
 struct speed_map {
-#if defined __FreeBSD__
+#if defined __FreeBSD__ \
+ || (defined B115200  && B115200  > 0xffff) \
+ || (defined B230400  && B230400  > 0xffff) \
+ || (defined B460800  && B460800  > 0xffff) \
+ || (defined B921600  && B921600  > 0xffff) \
+ || (defined B1152000 && B1152000 > 0xffff) \
+ || (defined B1000000 && B1000000 > 0xffff) \
+ || (defined B2000000 && B2000000 > 0xffff) \
+ || (defined B3000000 && B3000000 > 0xffff) \
+ || (defined B4000000 && B4000000 > 0xffff)
         /* On FreeBSD, B<num> constants don't fit into a short */
         unsigned speed;
 #else
@@ -19,6 +28,7 @@ struct speed_map {
         unsigned short value;
 };
 
+/* On Linux, Bxx constants are 0..15 (up to B38400) and 0x1001..0x100f */
 static const struct speed_map speeds[] = {
         {B0, 0},
         {B50, 50},
@@ -37,30 +47,79 @@ static const struct speed_map speeds[] = {
 #ifdef B19200
         {B19200, 19200},
 #elif defined(EXTA)
-        {EXTA, 19200},
+        {EXTA,   19200},
 #endif
+/* 19200 = 0x4b00 */
+/* 38400 = 0x9600, this value would use bit#15 if not "/200" encoded: */
 #ifdef B38400
-        {B38400, 38400/256 + 0x8000U},
+        {B38400, 38400/200 + 0x8000u},
 #elif defined(EXTB)
-        {EXTB, 38400/256 + 0x8000U},
+        {EXTB,   38400/200 + 0x8000u},
 #endif
 #ifdef B57600
-        {B57600, 57600/256 + 0x8000U},
+        {B57600, 57600/200 + 0x8000u},
 #endif
 #ifdef B115200
-        {B115200, 115200/256 + 0x8000U},
+        {B115200, 115200/200 + 0x8000u},
 #endif
 #ifdef B230400
-        {B230400, 230400/256 + 0x8000U},
+        {B230400, 230400/200 + 0x8000u},
 #endif
 #ifdef B460800
-        {B460800, 460800/256 + 0x8000U},
+        {B460800, 460800/200 + 0x8000u},
+#endif
+#ifdef B576000
+        {B576000, 576000/200 + 0x8000u},
 #endif
 #ifdef B921600
-        {B921600, 921600/256 + 0x8000U},
+        {B921600, 921600/200 + 0x8000u},
+#endif
+#ifdef B1152000
+        {B1152000, 1152000/200 + 0x8000u},
+#endif
+
+#ifdef B500000
+        {B500000,   500000/200 + 0x8000u},
+#endif
+#ifdef B1000000
+        {B1000000, 1000000/200 + 0x8000u},
+#endif
+#ifdef B1500000
+        {B1500000, 1500000/200 + 0x8000u},
+#endif
+#ifdef B2000000
+        {B2000000, 2000000/200 + 0x8000u},
+#endif
+#ifdef B2500000
+        {B2500000, 2500000/200 + 0x8000u},
 #endif
+#ifdef B3000000
+        {B3000000, 3000000/200 + 0x8000u},
+#endif
+#ifdef B3500000
+        {B3500000, 3500000/200 + 0x8000u},
+#endif
+#ifdef B4000000
+        {B4000000, 4000000/200 + 0x8000u},
+#endif
+/* 4000000/200 = 0x4e20, bit#15 still does not interfere with the value */
+/* (can use /800 if higher speeds would appear, /1600 won't work for B500000) */
 };
 
+/*
+ * TODO: maybe we can just bite the bullet, ditch the table and use termios2
+ * Linux API (supports arbitrary baud rates, no Bxxxx mess needed)? Example:
+ *
+ * #include <asm/termios.h>
+ * #include <asm/ioctls.h>
+ * struct termios2 t;
+ * ioctl(fd, TCGETS2, &t);
+ * t.c_ospeed = t.c_ispeed = 543210;
+ * t.c_cflag &= ~CBAUD;
+ * t.c_cflag |= BOTHER;
+ * ioctl(fd, TCSETS2, &t);
+ */
+
 enum { NUM_SPEEDS = ARRAY_SIZE(speeds) };
 
 unsigned FAST_FUNC tty_baud_to_value(speed_t speed)
@@ -69,8 +128,8 @@ unsigned FAST_FUNC tty_baud_to_value(speed_t speed)
 
         do {
                 if (speed == speeds[i].speed) {
-                        if (speeds[i].value & 0x8000U) {
-                                return ((unsigned long) (speeds[i].value) & 0x7fffU) * 256;
+                        if (speeds[i].value & 0x8000u) {
+                                return ((unsigned)(speeds[i].value) & 0x7fffU) * 200;
                         }
                         return speeds[i].value;
                 }
diff --git a/libbb/udp_io.c b/libbb/udp_io.c
index a32af9bd2..6e3ef484e 100644
--- a/libbb/udp_io.c
+++ b/libbb/udp_io.c
@@ -70,7 +70,13 @@ send_to_from(int fd, void *buf, size_t len, int flags,
         msg.msg_flags = flags;
 
         cmsgptr = CMSG_FIRSTHDR(&msg);
-        if (to->sa_family == AF_INET && from->sa_family == AF_INET) {
+        /*
+         * Users report that to->sa_family can be AF_INET6 too,
+         * if "to" was acquired by recv_from_to(). IOW: recv_from_to()
+         * was seen showing IPv6 "from" even when the destination
+         * of received packet (our local address) was IPv4.
+         */
+        if (/* to->sa_family == AF_INET && */ from->sa_family == AF_INET) {
                 struct in_pktinfo *pktptr;
                 cmsgptr->cmsg_level = IPPROTO_IP;
                 cmsgptr->cmsg_type = IP_PKTINFO;
@@ -86,7 +92,7 @@ send_to_from(int fd, void *buf, size_t len, int flags,
                 pktptr->ipi_spec_dst = ((struct sockaddr_in*)from)->sin_addr;
         }
 # if ENABLE_FEATURE_IPV6 && defined(IPV6_PKTINFO)
-        else if (to->sa_family == AF_INET6 && from->sa_family == AF_INET6) {
+        else if (/* to->sa_family == AF_INET6 && */ from->sa_family == AF_INET6) {
                 struct in6_pktinfo *pktptr;
                 cmsgptr->cmsg_level = IPPROTO_IPV6;
                 cmsgptr->cmsg_type = IPV6_PKTINFO;
diff --git a/libbb/vfork_daemon_rexec.c b/libbb/vfork_daemon_rexec.c
index f488f8e0c..766a89e5f 100644
--- a/libbb/vfork_daemon_rexec.c
+++ b/libbb/vfork_daemon_rexec.c
@@ -70,7 +70,8 @@ pid_t FAST_FUNC xspawn(char **argv)
         return pid;
 }
 
-#if ENABLE_FEATURE_PREFER_APPLETS
+#if ENABLE_FEATURE_PREFER_APPLETS \
+ || ENABLE_FEATURE_SH_NOFORK
 static jmp_buf die_jmp;
 static void jump(void)
 {
@@ -176,7 +177,7 @@ int FAST_FUNC run_nofork_applet(int applet_no, char **argv)
 
         return rc & 0xff; /* don't confuse people with "exitcodes" >255 */
 }
-#endif /* FEATURE_PREFER_APPLETS */
+#endif /* FEATURE_PREFER_APPLETS || FEATURE_SH_NOFORK */
 
 int FAST_FUNC spawn_and_wait(char **argv)
 {
diff --git a/libbb/xconnect.c b/libbb/xconnect.c
index c318af419..ee54898e3 100644
--- a/libbb/xconnect.c
+++ b/libbb/xconnect.c
@@ -500,12 +500,15 @@ char* FAST_FUNC xmalloc_sockaddr2hostonly_noport(const struct sockaddr *sa)
 {
         return sockaddr2str(sa, NI_NAMEREQD | IGNORE_PORT);
 }
+#ifndef NI_NUMERICSCOPE
+# define NI_NUMERICSCOPE 0
+#endif
 char* FAST_FUNC xmalloc_sockaddr2dotted(const struct sockaddr *sa)
 {
-        return sockaddr2str(sa, NI_NUMERICHOST);
+        return sockaddr2str(sa, NI_NUMERICHOST | NI_NUMERICSCOPE);
 }
 
 char* FAST_FUNC xmalloc_sockaddr2dotted_noport(const struct sockaddr *sa)
 {
-        return sockaddr2str(sa, NI_NUMERICHOST | IGNORE_PORT);
+        return sockaddr2str(sa, NI_NUMERICHOST | NI_NUMERICSCOPE | IGNORE_PORT);
 }
diff --git a/libbb/xfuncs_printf.c b/libbb/xfuncs_printf.c
index e9222f690..1b11caf6b 100644
--- a/libbb/xfuncs_printf.c
+++ b/libbb/xfuncs_printf.c
@@ -235,8 +235,16 @@ void FAST_FUNC xwrite(int fd, const void *buf, size_t count)
 {
         if (count) {
                 ssize_t size = full_write(fd, buf, count);
-                if ((size_t)size != count)
-                        bb_error_msg_and_die("short write");
+                if ((size_t)size != count) {
+                        /*
+                         * Two cases: write error immediately;
+                         * or some writes succeeded, then we hit an error.
+                         * In either case, errno is set.
+                         */
+                        bb_perror_msg_and_die(
+                                size >= 0 ? "short write" : "write error"
+                        );
+                }
         }
 }
 void FAST_FUNC xwrite_str(int fd, const char *str)