Merge branch 'busybox' into merge

8 files changed, 253 insertions, 174 deletions

diff --git a/networking/Config.src b/networking/Config.src
index fbad7ecb2..e56646917 100644
--- a/networking/Config.src
+++ b/networking/Config.src
@@ -134,6 +134,13 @@ config FEATURE_FTPD_ACCEPT_BROKEN_LIST
           it increases the code size by ~40 bytes.
           Most other ftp servers seem to behave similar to this.
 
+config FEATURE_FTP_AUTHENTICATION
+        bool "Enable authentication"
+        default y
+        depends on FTPD
+        help
+          Enable basic system login as seen in telnet etc.
+
 config FTPGET
         bool "ftpget"
         default y
diff --git a/networking/ftpd.c b/networking/ftpd.c
index 2d2a3a44c..6adcb1dee 100644
--- a/networking/ftpd.c
+++ b/networking/ftpd.c
@@ -622,7 +622,7 @@ popen_ls(const char *opt)
         pid_t pid;
 
         argv[0] = "ftpd";
-        argv[1] = opt; /* "-l" or "-1" */
+        argv[1] = opt; /* "-lA" or "-1A" */
         argv[2] = "--";
         argv[3] = G.ftp_arg;
         argv[4] = NULL;
@@ -699,7 +699,7 @@ handle_dir_common(int opts)
         if (!(opts & USE_CTRL_CONN) && !port_or_pasv_was_seen())
                 return; /* port_or_pasv_was_seen emitted error response */
 
-        ls_fd = popen_ls((opts & LONG_LISTING) ? "-l" : "-1");
+        ls_fd = popen_ls((opts & LONG_LISTING) ? "-lA" : "-1A");
         ls_fp = xfdopen_for_read(ls_fd);
 /* FIXME: filenames with embedded newlines are mishandled */
 
@@ -1102,10 +1102,11 @@ enum {
 #if !BB_MMU
         OPT_l = (1 << 0),
         OPT_1 = (1 << 1),
+        OPT_A = (1 << 2),
 #endif
-        OPT_v = (1 << ((!BB_MMU) * 2 + 0)),
-        OPT_S = (1 << ((!BB_MMU) * 2 + 1)),
-        OPT_w = (1 << ((!BB_MMU) * 2 + 2)) * ENABLE_FEATURE_FTP_WRITE,
+        OPT_v = (1 << ((!BB_MMU) * 3 + 0)),
+        OPT_S = (1 << ((!BB_MMU) * 3 + 1)),
+        OPT_w = (1 << ((!BB_MMU) * 3 + 2)) * ENABLE_FEATURE_FTP_WRITE,
 };
 
 int ftpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
@@ -1126,12 +1127,11 @@ int ftpd_main(int argc UNUSED_PARAM, char **argv)
         G.timeout = 2 * 60;
         opt_complementary = "t+:T+:vv:SS";
 #if BB_MMU
-        opts = getopt32(argv,   "vS" IF_FEATURE_FTP_WRITE("w") "t:T:", &G.timeout, &abs_timeout, &G.verbose, &verbose_S);
+        opts = getopt32(argv,    "vS" IF_FEATURE_FTP_WRITE("w") "t:T:", &G.timeout, &abs_timeout, &G.verbose, &verbose_S);
 #else
