Merge branch 'busybox' into merge

4 files changed, 72 insertions, 37 deletions

diff --git a/networking/interface.c b/networking/interface.c
index 24bd13c57..e5723b428 100644
--- a/networking/interface.c
+++ b/networking/interface.c
@@ -881,6 +881,7 @@ static void ife_print6(struct interface *ptr)
                         sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
                                         addr6p[0], addr6p[1], addr6p[2], addr6p[3],
                                         addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
+                        memset(&sap, 0, sizeof(sap));
                         inet_pton(AF_INET6, addr6,
                                           (struct sockaddr *) &sap.sin6_addr);
                         sap.sin6_family = AF_INET6;
diff --git a/networking/libiproute/iproute.c b/networking/libiproute/iproute.c
index d232ee6fd..82827488f 100644
--- a/networking/libiproute/iproute.c
+++ b/networking/libiproute/iproute.c
@@ -313,12 +313,13 @@ static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
 static int iproute_modify(int cmd, unsigned flags, char **argv)
 {
         static const char keywords[] ALIGN1 =
-                "src\0""via\0""mtu\0""lock\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
+                "src\0""via\0""mtu\0""lock\0""scope\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
                 "dev\0""oif\0""to\0""metric\0""onlink\0";
         enum {
                 ARG_src,
                 ARG_via,
                 ARG_mtu, PARM_lock,
+                ARG_scope,
                 ARG_protocol,
 IF_FEATURE_IP_RULE(ARG_table,)
                 ARG_dev,
@@ -344,6 +345,7 @@ IF_FEATURE_IP_RULE(ARG_table,)
         unsigned mxlock = 0;
         char *d = NULL;
         smalluint ok = 0;
+        smalluint scope_ok = 0;
         int arg;
 
         memset(&req, 0, sizeof(req));
@@ -352,15 +354,18 @@ IF_FEATURE_IP_RULE(ARG_table,)
         req.n.nlmsg_flags = NLM_F_REQUEST | flags;
         req.n.nlmsg_type = cmd;
         req.r.rtm_family = preferred_family;
-        if (RT_TABLE_MAIN) /* if it is zero, memset already did it */
+        if (RT_TABLE_MAIN != 0) /* if it is zero, memset already did it */
                 req.r.rtm_table = RT_TABLE_MAIN;
-        if (RT_SCOPE_NOWHERE)
+        if (RT_SCOPE_NOWHERE != 0)
                 req.r.rtm_scope = RT_SCOPE_NOWHERE;
 
         if (cmd != RTM_DELROUTE) {
-                req.r.rtm_protocol = RTPROT_BOOT;
-                req.r.rtm_scope = RT_SCOPE_UNIVERSE;
-                req.r.rtm_type = RTN_UNICAST;
+                if (RTPROT_BOOT != 0)
+                        req.r.rtm_protocol = RTPROT_BOOT;
+                if (RT_SCOPE_UNIVERSE != 0)
+                        req.r.rtm_scope = RT_SCOPE_UNIVERSE;
+                if (RTN_UNICAST != 0)
+                        req.r.rtm_type = RTN_UNICAST;
         }
 
         mxrta->rta_type = RTA_METRICS;
@@ -393,6 +398,13 @@ IF_FEATURE_IP_RULE(ARG_table,)
                         }
                         mtu = get_unsigned(*argv, "mtu");
                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
+                } else if (arg == ARG_scope) {
+                        uint32_t scope;
+                        NEXT_ARG();
+                        if (rtnl_rtscope_a2n(&scope, *argv))
+                                invarg_1_to_2(*argv, "scope");
+                        req.r.rtm_scope = scope;
+                        scope_ok = 1;
                 } else if (arg == ARG_protocol) {
                         uint32_t prot;
                         NEXT_ARG();
@@ -469,20 +481,22 @@ IF_FEATURE_IP_RULE(ARG_table,)
                 addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
         }
 
