Merge branch 'busybox' into merge

6 files changed, 77 insertions, 41 deletions

diff --git a/editors/ed.c b/editors/ed.c
index 209ce9942..4a84f7433 100644
--- a/editors/ed.c
+++ b/editors/ed.c
@@ -720,7 +720,7 @@ static void subCommand(const char *cmd, int num1, int num2)
                 if (deltaLen <= 0) {
                         memcpy(&lp->data[offset], newStr, newLen);
                         if (deltaLen) {
-                                memcpy(&lp->data[offset + newLen],
+                                memmove(&lp->data[offset + newLen],
                                         &lp->data[offset + oldLen],
                                         lp->len - offset - oldLen);
 
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index bee423553..c4f0c65f1 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -2300,7 +2300,8 @@ static int lineedit_read_key(char *read_key_buffer, int timeout)
                  * "\xff\n",pause,"ls\n" invalid and thus won't lose "ls".
                  *
                  * If LI_INTERRUPTIBLE, return -1 if got EINTR in poll()
-                 * inside read_key, or if bb_got_signal != 0 (IOW: if signal
+                 * inside read_key and bb_got_signal became != 0,
+                 * or if bb_got_signal != 0 (IOW: if signal
                  * arrived before poll() is reached).
                  *
                  * Note: read_key sets errno to 0 on success.
@@ -2317,14 +2318,16 @@ static int lineedit_read_key(char *read_key_buffer, int timeout)
                         IF_FEATURE_EDITING_WINCH(S.ok_to_redraw = 0;)
                         if (errno != EINTR)
                                 break;
+                        /* It was EINTR. Repeat read_key() unless... */
                         if (state->flags & LI_INTERRUPTIBLE) {
-                                /* LI_INTERRUPTIBLE bails out on EINTR,
-                                 * but nothing really guarantees that bb_got_signal
-                                 * is nonzero. Follow the least surprise principle:
+                                /* LI_INTERRUPTIBLE bails out on EINTR
+                                 * if bb_got_signal became nonzero.
+                                 * (It may stay zero: for example, our SIGWINCH
+                                 * handler does not set it. This is used for signals
+                                 * which should not interrupt line editing).
                                  */
-                                if (bb_got_signal == 0)
-                                        bb_got_signal = 255;
-                                goto ret;
+                                if (bb_got_signal != 0)
+                                        goto ret; /* will return -1 */
                         }
                 }
 
diff --git a/networking/ntpd.c b/networking/ntpd.c
index 204e1d7c2..c7519b8fb 100644
--- a/networking/ntpd.c
+++ b/networking/ntpd.c
@@ -551,20 +551,21 @@ gettime1900d(void)
         return G.cur_time;
 }
 
-static void
-d_to_tv(struct timeval *tv, double d)
-{
-        tv->tv_sec = (long)d;
-        tv->tv_usec = (d - tv->tv_sec) * 1000000;
-}
-
 static NOINLINE double
 lfp_to_d(l_fixedpt_t lfp)
 {
         double ret;
         lfp.int_partl = ntohl(lfp.int_partl);
         lfp.fractionl = ntohl(lfp.fractionl);
-        ret = (double)lfp.int_partl + ((double)lfp.fractionl / UINT_MAX);
+        ret = (double)lfp.int_partl + ((double)lfp.fractionl / (1ULL << 32));
+        /*
+         * Shift timestamps before 1970 to the second NTP era (2036-2106):
+         * int_partl value of OFFSET_1900_1970 (2208988800) is interpreted as
+         * the start of year 1970 and it is the minimal representable time,
+         * all values form the sequence 2208988800..0xffffffff,0..2208988799.
+         */
+        if (lfp.int_partl < OFFSET_1900_1970)
+                ret += (double)(1ULL << 32); /* because int_partl is 32-bit wide */
         return ret;
 }
 static NOINLINE double
@@ -573,7 +574,7 @@ sfp_to_d(s_fixedpt_t sfp)
         double ret;
         sfp.int_parts = ntohs(sfp.int_parts);
         sfp.fractions = ntohs(sfp.fractions);
-        ret = (double)sfp.int_parts + ((double)sfp.fractions / USHRT_MAX);
+        ret = (double)sfp.int_parts + ((double)sfp.fractions / (1 << 16));
         return ret;
 }
 #if ENABLE_FEATURE_NTPD_SERVER
@@ -582,8 +583,8 @@ d_to_lfp(l_fixedpt_t *lfp, double d)
 {
         uint32_t intl;
         uint32_t frac;
-        intl = (uint32_t)d;
-        frac = (uint32_t)((d - intl) * UINT_MAX);
+        intl = (uint32_t)(time_t)d;
+        frac = (uint32_t)((d - (time_t)d) * 0xffffffff);
         lfp->int_partl = htonl(intl);
         lfp->fractionl = htonl(frac);
 }
@@ -593,7 +594,7 @@ d_to_sfp(s_fixedpt_t *sfp, double d)
         uint16_t ints;
         uint16_t frac;
         ints = (uint16_t)d;
-        frac = (uint16_t)((d - ints) * USHRT_MAX);
+        frac = (uint16_t)((d - ints) * 0xffff);
         sfp->int_parts = htons(ints);
         sfp->fractions = htons(frac);
 }