-        opts = getopt32(argv, "l1vS" IF_FEATURE_FTP_WRITE("w") "t:T:", &G.timeout, &abs_timeout, &G.verbose, &verbose_S);
+        opts = getopt32(argv, "l1AvS" IF_FEATURE_FTP_WRITE("w") "t:T:", &G.timeout, &abs_timeout, &G.verbose, &verbose_S);
         if (opts & (OPT_l|OPT_1)) {
                 /* Our secret backdoor to ls */
-/* TODO: pass -A? It shows dot files */
 /* TODO: pass --group-directories-first? would be nice, but ls doesn't do that yet */
                 if (fchdir(3) != 0)
                         _exit(127);
@@ -1172,18 +1172,6 @@ int ftpd_main(int argc UNUSED_PARAM, char **argv)
         if (logmode)
                 applet_name = xasprintf("%s[%u]", applet_name, (int)getpid());
 
-#if !BB_MMU
-        G.root_fd = -1;
-#endif
-        argv += optind;
-        if (argv[0]) {
-#if !BB_MMU
-                G.root_fd = xopen("/", O_RDONLY | O_DIRECTORY);
-                close_on_exec_on(G.root_fd);
-#endif
-                xchroot(argv[0]);
-        }
-
         //umask(077); - admin can set umask before starting us
 
         /* Signals. We'll always take -EPIPE rather than a rude signal, thanks */
@@ -1199,23 +1187,22 @@ int ftpd_main(int argc UNUSED_PARAM, char **argv)
         WRITE_OK(FTP_GREET);
         signal(SIGALRM, timeout_handler);
 
-#ifdef IF_WE_WANT_TO_REQUIRE_LOGIN
+#if ENABLE_FEATURE_FTP_AUTHENTICATION
         {
-                smallint user_was_specified = 0;
+                struct passwd *pw = NULL;
+
                 while (1) {
                         uint32_t cmdval = cmdio_get_cmd_and_arg();
 
                         if (cmdval == const_USER) {
-                                if (G.ftp_arg == NULL || strcasecmp(G.ftp_arg, "anonymous") != 0)
-                                        cmdio_write_raw(STR(FTP_LOGINERR)" Server is anonymous only\r\n");
-                                else {
-                                        user_was_specified = 1;
-                                        cmdio_write_raw(STR(FTP_GIVEPWORD)" Please specify the password\r\n");
-                                }
+                                pw = getpwnam(G.ftp_arg);
+                                cmdio_write_raw(STR(FTP_GIVEPWORD)" Please specify password\r\n");
                         } else if (cmdval == const_PASS) {
-                                if (user_was_specified)
-                                        break;
-                                cmdio_write_raw(STR(FTP_NEEDUSER)" Login with USER\r\n");
+                                if (check_password(pw, G.ftp_arg) > 0) {
+                                        break;  /* login success */
+                                }
+                                cmdio_write_raw(STR(FTP_LOGINERR)" Login failed\r\n");
+                                pw = NULL;
                         } else if (cmdval == const_QUIT) {
                                 WRITE_OK(FTP_GOODBYE);
                                 return 0;
@@ -1223,10 +1210,24 @@ int ftpd_main(int argc UNUSED_PARAM, char **argv)
                                 cmdio_write_raw(STR(FTP_LOGINERR)" Login with USER and PASS\r\n");
                         }
                 }
+                change_identity(pw);
         }
         WRITE_OK(FTP_LOGINOK);
 #endif
 
+        /* Do this after auth, else /etc/passwd is not accessible */
+#if !BB_MMU
+        G.root_fd = -1;
+#endif
+        argv += optind;
+        if (argv[0]) {
+#if !BB_MMU
+                G.root_fd = xopen("/", O_RDONLY | O_DIRECTORY);
+                close_on_exec_on(G.root_fd);
+#endif
+                xchroot(argv[0]);
+        }
+
         /* RFC-959 Section 5.1
          * The following commands and options MUST be supported by every
          * server-FTP and user-FTP, except in cases where the underlying
diff --git a/networking/ntpd.c b/networking/ntpd.c
index 59607ed23..2d4f076d9 100644
--- a/networking/ntpd.c
+++ b/networking/ntpd.c
@@ -29,7 +29,7 @@
  */
 
 //usage:#define ntpd_trivial_usage
-//usage:        "[-dnqNw"IF_FEATURE_NTPD_SERVER("l")"] [-S PROG] [-p PEER]..."
+//usage:        "[-dnqNw"IF_FEATURE_NTPD_SERVER("l -I IFACE")"] [-S PROG] [-p PEER]..."
 //usage:#define ntpd_full_usage "\n\n"
 //usage:       "NTP client/server\n"
 //usage:     "\n        -d      Verbose"
@@ -39,6 +39,7 @@
 //usage:     "\n        -w      Do not set time (only query peers), implies -n"
 //usage:        IF_FEATURE_NTPD_SERVER(
 //usage:     "\n        -l      Run as server on port 123"
+//usage:     "\n        -I IFACE Bind server to IFACE, implies -l"
 //usage:        )
 //usage:     "\n        -S PROG Run PROG after stepping time, stratum change, and every 11 mins"
 //usage:     "\n        -p PEER Obtain time from PEER (may be repeated)"
@@ -108,36 +109,44 @@
  *   datapoints after the step.
  */
 
-#define RETRY_INTERVAL     5    /* on error, retry in N secs */
-#define RESPONSE_INTERVAL 15    /* wait for reply up to N secs */
 #define INITIAL_SAMPLES    4    /* how many samples do we want for init */
 #define BAD_DELAY_GROWTH   4    /* drop packet if its delay grew by more than this */
 
-/* Clock discipline parameters and constants */
+#define RETRY_INTERVAL    32    /* on send/recv error, retry in N secs (need to be power of 2) */
+#define NOREPLY_INTERVAL 512    /* sent, but got no reply: cap next query by this many seconds */
+#define RESPONSE_INTERVAL 16    /* wait for reply up to N secs */
 
 /* Step threshold (sec). std ntpd uses 0.128.
- * Using exact power of 2 (1/8) results in smaller code */
+ * Using exact power of 2 (1/8) results in smaller code
+ */
 #define STEP_THRESHOLD  0.125
-#define WATCH_THRESHOLD 128     /* stepout threshold (sec). std ntpd uses 900 (11 mins (!)) */
+/* Stepout threshold (sec). std ntpd uses 900 (11 mins (!)) */
+#define WATCH_THRESHOLD 128
 /* NB: set WATCH_THRESHOLD to ~60 when debugging to save time) */
 //UNUSED: #define PANIC_THRESHOLD 1000    /* panic threshold (sec) */
 
+/*
+ * If we got |offset| > BIGOFF from a peer, cap next query interval
+ * for this peer by this many seconds:
+ */
+#define BIGOFF          (STEP_THRESHOLD * 8)
+#define BIGOFF_INTERVAL (1 << 7) /* 128 s */
+
 #define FREQ_TOLERANCE  0.000015 /* frequency tolerance (15 PPM) */
 #define BURSTPOLL       0       /* initial poll */
 #define MINPOLL         5       /* minimum poll interval. std ntpd uses 6 (6: 64 sec) */
-/* If we got largish offset from a peer, cap next query interval
- * for this peer by this many seconds:
- */
-#define BIGOFF_INTERVAL (1 << 6)
-/* If offset > discipline_jitter * POLLADJ_GATE, and poll interval is >= 2^BIGPOLL,
- * then it is decreased _at once_. (If < 2^BIGPOLL, it will be decreased _eventually_).
+/*
+ * If offset > discipline_jitter * POLLADJ_GATE, and poll interval is > 2^BIGPOLL,
+ * then it is decreased _at once_. (If <= 2^BIGPOLL, it will be decreased _eventually_).
  */
-#define BIGPOLL         10      /* 2^10 sec ~= 17 min */
+#define BIGPOLL         9       /* 2^9 sec ~= 8.5 min */
 #define MAXPOLL         12      /* maximum poll interval (12: 1.1h, 17: 36.4h). std ntpd uses 17 */
-/* Actively lower poll when we see such big offsets.
+/*
+ * Actively lower poll when we see such big offsets.
  * With STEP_THRESHOLD = 0.125, it means we try to sync more aggressively
- * if offset increases over ~0.04 sec */
-#define POLLDOWN_OFFSET (STEP_THRESHOLD / 3)
+ * if offset increases over ~0.04 sec
+ */
+//#define POLLDOWN_OFFSET (STEP_THRESHOLD / 3)
 #define MINDISP         0.01    /* minimum dispersion (sec) */
 #define MAXDISP         16      /* maximum dispersion (sec) */
 #define MAXSTRAT        16      /* maximum stratum (infinity metric) */
@@ -283,6 +292,7 @@ enum {
         OPT_p = (1 << 5),
         OPT_S = (1 << 6),
         OPT_l = (1 << 7) * ENABLE_FEATURE_NTPD_SERVER,
+        OPT_I = (1 << 8) * ENABLE_FEATURE_NTPD_SERVER,
         /* We hijack some bits for other purposes */
         OPT_qq = (1 << 31),
 };
@@ -301,6 +311,7 @@ struct globals {
         llist_t  *ntp_peers;
 #if ENABLE_FEATURE_NTPD_SERVER
         int      listen_fd;
+        char     *if_name;
 # define G_listen_fd (G.listen_fd)
 #else
 # define G_listen_fd (-1)
@@ -969,6 +980,16 @@ step_time(double offset)
         }
 }
 