-        if (req.r.rtm_type == RTN_LOCAL || req.r.rtm_type == RTN_NAT)
-                req.r.rtm_scope = RT_SCOPE_HOST;
-        else
-        if (req.r.rtm_type == RTN_BROADCAST
-         || req.r.rtm_type == RTN_MULTICAST
-         || req.r.rtm_type == RTN_ANYCAST
-        ) {
-                req.r.rtm_scope = RT_SCOPE_LINK;
-        }
-        else if (req.r.rtm_type == RTN_UNICAST || req.r.rtm_type == RTN_UNSPEC) {
-                if (cmd == RTM_DELROUTE)
-                        req.r.rtm_scope = RT_SCOPE_NOWHERE;
-                else if (!(ok & gw_ok))
+        if (!scope_ok) {
+                if (req.r.rtm_type == RTN_LOCAL || req.r.rtm_type == RTN_NAT)
+                        req.r.rtm_scope = RT_SCOPE_HOST;
+                else
+                if (req.r.rtm_type == RTN_BROADCAST
+                 || req.r.rtm_type == RTN_MULTICAST
+                 || req.r.rtm_type == RTN_ANYCAST
+                ) {
                         req.r.rtm_scope = RT_SCOPE_LINK;
+                }
+                else if (req.r.rtm_type == RTN_UNICAST || req.r.rtm_type == RTN_UNSPEC) {
+                        if (cmd == RTM_DELROUTE)
+                                req.r.rtm_scope = RT_SCOPE_NOWHERE;
+                        else if (!(ok & gw_ok))
+                                req.r.rtm_scope = RT_SCOPE_LINK;
+                }
         }
 
         if (req.r.rtm_family == AF_UNSPEC) {
diff --git a/networking/ntpd.c b/networking/ntpd.c
index 9732c9b1a..1651670d9 100644
--- a/networking/ntpd.c
+++ b/networking/ntpd.c
@@ -112,7 +112,7 @@
  *
  * Made some changes to speed up re-syncing after our clock goes bad
  * (tested with suspending my laptop):
- * - if largish offset (>= STEP_THRESHOLD * 8 == 1 sec) is seen
+ * - if largish offset (>= STEP_THRESHOLD == 1 sec) is seen
  *   from a peer, schedule next query for this peer soon
  *   without drastically lowering poll interval for everybody.
  *   This makes us collect enough data for step much faster:
@@ -131,11 +131,14 @@
 #define RESPONSE_INTERVAL 16    /* wait for reply up to N secs */
 
 /* Step threshold (sec). std ntpd uses 0.128.
+ */
+#define STEP_THRESHOLD     1
+/* Slew threshold (sec): adjtimex() won't accept offsets larger than this.
  * Using exact power of 2 (1/8) results in smaller code
  */
-#define STEP_THRESHOLD  0.125
+#define SLEW_THRESHOLD 0.125
 /* Stepout threshold (sec). std ntpd uses 900 (11 mins (!)) */
-#define WATCH_THRESHOLD 128
+#define WATCH_THRESHOLD  128
 /* NB: set WATCH_THRESHOLD to ~60 when debugging to save time) */
 //UNUSED: #define PANIC_THRESHOLD 1000    /* panic threshold (sec) */
 
@@ -143,7 +146,7 @@
  * 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          STEP_THRESHOLD
 #define BIGOFF_INTERVAL (1 << 7) /* 128 s */
 
 #define FREQ_TOLERANCE  0.000015 /* frequency tolerance (15 PPM) */
@@ -157,10 +160,10 @@
 #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.
- * With STEP_THRESHOLD = 0.125, it means we try to sync more aggressively
+ * With SLEW_THRESHOLD = 0.125, it means we try to sync more aggressively
  * if offset increases over ~0.04 sec
  */
-//#define POLLDOWN_OFFSET (STEP_THRESHOLD / 3)
+//#define POLLDOWN_OFFSET (SLEW_THRESHOLD / 3)
 #define MINDISP         0.01    /* minimum dispersion (sec) */
 #define MAXDISP         16      /* maximum dispersion (sec) */
 #define MAXSTRAT        16      /* maximum stratum (infinity metric) */
@@ -720,7 +723,7 @@ static void
 reset_peer_stats(peer_t *p, double offset)
 {
         int i;
-        bool small_ofs = fabs(offset) < 16 * STEP_THRESHOLD;
+        bool small_ofs = fabs(offset) < STEP_THRESHOLD;
 
         /* Used to set p->filter_datapoint[i].d_dispersion = MAXDISP
          * and clear reachable bits, but this proved to be too agressive:
@@ -771,7 +774,7 @@ add_peers(const char *s)
         p->p_fd = -1;
         p->p_xmt_msg.m_status = MODE_CLIENT | (NTP_VERSION << 3);
         p->next_action_time = G.cur_time; /* = set_next(p, 0); */
-        reset_peer_stats(p, 16 * STEP_THRESHOLD);
+        reset_peer_stats(p, STEP_THRESHOLD);
 
         llist_add_to(&G.ntp_peers, p);
         G.peer_cnt++;
@@ -1638,14 +1641,7 @@ update_local_clock(peer_t *p)
         tmx.freq = G.discipline_freq_drift * 65536e6;
 #endif
         tmx.modes = ADJ_OFFSET | ADJ_STATUS | ADJ_TIMECONST;// | ADJ_MAXERROR | ADJ_ESTERROR;
-        tmx.offset = (offset * 1000000); /* usec */
-        tmx.status = STA_PLL;
-        if (G.ntp_status & LI_PLUSSEC)
-                tmx.status |= STA_INS;
-        if (G.ntp_status & LI_MINUSSEC)
-                tmx.status |= STA_DEL;
-
-        tmx.constant = (int)G.poll_exp - 4 > 0 ? (int)G.poll_exp - 4 : 0;
+        tmx.constant = (int)G.poll_exp - 4;
         /* EXPERIMENTAL.
          * The below if statement should be unnecessary, but...
          * It looks like Linux kernel's PLL is far too gentle in changing
@@ -1656,8 +1652,27 @@ update_local_clock(peer_t *p)
          * To be on a safe side, let's do it only if offset is significantly
          * larger than jitter.
          */
-        if (tmx.constant > 0 && G.offset_to_jitter_ratio >= TIMECONST_HACK_GATE)
+        if (G.offset_to_jitter_ratio >= TIMECONST_HACK_GATE)
                 tmx.constant--;
+        tmx.offset = (long)(offset * 1000000); /* usec */
+        if (SLEW_THRESHOLD < STEP_THRESHOLD) {
+                if (tmx.offset > (long)(SLEW_THRESHOLD * 1000000)) {
+                        tmx.offset = (long)(SLEW_THRESHOLD * 1000000);
+                        tmx.constant--;
+                }
+                if (tmx.offset < -(long)(SLEW_THRESHOLD * 1000000)) {
+                        tmx.offset = -(long)(SLEW_THRESHOLD * 1000000);
+                        tmx.constant--;
+                }
+        }
+        if (tmx.constant < 0)
+                tmx.constant = 0;
+
+        tmx.status = STA_PLL;
+        if (G.ntp_status & LI_PLUSSEC)
+                tmx.status |= STA_INS;
+        if (G.ntp_status & LI_MINUSSEC)
+                tmx.status |= STA_DEL;
 
         //tmx.esterror = (uint32_t)(clock_jitter * 1e6);
         //tmx.maxerror = (uint32_t)((sys_rootdelay / 2 + sys_rootdisp) * 1e6);
@@ -1931,6 +1946,9 @@ recv_and_process_peer_pkt(peer_t *p)
  increase_interval:
                         adjust_poll(MINPOLL);
                 } else {
+                        VERB3 if (rc > 0)
+                                bb_error_msg("want smaller poll interval: offset/jitter > %u",
+                                        POLLADJ_GATE);
                         adjust_poll(-G.poll_exp * 2);
                 }
         }
@@ -1939,7 +1957,7 @@ recv_and_process_peer_pkt(peer_t *p)
  pick_normal_interval:
         interval = poll_interval(INT_MAX);
         if (fabs(offset) >= BIGOFF && interval > BIGOFF_INTERVAL) {
-                /* If we are synced, offsets are less than STEP_THRESHOLD,
+                /* If we are synced, offsets are less than SLEW_THRESHOLD,
                  * or at the very least not much larger than it.
                  * Now we see a largish one.
                  * Either this peer is feeling bad, or packet got corrupted,
diff --git a/networking/udhcp/dhcpc.c b/networking/udhcp/dhcpc.c
index 915f65935..48097bc24 100644
--- a/networking/udhcp/dhcpc.c
+++ b/networking/udhcp/dhcpc.c
@@ -201,6 +201,8 @@ static int good_hostname(const char *name)
                         //Do we want this?
                         //return ((name - start) < 1025); /* NS_MAXDNAME */
                 name++;
+                if (*name == '\0')
+                        return 1; // We allow trailing dot too
         }
 }
 #else