Merge branch 'busybox' into mergemerge

6 files changed, 154 insertions, 74 deletions

diff --git a/libbb/Config.src b/libbb/Config.src
index ed6521c33..eff327c2a 100644
--- a/libbb/Config.src
+++ b/libbb/Config.src
@@ -192,8 +192,8 @@ config FEATURE_EDITING_VI
 config FEATURE_EDITING_HISTORY
         int "History size"
         # Don't allow way too big values here, code uses fixed "char *history[N]" struct member
-        range 0 9999
-        default 255
+        range 0 2000
+        default 200
         depends on FEATURE_EDITING
         help
         Specify command history size (0 - disable).
diff --git a/libbb/const_hack.c b/libbb/const_hack.c
index 75163fede..1d175481b 100644
--- a/libbb/const_hack.c
+++ b/libbb/const_hack.c
@@ -9,18 +9,27 @@
 #include "libbb.h"
 
 #if defined(__clang_major__) && __clang_major__ >= 9
-void FAST_FUNC XZALLOC_CONST_PTR(const void *pptr, size_t size)
+/* Clang/llvm drops assignment to "constant" storage. Silently.
+ * Needs serious convincing to not eliminate the store.
+ */
+static ALWAYS_INLINE void* not_const_pp(const void *p)
 {
-        ASSIGN_CONST_PTR(pptr, xzalloc(size));
+        void *pp;
+        asm volatile (
+                "# forget that p points to const"
+                : /*outputs*/ "=r" (pp)
+                : /*inputs*/ "0" (p)
+        );
+        return pp;
 }
-
-# if ENABLE_PLATFORM_MINGW32
-void FAST_FUNC ASSIGN_CONST_PTR(const void *pptr, const void *v)
+void FAST_FUNC ASSIGN_CONST_PTR(const void *pptr, void *v)
+{
+        *(void**)not_const_pp(pptr) = v;
+        barrier();
+}
+void FAST_FUNC XZALLOC_CONST_PTR(const void *pptr, size_t size)
 {
-        do {
-                *(void**)not_const_pp(pptr) = (void*)(v);
-                barrier();
-        } while (0);
+        *(void**)not_const_pp(pptr) = xzalloc(size);
+        barrier();
 }
-# endif
 #endif