+static void clamp_pollexp_and_set_MAXSTRAT(void)
+{
+        if (G.poll_exp < MINPOLL)
+                G.poll_exp = MINPOLL;
+        if (G.poll_exp > BIGPOLL)
+                G.poll_exp = BIGPOLL;
+        G.polladj_count = 0;
+        G.stratum = MAXSTRAT;
+}
+
 
 /*
  * Selection and clustering, and their helpers
@@ -1450,9 +1471,7 @@ update_local_clock(peer_t *p)
                         exit(0);
                 }
 
-                G.polladj_count = 0;
-                G.poll_exp = MINPOLL;
-                G.stratum = MAXSTRAT;
+                clamp_pollexp_and_set_MAXSTRAT();
 
                 run_script("step", offset);
 
@@ -1469,11 +1488,10 @@ update_local_clock(peer_t *p)
 
         } else { /* abs_offset <= STEP_THRESHOLD */
 
-                if (G.poll_exp < MINPOLL && G.initial_poll_complete) {
-                        VERB4 bb_error_msg("small offset:%+f, disabling burst mode", offset);
-                        G.polladj_count = 0;
-                        G.poll_exp = MINPOLL;
-                }
+                /* The ratio is calculated before jitter is updated to make
+                 * poll adjust code more sensitive to large offsets.
+                 */
+                G.offset_to_jitter_ratio = abs_offset / G.discipline_jitter;
 
                 /* Compute the clock jitter as the RMS of exponentially
                  * weighted offset differences. Used by the poll adjust code.
@@ -1481,6 +1499,8 @@ update_local_clock(peer_t *p)
                 etemp = SQUARE(G.discipline_jitter);
                 dtemp = SQUARE(offset - G.last_update_offset);
                 G.discipline_jitter = SQRT(etemp + (dtemp - etemp) / AVG);
+                if (G.discipline_jitter < G_precision_sec)
+                        G.discipline_jitter = G_precision_sec;
 
                 switch (G.discipline_state) {
                 case STATE_NSET:
@@ -1557,10 +1577,6 @@ update_local_clock(peer_t *p)
                 }
         }
 
-        if (G.discipline_jitter < G_precision_sec)
-                G.discipline_jitter = G_precision_sec;
-        G.offset_to_jitter_ratio = abs_offset / G.discipline_jitter;
-
         G.reftime = G.cur_time;
         G.ntp_status = p->lastpkt_status;
         G.refid = p->lastpkt_refid;
@@ -1657,30 +1673,53 @@ update_local_clock(peer_t *p)
  * (helpers first)
  */
 static unsigned
-retry_interval(void)
-{
-        /* Local problem, want to retry soon */
-        unsigned interval, r;
-        interval = RETRY_INTERVAL;
-        r = rand();
-        interval += r % (unsigned)(RETRY_INTERVAL / 4);
-        VERB4 bb_error_msg("chose retry interval:%u", interval);
-        return interval;
-}
-static unsigned
-poll_interval(int exponent)
+poll_interval(int upper_bound)
 {
         unsigned interval, r, mask;
-        exponent = G.poll_exp + exponent;
-        if (exponent < 0)
-                exponent = 0;
-        interval = 1 << exponent;
+        interval = 1 << G.poll_exp;
+        if (interval > upper_bound)
+                interval = upper_bound;
         mask = ((interval-1) >> 4) | 1;
         r = rand();
         interval += r & mask; /* ~ random(0..1) * interval/16 */
-        VERB4 bb_error_msg("chose poll interval:%u (poll_exp:%d exp:%d)", interval, G.poll_exp, exponent);
+        VERB4 bb_error_msg("chose poll interval:%u (poll_exp:%d)", interval, G.poll_exp);
         return interval;
 }