@@ -1036,8 +1037,17 @@ step_time(double offset)
         time_t tval;
 
         xgettimeofday(&tvc);
+        /* This code adds floating point value on the order of 1.0
+         * to a value of ~4 billion (as of years 203x).
+         * With 52-bit mantissa, "only" 20 bits of offset's precision
+         * are used (~1 microsecond), the rest is lost.
+         * Some 200 billion years later, when tvc.tv_sec would have
+         * 63 significant bits, the precision loss would be catastrophic,
+         * a more complex code would be needed.
+         */
         dtime = tvc.tv_sec + (1.0e-6 * tvc.tv_usec) + offset;
-        d_to_tv(&tvn, dtime);
+        tvn.tv_sec = (time_t)dtime;
+        tvn.tv_usec = (dtime - tvn.tv_sec) * 1000000;
         xsettimeofday(&tvn);
 
         VERB2 {
diff --git a/procps/nmeter.c b/procps/nmeter.c
index 68e6f3325..e52c868df 100644
--- a/procps/nmeter.c
+++ b/procps/nmeter.c
@@ -59,9 +59,9 @@
 
 typedef unsigned long long ullong;
 
-enum {  /* Preferably use powers of 2 */
+enum {
         PROC_MIN_FILE_SIZE = 256,
-        PROC_MAX_FILE_SIZE = 16 * 1024,
+        PROC_MAX_FILE_SIZE = 64 * 1024, /* 16k was a bit too small for a 128-CPU machine */
 };
 
 typedef struct proc_file {
@@ -176,7 +176,10 @@ static void readfile_z(proc_file *pf, const char* fname)
         close(fd);
         if (rdsz > 0) {
                 if (rdsz == sz-1 && sz < PROC_MAX_FILE_SIZE) {
-                        sz *= 2;
+                        if (sz < 4 * 1024)
+                                sz *= 2;
+                        else
+                                sz += 4 * 1024;
                         buf = xrealloc(buf, sz);
                         goto again;
                 }
diff --git a/shell/ash.c b/shell/ash.c
index 87190c453..94eb49d79 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -11769,7 +11769,8 @@ preadfd(void)
  again:
                 /* For shell, LI_INTERRUPTIBLE is set:
                  * read_line_input will abort on either
-                 * getting EINTR in poll(), or if it sees bb_got_signal != 0
+                 * getting EINTR in poll() and bb_got_signal became != 0,
+                 * or if it sees bb_got_signal != 0
                  * (IOW: if signal arrives before poll() is reached).
                  * Interactive testcases:
                  * (while kill -INT $$; do sleep 1; done) &
diff --git a/shell/hush.c b/shell/hush.c
index d111f0cc5..e6be70078 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -1829,7 +1829,13 @@ static void restore_G_args(save_arg_t *sv, char **argv)
  * SIGQUIT: ignore
  * SIGTERM (interactive): ignore
  * SIGHUP (interactive):
- *    send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit
+ *    Send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit.
+ *    Kernel would do this for us ("orphaned process group" handling
+ *    according to POSIX) if we are a session leader and thus our death
+ *    frees the controlling tty, but to be bash-compatible, we also do it
+ *    for every interactive shell's death by SIGHUP.
+ *    (Also, we need to restore tty pgrp, otherwise e.g. Midnight Commander
+ *    backgrounds when hush started from it gets killed by SIGHUP).
  * SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore
  *    Note that ^Z is handled not by trapping SIGTSTP, but by seeing
  *    that all pipe members are stopped. Try this in bash:
@@ -1946,7 +1952,12 @@ static void record_pending_signo(int sig)
 {
         sigaddset(&G.pending_set, sig);
 #if ENABLE_FEATURE_EDITING
-        bb_got_signal = sig; /* for read_line_input: "we got a signal" */
+        if (sig != SIGCHLD
+         || (G_traps && G_traps[SIGCHLD] && G_traps[SIGCHLD][0])
+         /* ^^^ if SIGCHLD, interrupt line reading only if it has a trap */
+        ) {
+                bb_got_signal = sig; /* for read_line_input: "we got a signal" */
+        }
 #endif
 #if ENABLE_HUSH_FAST
         if (sig == SIGCHLD) {
@@ -2173,20 +2184,27 @@ static int check_and_run_traps(void)
                         break;
 #if ENABLE_HUSH_JOB
                 case SIGHUP: {
-//TODO: why are we doing this? ash and dash don't do this,
-//they have no handler for SIGHUP at all,
-//they rely on kernel to send SIGHUP+SIGCONT to orphaned process groups
-                        struct pipe *job;
-                        debug_printf_exec("%s: sig:%d default SIGHUP handler\n", __func__, sig);
-                        /* bash is observed to signal whole process groups,
-                         * not individual processes */
-                        for (job = G.job_list; job; job = job->next) {
-                                if (job->pgrp <= 0)
-                                        continue;
-                                debug_printf_exec("HUPing pgrp %d\n", job->pgrp);
-                                if (kill(- job->pgrp, SIGHUP) == 0)
-                                        kill(- job->pgrp, SIGCONT);
+                        /* if (G_interactive_fd) - no need to check, the handler
+                         * is only installed if we *are* interactive */
+                        {
+                                /* bash compat: "Before exiting, an interactive
+                                 * shell resends the SIGHUP to all jobs, running
+                                 * or stopped.  Stopped jobs are sent SIGCONT
+                                 * to ensure that they receive the SIGHUP."
+                                 */
+                                struct pipe *job;
+                                debug_printf_exec("%s: sig:%d default SIGHUP handler\n", __func__, sig);
+                                /* bash is observed to signal whole process groups,
+                                 * not individual processes */
+                                for (job = G.job_list; job; job = job->next) {
+                                        if (job->pgrp <= 0)
+                                                continue;
+                                        debug_printf_exec("HUPing pgrp %d\n", job->pgrp);
+                                        if (kill(- job->pgrp, SIGHUP) == 0)
+                                                kill(- job->pgrp, SIGCONT);
+                                }
                         }
+                        /* this restores tty pgrp, then kills us with SIGHUP */
                         sigexit(SIGHUP);
                 }
 #endif
@@ -2669,7 +2687,8 @@ static int get_user_input(struct in_str *i)
                 } else {
                         /* For shell, LI_INTERRUPTIBLE is set:
                          * read_line_input will abort on either
-                         * getting EINTR in poll(), or if it sees bb_got_signal != 0
+                         * getting EINTR in poll() and bb_got_signal became != 0,
+                         * or if it sees bb_got_signal != 0
                          * (IOW: if signal arrives before poll() is reached).
                          * Interactive testcases:
                          * (while kill -INT $$; do sleep 1; done) &