diff --git a/libbb/dump.c b/libbb/dump.c
index aa57eca8c..b2abe85af 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -703,15 +703,21 @@ static NOINLINE void display(priv_dumper_t* dumper)
                                                         conv_u(pr, bp);
                                                         break;
                                                 case F_UINT: {
+                                                        union {
+                                                                uint16_t uval16;
+                                                                uint32_t uval32;
+                                                        } u;
                                                         unsigned value = (unsigned char)*bp;
                                                         switch (pr->bcnt) {
                                                         case 1:
                                                                 break;
                                                         case 2:
-                                                                move_from_unaligned16(value, bp);
+                                                                move_from_unaligned16(u.uval16, bp);
+                                                                value = u.uval16;
                                                                 break;
                                                         case 4:
-                                                                move_from_unaligned32(value, bp);
+                                                                move_from_unaligned32(u.uval32, bp);
+                                                                value = u.uval32;
                                                                 break;
                                                         /* case 8: no users yet */
                                                         }
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index 8e2b37853..c8a0f37fe 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -457,7 +457,7 @@ static void put_cur_glyph_and_inc_cursor(void)
                  * have automargin (IOW: it is moving cursor to next line
                  * by itself (which is wrong for VT-10x terminals)),
                  * this will break things: there will be one extra empty line */
-                puts("\r"); /* + implicit '\n' */
+                fputs("\r\n", stderr);
 #else
                 /* VT-10x terminals don't wrap cursor to next line when last char
                  * on the line is printed - cursor stays "over" this char.
@@ -1302,9 +1302,10 @@ static void showfiles(void)
                         );
                 }
                 if (ENABLE_UNICODE_SUPPORT)
-                        puts(printable_string(matches[n]));
+                        fputs(printable_string(matches[n]), stderr);
                 else
-                        puts(matches[n]);
+                        fputs(matches[n], stderr);
+                bb_putchar_stderr('\n');
         }
 }
 
@@ -1595,8 +1596,8 @@ unsigned FAST_FUNC size_from_HISTFILESIZE(const char *hp)
 # endif
         if (hp) {
                 size = atoi(hp);
-                if (size <= 0)
-                        return 1;
+                if (size < 0)
+                        return 0;
                 if (size > MAX_HISTORY)
                         return MAX_HISTORY;
         }
@@ -1690,18 +1691,21 @@ static void load_history(line_input_t *st_parm)
         /* NB: do not trash old history if file can't be opened */
 
         fp = fopen_for_read(st_parm->hist_file);
-        if (fp) {
-                /* clean up old history */
-                for (idx = st_parm->cnt_history; idx > 0;) {
-                        idx--;
-                        free(st_parm->history[idx]);
-                        st_parm->history[idx] = NULL;
-                }
+        if (!fp)
+                return;
+
+        /* clean up old history */
+        for (idx = st_parm->cnt_history; idx > 0;) {
+                idx--;
+                free(st_parm->history[idx]);
+                st_parm->history[idx] = NULL;
+        }
 
-                /* fill temp_h[], retaining only last MAX_HISTORY lines */
-                memset(temp_h, 0, sizeof(temp_h));
-                idx = 0;
-                st_parm->cnt_history_in_file = 0;
+        /* fill temp_h[], retaining only last max_history lines */
+        memset(temp_h, 0, sizeof(temp_h));
+        idx = 0;
+        st_parm->cnt_history_in_file = 0;
+        if (st_parm->max_history != 0) {
                 while ((line = xmalloc_fgetline(fp)) != NULL) {
                         if (line[0] == '\0') {
                                 free(line);
@@ -1714,34 +1718,34 @@ static void load_history(line_input_t *st_parm)
                         if (idx == st_parm->max_history)
                                 idx = 0;
                 }
-                fclose(fp);
-
-                /* find first non-NULL temp_h[], if any */
-                if (st_parm->cnt_history_in_file) {
-                        while (temp_h[idx] == NULL) {
-                                idx++;
-                                if (idx == st_parm->max_history)
-                                        idx = 0;
-                        }
-                }
+        }
+        fclose(fp);
 
-                /* copy temp_h[] to st_parm->history[] */
-                for (i = 0; i < st_parm->max_history;) {
-                        line = temp_h[idx];
-                        if (!line)
-                                break;
+        /* find first non-NULL temp_h[], if any */
+        if (st_parm->cnt_history_in_file != 0) {
+                while (temp_h[idx] == NULL) {
                         idx++;
                         if (idx == st_parm->max_history)
                                 idx = 0;
-                        line_len = strlen(line);
-                        if (line_len >= MAX_LINELEN)
-                                line[MAX_LINELEN-1] = '\0';
-                        st_parm->history[i++] = line;
                 }
-                st_parm->cnt_history = i;
-                if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT)
-                        st_parm->cnt_history_in_file = i;
         }
+
+        /* copy temp_h[] to st_parm->history[] */
+        for (i = 0; i < st_parm->max_history;) {
+                line = temp_h[idx];
+                if (!line)
+                        break;
+                idx++;
+                if (idx == st_parm->max_history)
+                        idx = 0;
+                line_len = strlen(line);
+                if (line_len >= MAX_LINELEN)
+                        line[MAX_LINELEN-1] = '\0';
+                st_parm->history[i++] = line;
+        }
+        st_parm->cnt_history = i;
+        if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT)
+                st_parm->cnt_history_in_file = i;
 }
 
 #  if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
@@ -1749,17 +1753,27 @@ void FAST_FUNC save_history(line_input_t *st)
 {
         FILE *fp;
 
-        if (!st || !st->hist_file)
+        /* bash compat: HISTFILE="" disables history saving */
+        if (!st || !st->hist_file || !state->hist_file[0])
                 return;
         if (st->cnt_history <= st->cnt_history_in_file)
-                return;
+                return; /* no new entries were added */
+        /* note: if st->max_history is 0, we do not abort: we truncate the history to 0 lines */
 
-        fp = fopen(st->hist_file, "a");
+        fp = fopen(st->hist_file, (st->max_history == 0 ? "w" : "a"));
         if (fp) {
                 int i, fd;
                 char *new_name;
                 line_input_t *st_temp;
 
+                /* max_history==0 needs special-casing in general code,
+                 * just handle it in a simpler way: */
+                if (st->max_history == 0) {
+                        /* fopen("w") already truncated it */
+                        fclose(fp);
+                        return;
+                }
+
                 for (i = st->cnt_history_in_file; i < st->cnt_history; i++)
                         fprintf(fp, "%s\n", st->history[i]);
                 fclose(fp);
@@ -1769,6 +1783,8 @@ void FAST_FUNC save_history(line_input_t *st)
                 st_temp = new_line_input_t(st->flags);
                 st_temp->hist_file = st->hist_file;
                 st_temp->max_history = st->max_history;
+                /* load no more than max_history last lines */
+                /* (in unlikely case that file disappeared, st_temp gets empty history) */
                 load_history(st_temp);
 
                 /* write out temp file and replace hist_file atomically */
@@ -1792,13 +1808,13 @@ static void save_history(char *str)
         int fd;
         int len, len2;
 
-        if (!state->hist_file)
+        /* bash compat: HISTFILE="" disables history saving */
+        if (!state->hist_file || !state->hist_file[0])
                 return;
 
         fd = open(state->hist_file, O_WRONLY | O_CREAT | O_APPEND, 0600);
         if (fd < 0)
                 return;
-        xlseek(fd, 0, SEEK_END); /* paranoia */
         len = strlen(str);
         str[len] = '\n'; /* we (try to) do atomic write */
         len2 = full_write(fd, str, len + 1);
@@ -1853,13 +1869,10 @@ static void remember_in_history(char *str)
         if (str[0] == '\0')
                 return;
         i = state->cnt_history;
-        /* Don't save dupes */
-        if (i && strcmp(state->history[i-1], str) == 0)
+        /* Don't save dups */
+        if (i != 0 && strcmp(state->history[i-1], str) == 0)
                 return;
 
-        free(state->history[state->max_history]); /* redundant, paranoia */
-        state->history[state->max_history] = NULL; /* redundant, paranoia */
-
         /* If history[] is full, remove the oldest command */
         /* we need to keep history[state->max_history] empty, hence >=, not > */
         if (i >= state->max_history) {
@@ -1872,7 +1885,7 @@ static void remember_in_history(char *str)
                         state->cnt_history_in_file--;
 # endif
         }
-        /* i <= state->max_history-1 */
+        /* i < state->max_history */
         state->history[i++] = xstrdup(str);
         /* i <= state->max_history */
         state->cur_history = i;
@@ -2388,7 +2401,6 @@ static int lineedit_read_key(char *read_key_buffer, int timeout)
                                 errno = EINTR;
                                 return -1;
                         }
-//FIXME: still races here with signals, but small window to poll() inside read_key
                         IF_FEATURE_EDITING_WINCH(S.ok_to_redraw = 1;)
                         /* errno = 0; - read_key does this itself */
                         ic = read_key(STDIN_FILENO, read_key_buffer, timeout);
diff --git a/libbb/poll_with_signals.c b/libbb/poll_with_signals.c
new file mode 100644
index 000000000..d3c005418
--- /dev/null
+++ b/libbb/poll_with_signals.c
@@ -0,0 +1,48 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Utility routines.
+ *
+ * Copyright (C) 2025 Denys Vlasenko <vda.linux@googlemail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-$(CONFIG_PLATFORM_POSIX) += poll_with_signals.o
+
+#include "libbb.h"
+
+/* Shells, for example, need their line input and "read" builtin
+ * to be interruptible, and the naive handling of it a-la:
+ *      if (bb_got_signal) {
+ *              errno = EINTR;
+ *              return -1;
+ *      }
+ *      poll(pfd, 1, -1); // signal here would set EINTR
+ * is racy.
+ * This is a bit heavy-handed, but safe wrt races:
+ */
+int FAST_FUNC check_got_signal_and_poll(struct pollfd pfd[1], int timeout)
+{
+        int n;
+        struct timespec tv;
+        sigset_t orig_mask;
+
+        if (bb_got_signal) /* optimization */
+                goto eintr;
+
+        if (timeout >= 0) {
+                tv.tv_sec = timeout / 1000;
+                tv.tv_nsec = (timeout % 1000) * 1000000;
+        }
+        /* test bb_got_signal, then poll(), atomically wrt signals */
+        sigfillset(&orig_mask);
+        sigprocmask2(SIG_BLOCK, &orig_mask);
+        if (bb_got_signal) {
+                sigprocmask2(SIG_SETMASK, &orig_mask);
+ eintr:
+                errno = EINTR; /* inform the caller that we got a signal */
+                return -1;
+        }
+        n = ppoll(pfd, 1, timeout >= 0 ? &tv : NULL, &orig_mask);
+        sigprocmask2(SIG_SETMASK, &orig_mask);
+        return n;
+}
diff --git a/libbb/read_key.c b/libbb/read_key.c
index 54886cc9c..2414105ee 100644
--- a/libbb/read_key.c
+++ b/libbb/read_key.c
@@ -11,7 +11,7 @@
 
 int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
 {
-        struct pollfd pfd;
+        struct pollfd pfd[1];
         const char *seq;
         int n;
 
@@ -117,8 +117,8 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                 return windows_read_key(fd, buffer, timeout);
 #endif
 
-        pfd.fd = fd;
-        pfd.events = POLLIN;
+        pfd->fd = fd;
+        pfd->events = POLLIN;
 
         buffer++; /* saved chars counter is in buffer[-1] now */
 
@@ -126,12 +126,16 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
         errno = 0;
         n = (unsigned char)buffer[-1];
         if (n == 0) {
-                /* If no data, wait for input.
-                 * If requested, wait TIMEOUT ms. TIMEOUT = -1 is useful
-                 * if fd can be in non-blocking mode.
-                 */
+                /* No data. Wait for input. */
+
+                /* timeout == -2 means "do not poll". Else: */
                 if (timeout >= -1) {
-                        n = poll(&pfd, 1, timeout);
+                        /* We must poll even if timeout == -1:
+                         * we want to be interrupted if signal arrives,
+                         * regardless of SA_RESTART-ness of that signal!
+                         */
+                        /* test bb_got_signal, then poll(), atomically wrt signals */
+                        n = check_got_signal_and_poll(pfd, timeout);
                         if (n < 0 && errno == EINTR)
                                 return n;
                         if (n == 0) {
@@ -140,6 +144,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                                 return -1;
                         }
                 }
+
                 /* It is tempting to read more than one byte here,
                  * but it breaks pasting. Example: at shell prompt,
                  * user presses "c","a","t" and then pastes "\nline\n".
@@ -178,7 +183,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                                  * so if we block for long it's not really an escape sequence.
                                  * Timeout is needed to reconnect escape sequences
                                  * split up by transmission over a serial console. */
-                                if (safe_poll(&pfd, 1, 50) == 0) {
+                                if (safe_poll(pfd, 1, 50) == 0) {
                                         /* No more data!
                                          * Array is sorted from shortest to longest,
                                          * we can't match anything later in array -
@@ -227,7 +232,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
          * n = bytes read. Try to read more until we time out.
          */
         while (n < KEYCODE_BUFFER_SIZE-1) { /* 1 for count byte at buffer[-1] */
-                if (safe_poll(&pfd, 1, 50) == 0) {
+                if (safe_poll(pfd, 1, 50) == 0) {
                         /* No more data! */
                         break;
                 }