+static void
+adjust_poll(int count)
+{
+        G.polladj_count += count;
+        if (G.polladj_count > POLLADJ_LIMIT) {
+                G.polladj_count = 0;
+                if (G.poll_exp < MAXPOLL) {
+                        G.poll_exp++;
+                        VERB4 bb_error_msg("polladj: discipline_jitter:%f ++poll_exp=%d",
+                                        G.discipline_jitter, G.poll_exp);
+                }
+        } else if (G.polladj_count < -POLLADJ_LIMIT || (count < 0 && G.poll_exp > BIGPOLL)) {
+                G.polladj_count = 0;
+                if (G.poll_exp > MINPOLL) {
+                        llist_t *item;
+
+                        G.poll_exp--;
+                        /* Correct p->next_action_time in each peer
+                         * which waits for sending, so that they send earlier.
+                         * Old pp->next_action_time are on the order
+                         * of t + (1 << old_poll_exp) + small_random,
+                         * we simply need to subtract ~half of that.
+                         */
+                        for (item = G.ntp_peers; item != NULL; item = item->link) {
+                                peer_t *pp = (peer_t *) item->data;
+                                if (pp->p_fd < 0)
+                                        pp->next_action_time -= (1 << G.poll_exp);
+                        }
+                        VERB4 bb_error_msg("polladj: discipline_jitter:%f --poll_exp=%d",
+                                        G.discipline_jitter, G.poll_exp);
+                }
+        } else {
+                VERB4 bb_error_msg("polladj: count:%d", G.polladj_count);
+        }
+}
 static NOINLINE void
 recv_and_process_peer_pkt(peer_t *p)
 {
@@ -1700,19 +1739,23 @@ recv_and_process_peer_pkt(peer_t *p)
          * ntp servers reply from their *other IP*.
          * TODO: maybe we should check at least what we can: from.port == 123?
          */
+ recv_again:
         size = recv(p->p_fd, &msg, sizeof(msg), MSG_DONTWAIT);
-        if (size == -1) {
-                bb_perror_msg("recv(%s) error", p->p_dotted);
-                if (errno == EHOSTUNREACH || errno == EHOSTDOWN
-                 || errno == ENETUNREACH || errno == ENETDOWN
-                 || errno == ECONNREFUSED || errno == EADDRNOTAVAIL
-                 || errno == EAGAIN
-                ) {
-//TODO: always do this?
-                        interval = retry_interval();
-                        goto set_next_and_ret;
-                }
-                xfunc_die();
+        if (size < 0) {
+                if (errno == EINTR)
+                        /* Signal caught */
+                        goto recv_again;
+                if (errno == EAGAIN)
+                        /* There was no packet after all
+                         * (poll() returning POLLIN for a fd
+                         * is not a ironclad guarantee that data is there)
+                         */
+                        return;
+                /*
+                 * If you need a different handling for a specific
+                 * errno, always explain it in comment.
+                 */
+                bb_perror_msg_and_die("recv(%s) error", p->p_dotted);
         }
 
         if (size != NTP_MSGSIZE_NOAUTH && size != NTP_MSGSIZE) {
@@ -1738,10 +1781,15 @@ recv_and_process_peer_pkt(peer_t *p)
          || msg.m_stratum == 0
          || msg.m_stratum > NTP_MAXSTRATUM
         ) {
-// TODO: stratum 0 responses may have commands in 32-bit m_refid field:
-// "DENY", "RSTR" - peer does not like us at all
-// "RATE" - peer is overloaded, reduce polling freq
                 bb_error_msg("reply from %s: peer is unsynced", p->p_dotted);
+                /*
+                 * Stratum 0 responses may have commands in 32-bit m_refid field:
+                 * "DENY", "RSTR" - peer does not like us at all,
+                 * "RATE" - peer is overloaded, reduce polling freq.
+                 * If poll interval is small, increase it.
+                 */
+                if (G.poll_exp < BIGPOLL)
+                        goto increase_interval;
                 goto pick_normal_interval;
         }
 
@@ -1830,21 +1878,36 @@ recv_and_process_peer_pkt(peer_t *p)
         /* Muck with statictics and update the clock */
         filter_datapoints(p);
         q = select_and_cluster();
-        rc = -1;
+        rc = 0;
         if (q) {
-                rc = 0;
                 if (!(option_mask32 & OPT_w)) {
                         rc = update_local_clock(q);
+#if 0
+//Disabled this because there is a case where largish offsets
+//are unavoidable: if network round-trip delay is, say, ~0.6s,
+//error in offset estimation would be ~delay/2 ~= 0.3s.
+//Thus, offsets will be usually in -0.3...0.3s range.
+//In this case, this code would keep poll interval small,
+//but it won't be helping.
+//BIGOFF check below deals with a case of seeing multi-second offsets.
+
                         /* If drift is dangerously large, immediately
                          * drop poll interval one step down.
                          */
                         if (fabs(q->filter_offset) >= POLLDOWN_OFFSET) {
                                 VERB4 bb_error_msg("offset:%+f > POLLDOWN_OFFSET", q->filter_offset);
-                                goto poll_down;
+                                adjust_poll(-POLLADJ_LIMIT * 3);
+                                rc = 0;
                         }
+#endif
                 }
+        } else {
+                /* No peer selected.
+                 * If poll interval is small, increase it.
+                 */
+                if (G.poll_exp < BIGPOLL)
+                        goto increase_interval;
         }
-        /* else: no peer selected, rc = -1: we want to poll more often */
 
         if (rc != 0) {
                 /* Adjust the poll interval by comparing the current offset
@@ -1856,50 +1919,17 @@ recv_and_process_peer_pkt(peer_t *p)
                 if (rc > 0 && G.offset_to_jitter_ratio <= POLLADJ_GATE) {
                         /* was += G.poll_exp but it is a bit
                          * too optimistic for my taste at high poll_exp's */
-                        G.polladj_count += MINPOLL;
-                        if (G.polladj_count > POLLADJ_LIMIT) {
-                                G.polladj_count = 0;
-                                if (G.poll_exp < MAXPOLL) {
-                                        G.poll_exp++;
-                                        VERB4 bb_error_msg("polladj: discipline_jitter:%f ++poll_exp=%d",
-                                                        G.discipline_jitter, G.poll_exp);
-                                }
-                        } else {
-                                VERB4 bb_error_msg("polladj: incr:%d", G.polladj_count);
-                        }
+ increase_interval:
+                        adjust_poll(MINPOLL);
                 } else {
-                        G.polladj_count -= G.poll_exp * 2;
-                        if (G.polladj_count < -POLLADJ_LIMIT || G.poll_exp >= BIGPOLL) {
- poll_down:
-                                G.polladj_count = 0;
-                                if (G.poll_exp > MINPOLL) {
-                                        llist_t *item;
-
-                                        G.poll_exp--;
-                                        /* Correct p->next_action_time in each peer
-                                         * which waits for sending, so that they send earlier.
-                                         * Old pp->next_action_time are on the order
-                                         * of t + (1 << old_poll_exp) + small_random,
-                                         * we simply need to subtract ~half of that.
-                                         */
-                                        for (item = G.ntp_peers; item != NULL; item = item->link) {
-                                                peer_t *pp = (peer_t *) item->data;
-                                                if (pp->p_fd < 0)
-                                                        pp->next_action_time -= (1 << G.poll_exp);
-                                        }
-                                        VERB4 bb_error_msg("polladj: discipline_jitter:%f --poll_exp=%d",
-                                                        G.discipline_jitter, G.poll_exp);
-                                }
-                        } else {
-                                VERB4 bb_error_msg("polladj: decr:%d", G.polladj_count);
-                        }
+                        adjust_poll(-G.poll_exp * 2);
                 }
         }
 
         /* Decide when to send new query for this peer */
  pick_normal_interval:
-        interval = poll_interval(0);
-        if (fabs(offset) >= STEP_THRESHOLD * 8 && interval > BIGOFF_INTERVAL) {
+        interval = poll_interval(INT_MAX);
+        if (fabs(offset) >= BIGOFF && interval > BIGOFF_INTERVAL) {
                 /* If we are synced, offsets are less than STEP_THRESHOLD,
                  * or at the very least not much larger than it.
                  * Now we see a largish one.
@@ -1914,7 +1944,6 @@ recv_and_process_peer_pkt(peer_t *p)
                 interval = BIGOFF_INTERVAL;
         }
 
- set_next_and_ret:
         set_next(p, interval);
 }
 
@@ -2085,6 +2114,7 @@ static NOINLINE void ntp_init(char **argv)
                 bb_error_msg_and_die(bb_msg_you_must_be_root);
 
         /* Set some globals */
+        G.discipline_jitter = G_precision_sec;
         G.stratum = MAXSTRAT;
         if (BURSTPOLL != 0)
                 G.poll_exp = BURSTPOLL; /* speeds up initial sync */
@@ -2092,13 +2122,19 @@ static NOINLINE void ntp_init(char **argv)
 
         /* Parse options */
         peers = NULL;
-        opt_complementary = "dd:p::wn"; /* d: counter; p: list; -w implies -n */
+        opt_complementary = "dd:p::wn"         /* -d: counter; -p: list; -w implies -n */
+                IF_FEATURE_NTPD_SERVER(":Il"); /* -I implies -l */
         opts = getopt32(argv,
                         "nqNx" /* compat */
                         "wp:S:"IF_FEATURE_NTPD_SERVER("l") /* NOT compat */
+                        IF_FEATURE_NTPD_SERVER("I:") /* compat */
                         "d" /* compat */
                         "46aAbgL", /* compat, ignored */
-                        &peers, &G.script_name, &G.verbose);
+                        &peers,&G.script_name,
+#if ENABLE_FEATURE_NTPD_SERVER
+                        &G.if_name,
+#endif
+                        &G.verbose);
 
 //      if (opts & OPT_x) /* disable stepping, only slew is allowed */
 //              G.time_was_stepped = 1;
@@ -2130,18 +2166,22 @@ static NOINLINE void ntp_init(char **argv)
                 /* -l but no peers: "stratum 1 server" mode */
                 G.stratum = 1;
         }
-        if (!(opts & OPT_n)) {
-                bb_daemonize_or_rexec(DAEMON_DEVNULL_STDIO, argv);
-                logmode = LOGMODE_NONE;
-        }
 #if ENABLE_FEATURE_NTPD_SERVER
         G_listen_fd = -1;
         if (opts & OPT_l) {
                 G_listen_fd = create_and_bind_dgram_or_die(NULL, 123);
+                if (opts & OPT_I) {
+                        if (setsockopt_bindtodevice(G_listen_fd, G.if_name))
+                                xfunc_die();
+                }
                 socket_want_pktinfo(G_listen_fd);
                 setsockopt(G_listen_fd, IPPROTO_IP, IP_TOS, &const_IPTOS_LOWDELAY, sizeof(const_IPTOS_LOWDELAY));
         }
 #endif
+        if (!(opts & OPT_n)) {
+                bb_daemonize_or_rexec(DAEMON_DEVNULL_STDIO, argv);
+                logmode = LOGMODE_NONE;
+        }
         /* I hesitate to set -20 prio. -15 should be high enough for timekeeping */
         if (opts & OPT_N)
                 setpriority(PRIO_PROCESS, 0, -15);
@@ -2229,6 +2269,9 @@ int ntpd_main(int argc UNUSED_PARAM, char **argv)
                                 if (p->p_fd == -1) {
                                         /* Time to send new req */
                                         if (--cnt == 0) {
+                                                VERB4 bb_error_msg("disabling burst mode");
+                                                G.polladj_count = 0;
+                                                G.poll_exp = MINPOLL;
                                                 G.initial_poll_complete = 1;
                                         }
                                         send_query_to_peer(p);
@@ -2236,7 +2279,10 @@ int ntpd_main(int argc UNUSED_PARAM, char **argv)
                                         /* Timed out waiting for reply */
                                         close(p->p_fd);
                                         p->p_fd = -1;
-                                        timeout = poll_interval(-2); /* -2: try a bit sooner */
+                                        /* If poll interval is small, increase it */
+                                        if (G.poll_exp < BIGPOLL)
+                                                adjust_poll(MINPOLL);
+                                        timeout = poll_interval(NOREPLY_INTERVAL);
                                         bb_error_msg("timed out waiting for %s, reach 0x%02x, next query in %us",
                                                         p->p_dotted, p->reachable_bits, timeout);
                                         set_next(p, timeout);
@@ -2327,9 +2373,7 @@ int ntpd_main(int argc UNUSED_PARAM, char **argv)
                                         goto have_reachable_peer;
                         }
                         /* No peer responded for last 8 packets, panic */
-                        G.polladj_count = 0;
-                        G.poll_exp = MINPOLL;
-                        G.stratum = MAXSTRAT;
+                        clamp_pollexp_and_set_MAXSTRAT();
                         run_script("unsync", 0.0);
  have_reachable_peer: ;
                 }
diff --git a/networking/ping.c b/networking/ping.c
index 5e4771f5a..c475395e7 100644
--- a/networking/ping.c
+++ b/networking/ping.c
@@ -100,8 +100,9 @@
 //usage:     "\n                        (after all -c CNT packets are sent)"
 //usage:     "\n        -w SEC          Seconds until ping exits (default:infinite)"
 //usage:     "\n                        (can exit earlier with -c CNT)"
-//usage:     "\n        -q              Quiet, only displays output at start"
+//usage:     "\n        -q              Quiet, only display output at start"
 //usage:     "\n                        and when finished"
+//usage:     "\n        -p              Pattern to use for payload"
 //usage:
 //usage:# define ping6_trivial_usage
 //usage:       "[OPTIONS] HOST"
@@ -110,8 +111,9 @@
 //usage:     "\n        -c CNT          Send only CNT pings"
 //usage:     "\n        -s SIZE         Send SIZE data bytes in packets (default:56)"
 //usage:     "\n        -I IFACE/IP     Use interface or IP address as source"
-//usage:     "\n        -q              Quiet, only displays output at start"
+//usage:     "\n        -q              Quiet, only display output at start"
 //usage:     "\n                        and when finished"
+//usage:     "\n        -p              Pattern to use for payload"
 //usage:
 //usage:#endif
 //usage:
@@ -330,7 +332,7 @@ static int common_ping_main(sa_family_t af, char **argv)
 
 /* Full(er) version */
 
-#define OPT_STRING ("qvc:s:t:w:W:I:n4" IF_PING6("6"))
+#define OPT_STRING ("qvc:s:t:w:W:I:np:4" IF_PING6("6"))
 enum {
         OPT_QUIET = 1 << 0,
         OPT_VERBOSE = 1 << 1,
@@ -341,8 +343,9 @@ enum {
         OPT_W = 1 << 6,
         OPT_I = 1 << 7,
         /*OPT_n = 1 << 8, - ignored */
-        OPT_IPV4 = 1 << 9,
-        OPT_IPV6 = (1 << 10) * ENABLE_PING6,
+        OPT_p = 1 << 9,
+        OPT_IPV4 = 1 << 10,
+        OPT_IPV6 = (1 << 11) * ENABLE_PING6,
 };
 
 
@@ -355,6 +358,7 @@ struct globals {
         unsigned opt_ttl;
         unsigned long ntransmitted, nreceived, nrepeats;
         uint16_t myid;
+        uint8_t pattern;
         unsigned tmin, tmax; /* in us */
         unsigned long long tsum; /* in us, sum of all times */
         unsigned deadline;
@@ -485,7 +489,7 @@ static void sendping4(int junk UNUSED_PARAM)
 {
         struct icmp *pkt = G.snd_packet;
 
-        //memset(pkt, 0, datalen + ICMP_MINLEN + 4); - G.snd_packet was xzalloced
+        memset(pkt, G.pattern, datalen + ICMP_MINLEN + 4);
         pkt->icmp_type = ICMP_ECHO;
         /*pkt->icmp_code = 0;*/
         pkt->icmp_cksum = 0; /* cksum is calculated with this field set to 0 */
@@ -508,7 +512,7 @@ static void sendping6(int junk UNUSED_PARAM)
 {
         struct icmp6_hdr *pkt = G.snd_packet;
 
-        //memset(pkt, 0, datalen + sizeof(struct icmp6_hdr) + 4);
+        memset(pkt, G.pattern, datalen + sizeof(struct icmp6_hdr) + 4);
         pkt->icmp6_type = ICMP6_ECHO_REQUEST;
         /*pkt->icmp6_code = 0;*/
         /*pkt->icmp6_cksum = 0;*/
@@ -850,13 +854,13 @@ static void ping(len_and_sockaddr *lsa)
 static int common_ping_main(int opt, char **argv)
 {
         len_and_sockaddr *lsa;
-        char *str_s;
+        char *str_s, *str_p;
 
         INIT_G();
 
         /* exactly one argument needed; -v and -q don't mix; -c NUM, -t NUM, -w NUM, -W NUM */
         opt_complementary = "=1:q--v:v--q:c+:t+:w+:W+";
-        opt |= getopt32(argv, OPT_STRING, &pingcount, &str_s, &opt_ttl, &deadline, &timeout, &str_I);
+        opt |= getopt32(argv, OPT_STRING, &pingcount, &str_s, &opt_ttl, &deadline, &timeout, &str_I, &str_p);
         if (opt & OPT_s)
                 datalen = xatou16(str_s); // -s
         if (opt & OPT_I) { // -I
@@ -867,6 +871,9 @@ static int common_ping_main(int opt, char **argv)
                         str_I = NULL; /* don't try to bind to device later */
                 }
         }
+        if (opt & OPT_p)
+                G.pattern = xstrtou_range(str_p, 16, 0, 255);
+
         myid = (uint16_t) getpid();
         hostname = argv[optind];
 #if ENABLE_PING6
diff --git a/networking/tftp.c b/networking/tftp.c
index 630fdaf9a..7c0ee58d7 100644
--- a/networking/tftp.c
+++ b/networking/tftp.c
@@ -117,8 +117,10 @@ struct globals {
         /* u16 TFTP_ERROR; u16 reason; both network-endian, then error text: */
         uint8_t error_pkt[4 + 32];
         struct passwd *pw;
-        /* used in tftpd_main(), a bit big for stack: */
-        char block_buf[TFTP_BLKSIZE_DEFAULT];
+        /* Used in tftpd_main() for initial packet */
+        /* Some HP PA-RISC firmware always sends fixed 516-byte requests */
+        char block_buf[516];
+        char block_buf_tail[1];
 #if ENABLE_FEATURE_TFTP_PROGRESS_BAR
         off_t pos;
         off_t size;
@@ -793,14 +795,16 @@ int tftpd_main(int argc UNUSED_PARAM, char **argv)
                 xchroot(argv[0]);
         }
 
-        result = recv_from_to(STDIN_FILENO, G.block_buf, sizeof(G.block_buf),
+        result = recv_from_to(STDIN_FILENO,
+                        G.block_buf, sizeof(G.block_buf) + 1,
+                        /* ^^^ sizeof+1 to reliably detect oversized input */
                         0 /* flags */,
                         &peer_lsa->u.sa, &our_lsa->u.sa, our_lsa->len);
 
         error_msg = "malformed packet";
         opcode = ntohs(*(uint16_t*)G.block_buf);
-        if (result < 4 || result >= sizeof(G.block_buf)
-         || G.block_buf[result-1] != '\0'
+        if (result < 4 || result > sizeof(G.block_buf)
+        /*|| G.block_buf[result-1] != '\0' - bug compatibility, see below */
          || (IF_FEATURE_TFTP_PUT(opcode != TFTP_RRQ) /* not download */
              IF_GETPUT(&&)
              IF_FEATURE_TFTP_GET(opcode != TFTP_WRQ) /* not upload */
@@ -808,6 +812,13 @@ int tftpd_main(int argc UNUSED_PARAM, char **argv)
         ) {
                 goto err;
         }
+        /* Some HP PA-RISC firmware always sends fixed 516-byte requests,
+         * with trailing garbage.
+         * Support that by not requiring NUL to be the last byte (see above).
+         * To make strXYZ() ops safe, force NUL termination:
+         */
+        G.block_buf_tail[0] = '\0';
+
         local_file = G.block_buf + 2;
         if (local_file[0] == '.' || strstr(local_file, "/.")) {
                 error_msg = "dot in file name";
diff --git a/networking/udhcp/common.c b/networking/udhcp/common.c
index fe322db4f..bc41c8d4d 100644
--- a/networking/udhcp/common.c
+++ b/networking/udhcp/common.c
@@ -63,6 +63,7 @@ const struct dhcp_optflag dhcp_optflags[] = {
         { OPTION_U8                               , 0x85 }, /* DHCP_VLAN_PRIORITY */
 #endif
         { OPTION_STRING                           , 0xd1 }, /* DHCP_PXE_CONF_FILE */
+        { OPTION_STRING                           , 0xd2 }, /* DHCP_PXE_PATH_PREFIX */
         { OPTION_6RD                              , 0xd4 }, /* DHCP_6RD           */
         { OPTION_STATIC_ROUTES | OPTION_LIST      , 0xf9 }, /* DHCP_MS_STATIC_ROUTES */
         { OPTION_STRING                           , 0xfc }, /* DHCP_WPAD          */
@@ -130,6 +131,7 @@ const char dhcp_option_strings[] ALIGN1 =
         "vlanpriority" "\0"/* DHCP_VLAN_PRIORITY  */
 #endif
         "pxeconffile" "\0" /* DHCP_PXE_CONF_FILE  */
+        "pxepathprefix" "\0" /* DHCP_PXE_PATH_PREFIX  */
         "ip6rd" "\0"       /* DHCP_6RD            */
         "msstaticroutes""\0"/* DHCP_MS_STATIC_ROUTES */
         "wpad" "\0"        /* DHCP_WPAD           */
diff --git a/networking/udhcp/common.h b/networking/udhcp/common.h
index 5e70d609f..e5e0f2599 100644
--- a/networking/udhcp/common.h
+++ b/networking/udhcp/common.h
@@ -152,6 +152,7 @@ enum {
 //#define DHCP_VLAN_ID          0x84 /* 802.1P VLAN ID */
 //#define DHCP_VLAN_PRIORITY    0x85 /* 802.1Q VLAN priority */
 //#define DHCP_PXE_CONF_FILE    0xd1 /* RFC 5071 Configuration File */
+//#define DHCP_PXE_PATH_PREFIX  0xd2 /* RFC 5071 Configuration File */
 //#define DHCP_MS_STATIC_ROUTES 0xf9 /* Microsoft's pre-RFC 3442 code for 0x79? */
 //#define DHCP_WPAD             0xfc /* MSIE's Web Proxy Autodiscovery Protocol */
 #define DHCP_END                0xff
diff --git a/networking/zcip.c b/networking/zcip.c
index 7314ff8db..45d1f7c1c 100644
--- a/networking/zcip.c
+++ b/networking/zcip.c
@@ -366,11 +366,11 @@ int zcip_main(int argc UNUSED_PARAM, char **argv)
                                         nprobes++;
                                         VDBG("probe/%u %s@%s\n",
                                                         nprobes, argv_intf, inet_ntoa(ip));
+                                        timeout_ms = PROBE_MIN * 1000;
+                                        timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
                                         arp(/* ARPOP_REQUEST, */
                                                         /* &eth_addr, */ null_ip,
                                                         &null_addr, ip);
-                                        timeout_ms = PROBE_MIN * 1000;
-                                        timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
                                 }
                                 else {
                                         // Switch to announce state.
@@ -378,10 +378,10 @@ int zcip_main(int argc UNUSED_PARAM, char **argv)
                                         nclaims = 0;
                                         VDBG("announce/%u %s@%s\n",
                                                         nclaims, argv_intf, inet_ntoa(ip));
+                                        timeout_ms = ANNOUNCE_INTERVAL * 1000;
                                         arp(/* ARPOP_REQUEST, */
                                                         /* &eth_addr, */ ip,
                                                         &eth_addr, ip);
-                                        timeout_ms = ANNOUNCE_INTERVAL * 1000;
                                 }
                                 break;
                         case RATE_LIMIT_PROBE:
@@ -391,10 +391,10 @@ int zcip_main(int argc UNUSED_PARAM, char **argv)
                                 nclaims = 0;
                                 VDBG("announce/%u %s@%s\n",
                                                 nclaims, argv_intf, inet_ntoa(ip));
+                                timeout_ms = ANNOUNCE_INTERVAL * 1000;
                                 arp(/* ARPOP_REQUEST, */
                                                 /* &eth_addr, */ ip,
                                                 &eth_addr, ip);
-                                timeout_ms = ANNOUNCE_INTERVAL * 1000;
                                 break;
                         case ANNOUNCE:
                                 // timeouts in the ANNOUNCE state mean no conflicting ARP packets
@@ -403,10 +403,10 @@ int zcip_main(int argc UNUSED_PARAM, char **argv)
                                         nclaims++;
                                         VDBG("announce/%u %s@%s\n",
                                                         nclaims, argv_intf, inet_ntoa(ip));
+                                        timeout_ms = ANNOUNCE_INTERVAL * 1000;
                                         arp(/* ARPOP_REQUEST, */
                                                         /* &eth_addr, */ ip,
                                                         &eth_addr, ip);
-                                        timeout_ms = ANNOUNCE_INTERVAL * 1000;
                                 }
                                 else {
                                         // Switch to monitor state.
@@ -495,22 +495,28 @@ int zcip_main(int argc UNUSED_PARAM, char **argv)
                         }
 #endif
                         if (p.arp.arp_op != htons(ARPOP_REQUEST)
-                         && p.arp.arp_op != htons(ARPOP_REPLY))
+                         && p.arp.arp_op != htons(ARPOP_REPLY)
+                        ) {
                                 continue;
+                        }
 
                         source_ip_conflict = 0;
                         target_ip_conflict = 0;
 
-                        if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0
-                         && memcmp(&p.arp.arp_sha, &eth_addr, ETH_ALEN) != 0
-                        ) {
-                                source_ip_conflict = 1;
-                        }
-                        if (p.arp.arp_op == htons(ARPOP_REQUEST)
-                         && memcmp(p.arp.arp_tpa, &ip.s_addr, sizeof(struct in_addr)) == 0
-                         && memcmp(&p.arp.arp_tha, &eth_addr, ETH_ALEN) != 0
-                        ) {
-                                target_ip_conflict = 1;
+                        if (memcmp(&p.arp.arp_sha, &eth_addr, ETH_ALEN) != 0) {
+                                if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr))) {
+                                        /* A probe or reply with source_ip == chosen ip */
+                                        source_ip_conflict = 1;
+                                }
+                                if (p.arp.arp_op == htons(ARPOP_REQUEST)
+                                 && memcmp(p.arp.arp_spa, &null_ip, sizeof(struct in_addr)) == 0
+                                 && memcmp(p.arp.arp_tpa, &ip.s_addr, sizeof(struct in_addr)) == 0
+                                ) {
+                                        /* A probe with source_ip == 0.0.0.0, target_ip == chosen ip:
+                                         * another host trying to claim this ip!
+                                         */
+                                        target_ip_conflict = 1;
+                                }
                         }
 
                         VDBG("state = %d, source ip conflict = %d, target ip conflict = %d\n",