Merge branch 'busybox' into merge

19 files changed, 529 insertions, 159 deletions

diff --git a/networking/Config.src b/networking/Config.src
index 43ccbf385..8c7417f86 100644
--- a/networking/Config.src
+++ b/networking/Config.src
@@ -554,6 +554,13 @@ config FEATURE_IP_RULE
         help
           Add support for rule commands to "ip".
 
+config FEATURE_IP_NEIGH
+        bool "ip neighbor"
+        default y
+        depends on IP
+        help
+          Add support for neighbor commands to "ip".
+
 config FEATURE_IP_SHORT_FORMS
         bool "Support short forms of ip commands"
         default y
@@ -565,6 +572,7 @@ config FEATURE_IP_SHORT_FORMS
           ip route  -> iproute
           ip tunnel -> iptunnel
           ip rule   -> iprule
+          ip neigh  -> ipneigh
 
           Say N unless you desparately need the short form of the ip
           object commands.
@@ -604,6 +612,11 @@ config IPRULE
         default y
         depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_RULE
 
+config IPNEIGH
+        bool
+        default y
+        depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_NEIGH
+
 config IPCALC
         bool "ipcalc"
         default y
diff --git a/networking/brctl.c b/networking/brctl.c
index c01a86998..b7320966a 100644
--- a/networking/brctl.c
+++ b/networking/brctl.c
@@ -128,7 +128,7 @@ static ALWAYS_INLINE void bb_strtotimeval(struct timeval *tv,
 # else
         if (sscanf(time_str, "%lf", &secs) != 1)
 # endif
-                bb_error_msg_and_die(bb_msg_invalid_arg, time_str, "timespec");
+                bb_error_msg_and_die(bb_msg_invalid_arg_to, time_str, "timespec");
         tv->tv_sec = secs;
         tv->tv_usec = 1000000 * (secs - tv->tv_sec);
 }
@@ -205,7 +205,7 @@ int brctl_main(int argc UNUSED_PARAM, char **argv)
 
                 key = index_in_strings(keywords, *argv);
                 if (key == -1) /* no match found in keywords array, bail out. */
-                        bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+                        bb_error_msg_and_die(bb_msg_invalid_arg_to, *argv, applet_name);
                 argv++;
                 fd = xsocket(AF_INET, SOCK_STREAM, 0);
 
@@ -299,7 +299,7 @@ int brctl_main(int argc UNUSED_PARAM, char **argv)
                                 "1\0" "on\0"  "y\0" "yes\0"; /* 4 .. 7 */
                         int onoff = index_in_strings(no_yes, *argv);
                         if (onoff < 0)
-                                bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+                                bb_error_msg_and_die(bb_msg_invalid_arg_to, *argv, applet_name);
                         onoff = (unsigned)onoff / 4;
                         arm_ioctl(args, BRCTL_SET_BRIDGE_STP_STATE, onoff, 0);
                         goto fire;
@@ -332,7 +332,7 @@ int brctl_main(int argc UNUSED_PARAM, char **argv)
 
                                 port = if_nametoindex(*argv++);
                                 if (!port)
-                                        bb_error_msg_and_die(bb_msg_invalid_arg, *argv, "port");
+                                        bb_error_msg_and_die(bb_msg_invalid_arg_to, *argv, "port");
                                 memset(ifidx, 0, sizeof ifidx);
                                 arm_ioctl(args, BRCTL_GET_PORT_LIST, (unsigned long)ifidx,
                                                 MAX_PORTS);
diff --git a/networking/inetd.c b/networking/inetd.c
index dce5a0885..243165a07 100644
--- a/networking/inetd.c
+++ b/networking/inetd.c
@@ -329,9 +329,6 @@ struct globals {
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 enum { LINE_SIZE = COMMON_BUFSIZE - offsetof(struct globals, line) };
-struct BUG_G_too_big {
-        char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
-};
 #define rlim_ofile_cur  (G.rlim_ofile_cur )
 #define rlim_ofile      (G.rlim_ofile     )
 #define serv_list       (G.serv_list      )
@@ -352,6 +349,7 @@ struct BUG_G_too_big {
 #define allsock         (G.allsock        )
 #define line            (G.line           )
 #define INIT_G() do { \
+        BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
         rlim_ofile_cur = OPEN_MAX; \
         global_queuelen = 128; \
         config_filename = "/etc/inetd.conf"; \
diff --git a/networking/ip.c b/networking/ip.c
index d35345c36..ddfe74e9c 100644
--- a/networking/ip.c
+++ b/networking/ip.c
@@ -16,6 +16,7 @@
 //usage:        IF_FEATURE_IP_ROUTE("route | ")
 //usage:        IF_FEATURE_IP_LINK("link | ")
 //usage:        IF_FEATURE_IP_TUNNEL("tunnel | ")
+//usage:        IF_FEATURE_IP_NEIGH("neigh | ")
 //usage:        IF_FEATURE_IP_RULE("rule")
 //usage:       "} {COMMAND}"
 //usage:#define ip_full_usage "\n\n"
@@ -25,6 +26,7 @@
 //usage:        IF_FEATURE_IP_ROUTE("route | ")
 //usage:        IF_FEATURE_IP_LINK("link | ")
 //usage:        IF_FEATURE_IP_TUNNEL("tunnel | ")
+//usage:        IF_FEATURE_IP_NEIGH("neigh | ")
 //usage:        IF_FEATURE_IP_RULE("rule")
 //usage:       "}\n"
 //usage:       "OPTIONS := { -f[amily] { inet | inet6 | link } | -o[neline] }"
@@ -80,6 +82,11 @@
 //usage:       "        [mode { ipip | gre | sit }] [remote ADDR] [local ADDR]\n"
 //usage:       "        [[i|o]seq] [[i|o]key KEY] [[i|o]csum]\n"
 //usage:       "        [ttl TTL] [tos TOS] [[no]pmtudisc] [dev PHYS_DEV]"
+//usage:
+//usage:#define ipneigh_trivial_usage
+//usage:       "{ show | flush} [ to PREFIX ] [ dev DEV ] [ nud STATE ]"
+//usage:#define ipneigh_full_usage "\n\n"
+//usage:       "ipneigh { show | flush} [ to PREFIX ] [ dev DEV ] [ nud STATE ]"
 
 #include "libbb.h"
 
@@ -90,7 +97,8 @@
  || ENABLE_FEATURE_IP_ROUTE \
  || ENABLE_FEATURE_IP_LINK \
  || ENABLE_FEATURE_IP_TUNNEL \
- || ENABLE_FEATURE_IP_RULE
+ || ENABLE_FEATURE_IP_RULE \
+ || ENABLE_FEATURE_IP_NEIGH
 
 static int FAST_FUNC ip_print_help(char **argv UNUSED_PARAM)
 {
@@ -140,6 +148,13 @@ int iptunnel_main(int argc UNUSED_PARAM, char **argv)
         return ip_do(do_iptunnel, argv);
 }
 #endif
+#if ENABLE_FEATURE_IP_NEIGH
+int ipneigh_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int ipneigh_main(int argc UNUSED_PARAM, char **argv)
+{
+        return ip_do(do_ipneigh, argv);
+}
+#endif
 
 
 int ip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
@@ -153,6 +168,7 @@ int ip_main(int argc UNUSED_PARAM, char **argv)
                 IF_FEATURE_IP_TUNNEL("tunnel\0")
                 IF_FEATURE_IP_TUNNEL("tunl\0")
                 IF_FEATURE_IP_RULE("rule\0")
+                IF_FEATURE_IP_NEIGH("neigh\0")
                 ;
         static const ip_func_ptr_t ip_func_ptrs[] = {
                 ip_print_help,
@@ -163,6 +179,7 @@ int ip_main(int argc UNUSED_PARAM, char **argv)
                 IF_FEATURE_IP_TUNNEL(do_iptunnel,)
                 IF_FEATURE_IP_TUNNEL(do_iptunnel,)
                 IF_FEATURE_IP_RULE(do_iprule,)
+                IF_FEATURE_IP_NEIGH(do_ipneigh,)
         };
         ip_func_ptr_t ip_func;
         int key;
diff --git a/networking/libiproute/Kbuild.src b/networking/libiproute/Kbuild.src
index 7c78f3c6a..c20e2fee8 100644
--- a/networking/libiproute/Kbuild.src
+++ b/networking/libiproute/Kbuild.src
@@ -64,3 +64,11 @@ lib-$(CONFIG_FEATURE_IP_RULE) += \
         iprule.o \
         rt_names.o \
         utils.o
+
+lib-$(CONFIG_FEATURE_IP_NEIGH) += \
+        ip_parse_common_args.o \
+        ipneigh.o \
+        libnetlink.o \
+        ll_map.o \
+        rt_names.o \
+        utils.o
diff --git a/networking/libiproute/ip_common.h b/networking/libiproute/ip_common.h
index 30c7e595b..40171bed9 100644
--- a/networking/libiproute/ip_common.h
+++ b/networking/libiproute/ip_common.h
@@ -24,7 +24,7 @@ int FAST_FUNC ipaddr_list_or_flush(char **argv, int flush);
 int FAST_FUNC do_ipaddr(char **argv);
 int FAST_FUNC do_iproute(char **argv);
 int FAST_FUNC do_iprule(char **argv);
-//int FAST_FUNC do_ipneigh(char **argv);
+int FAST_FUNC do_ipneigh(char **argv);
 int FAST_FUNC do_iptunnel(char **argv);
 int FAST_FUNC do_iplink(char **argv);
 //int FAST_FUNC do_ipmonitor(char **argv);
diff --git a/networking/libiproute/ip_parse_common_args.c b/networking/libiproute/ip_parse_common_args.c
index 59c759b23..1a298f738 100644
--- a/networking/libiproute/ip_parse_common_args.c
+++ b/networking/libiproute/ip_parse_common_args.c
@@ -67,7 +67,7 @@ char** FAST_FUNC ip_parse_common_args(char **argv)
                                 bb_show_usage();
                         arg = index_in_strings(families, *argv);
                         if (arg < 0)
-                                invarg(*argv, "protocol family");
+                                invarg_1_to_2(*argv, "family");
                         /* now arg == 0, 1 or 2 */
                 } else {
                         arg -= ARG_IPv4;
diff --git a/networking/libiproute/ipaddress.c b/networking/libiproute/ipaddress.c
index 8845cab91..5c975d8c5 100644
--- a/networking/libiproute/ipaddress.c
+++ b/networking/libiproute/ipaddress.c
@@ -214,8 +214,7 @@ static int FAST_FUNC print_addrinfo(const struct sockaddr_nl *who UNUSED_PARAM,
 {
         struct ifaddrmsg *ifa = NLMSG_DATA(n);
         int len = n->nlmsg_len;
-        struct rtattr * rta_tb[IFA_MAX+1];
-        char abuf[256];
+        struct rtattr *rta_tb[IFA_MAX+1];
 
         if (n->nlmsg_type != RTM_NEWADDR && n->nlmsg_type != RTM_DELADDR)
                 return 0;
@@ -291,9 +290,9 @@ static int FAST_FUNC print_addrinfo(const struct sockaddr_nl *who UNUSED_PARAM,
                 printf("    family %d ", ifa->ifa_family);
 
         if (rta_tb[IFA_LOCAL]) {
-                fputs(rt_addr_n2a(ifa->ifa_family,
-                                              RTA_DATA(rta_tb[IFA_LOCAL]),
-                                              abuf, sizeof(abuf)), stdout);
+                fputs(rt_addr_n2a(ifa->ifa_family, RTA_DATA(rta_tb[IFA_LOCAL])),
+                        stdout
+                );
 
                 if (rta_tb[IFA_ADDRESS] == NULL
                  || memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_LOCAL]), 4) == 0
@@ -301,25 +300,22 @@ static int FAST_FUNC print_addrinfo(const struct sockaddr_nl *who UNUSED_PARAM,
                         printf("/%d ", ifa->ifa_prefixlen);
                 } else {
                         printf(" peer %s/%d ",
-                                rt_addr_n2a(ifa->ifa_family,
-                                            RTA_DATA(rta_tb[IFA_ADDRESS]),
-                                            abuf, sizeof(abuf)),
-                                ifa->ifa_prefixlen);
+                                rt_addr_n2a(ifa->ifa_family, RTA_DATA(rta_tb[IFA_ADDRESS])),
+                                ifa->ifa_prefixlen
+                        );
                 }
         }
 
         if (rta_tb[IFA_BROADCAST]) {
                 printf("brd %s ",
                         rt_addr_n2a(ifa->ifa_family,
-                                        RTA_DATA(rta_tb[IFA_BROADCAST]),
-                                        abuf, sizeof(abuf))
+                                RTA_DATA(rta_tb[IFA_BROADCAST]))
                 );
         }
         if (rta_tb[IFA_ANYCAST]) {
                 printf("any %s ",
                         rt_addr_n2a(ifa->ifa_family,
-                                        RTA_DATA(rta_tb[IFA_ANYCAST]),
-                                        abuf, sizeof(abuf))
+                                RTA_DATA(rta_tb[IFA_ANYCAST]))
                 );
         }
         printf("scope %s ", rtnl_rtscope_n2a(ifa->ifa_scope));
@@ -455,7 +451,7 @@ int FAST_FUNC ipaddr_list_or_flush(char **argv, int flush)
                         G_filter.scopemask = -1;
                         if (rtnl_rtscope_a2n(&scope, *argv)) {
                                 if (strcmp(*argv, "all") != 0) {
-                                        invarg(*argv, "scope");
+                                        invarg_1_to_2(*argv, "scope");
                                 }
                                 scope = RT_SCOPE_NOWHERE;
                                 G_filter.scopemask = 0;
@@ -669,7 +665,7 @@ static int ipaddr_modify(int cmd, int flags, char **argv)
                 } else if (arg == 5) { /* scope */
                         uint32_t scope = 0;
                         if (rtnl_rtscope_a2n(&scope, *argv)) {
-                                invarg(*argv, "scope");
+                                invarg_1_to_2(*argv, "scope");
                         }
                         req.ifa.ifa_scope = scope;
                         scoped = 1;
@@ -751,7 +747,7 @@ int FAST_FUNC do_ipaddr(char **argv)
         if (*argv) {
                 cmd = index_in_substrings(commands, *argv);
                 if (cmd < 0)
-                        invarg(*argv, applet_name);
+                        invarg_1_to_2(*argv, applet_name);
                 argv++;
                 if (cmd <= 4) {
                         return ipaddr_modify(
diff --git a/networking/libiproute/iplink.c b/networking/libiproute/iplink.c
index 5c27c2de3..ae3ef0ceb 100644
--- a/networking/libiproute/iplink.c
+++ b/networking/libiproute/iplink.c
@@ -349,7 +349,7 @@ static void vlan_parse_opt(char **argv, struct nlmsghdr *n, unsigned int size)
         while (*argv) {
                 arg = index_in_substrings(keywords, *argv);
                 if (arg < 0)
-                        invarg(*argv, "type vlan");
+                        invarg_1_to_2(*argv, "type vlan");
 
                 NEXT_ARG();
                 if (arg == ARG_id) {
@@ -512,7 +512,7 @@ static int do_add_or_delete(char **argv, const unsigned rtm)
         if (name_str) {
                 const size_t name_len = strlen(name_str) + 1;
                 if (name_len < 2 || name_len > IFNAMSIZ)
-                        invarg(name_str, "name");
+                        invarg_1_to_2(name_str, "name");
                 addattr_l(&req.n, sizeof(req), IFLA_IFNAME, name_str, name_len);
         }
         if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
@@ -536,14 +536,14 @@ static int do_add_or_delete(char **argv, const unsigned rtm)
                         if (qlen != -1)
                                 duparg("txqueuelen", *argv);
                         if (get_integer(&qlen,  *argv, 0))
-                                invarg("Invalid \"txqueuelen\" value\n", *argv);
+                                invarg_1_to_2(*argv, "txqueuelen");
                         addattr_l(&req->n, sizeof(*req), IFLA_TXQLEN, &qlen, 4);
                 } else if (strcmp(*argv, "mtu") == 0) {
                         NEXT_ARG();
                         if (mtu != -1)
                                 duparg("mtu", *argv);
                         if (get_integer(&mtu, *argv, 0))
-                                invarg("Invalid \"mtu\" value\n", *argv);
+                                invarg_1_to_2(*argv, "mtu");
                         addattr_l(&req->n, sizeof(*req), IFLA_MTU, &mtu, 4);
                 } else if (strcmp(*argv, "netns") == 0) {
                         NEXT_ARG();
@@ -554,7 +554,7 @@ static int do_add_or_delete(char **argv, const unsigned rtm)
                         else if (get_integer(&netns, *argv, 0) == 0)
                                 addattr_l(&req->n, sizeof(*req), IFLA_NET_NS_PID, &netns, 4);
                         else
-                                invarg("Invalid \"netns\" value\n", *argv);
+                                invarg_1_to_2(*argv, "netns");
                 } else if (strcmp(*argv, "multicast") == 0) {
                         NEXT_ARG();
                         req->i.ifi_change |= IFF_MULTICAST;
@@ -604,7 +604,7 @@ static int do_add_or_delete(char **argv, const unsigned rtm)
                         struct rtattr *vflist;
                         NEXT_ARG();
                         if (get_integer(&vf,  *argv, 0)) {
-                                invarg("Invalid \"vf\" value\n", *argv);
+                                invarg_1_to_2(*argv, "vf");
                         }
                         vflist = addattr_nest(&req->n, sizeof(*req),
                                               IFLA_VFINFO_LIST);
@@ -617,7 +617,7 @@ static int do_add_or_delete(char **argv, const unsigned rtm)
                         NEXT_ARG();
                         ifindex = ll_name_to_index(*argv);
                         if (!ifindex)
-                                invarg("Device does not exist\n", *argv);
+                                invarg_1_to_2(*argv, "master");
                         addattr_l(&req->n, sizeof(*req), IFLA_MASTER,
                                   &ifindex, 4);
                 } else if (matches(*argv, "nomaster") == 0) {
@@ -644,28 +644,27 @@ static int do_add_or_delete(char **argv, const unsigned rtm)
                         if (*group != -1)
                                 duparg("group", *argv);
                         if (rtnl_group_a2n(group, *argv))
-                                invarg("Invalid \"group\" value\n", *argv);
+                                invarg_1_to_2(*argv, "group");
                 } else if (strcmp(*argv, "mode") == 0) {
                         int mode;
                         NEXT_ARG();
                         mode = get_link_mode(*argv);
                         if (mode < 0)
-                                invarg("Invalid link mode\n", *argv);
+                                invarg_1_to_2(*argv, "mode");
                         addattr8(&req->n, sizeof(*req), IFLA_LINKMODE, mode);
                 } else if (strcmp(*argv, "state") == 0) {
                         int state;
                         NEXT_ARG();
                         state = get_operstate(*argv);
                         if (state < 0)
-                                invarg("Invalid operstate\n", *argv);
-
+                                invarg_1_to_2(*argv, "state");
                         addattr8(&req->n, sizeof(*req), IFLA_OPERSTATE, state);
                 } else if (matches(*argv, "numtxqueues") == 0) {
                         NEXT_ARG();
                         if (numtxqueues != -1)
                                 duparg("numtxqueues", *argv);
                         if (get_integer(&numtxqueues, *argv, 0))
-                                invarg("Invalid \"numtxqueues\" value\n", *argv);
+                                invarg_1_to_2(*argv, "numtxqueues");
                         addattr_l(&req->n, sizeof(*req), IFLA_NUM_TX_QUEUES,
                                   &numtxqueues, 4);
                 } else if (matches(*argv, "numrxqueues") == 0) {
@@ -673,7 +672,7 @@ static int do_add_or_delete(char **argv, const unsigned rtm)
                         if (numrxqueues != -1)
                                 duparg("numrxqueues", *argv);
                         if (get_integer(&numrxqueues, *argv, 0))
-                                invarg("Invalid \"numrxqueues\" value\n", *argv);
+                                invarg_1_to_2(*argv, "numrxqueues");
                         addattr_l(&req->n, sizeof(*req), IFLA_NUM_RX_QUEUES,
                                   &numrxqueues, 4);
                 }
@@ -687,7 +686,7 @@ int FAST_FUNC do_iplink(char **argv)
         if (*argv) {
                 int key = index_in_substrings(keywords, *argv);
                 if (key < 0) /* invalid argument */
-                        invarg(*argv, applet_name);
+                        invarg_1_to_2(*argv, applet_name);
                 argv++;
                 if (key <= 1) /* add/delete */
                         return do_add_or_delete(argv, key ? RTM_DELLINK : RTM_NEWLINK);
diff --git a/networking/libiproute/ipneigh.c b/networking/libiproute/ipneigh.c
new file mode 100644
index 000000000..179505c2d
--- /dev/null
+++ b/networking/libiproute/ipneigh.c
@@ -0,0 +1,353 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ * Ported to Busybox by:  Curt Brune <curt@cumulusnetworks.com>
+ */
+
+#include "ip_common.h"  /* #include "libbb.h" is inside */
+#include "rt_names.h"
+#include "utils.h"
+#include <linux/neighbour.h>
+#include <net/if_arp.h>
+
+//static int xshow_stats = 3;
+enum { xshow_stats = 3 };
+
+static inline uint32_t rta_getattr_u32(const struct rtattr *rta)
+{
+        return *(uint32_t *)RTA_DATA(rta);
+}
+
+#ifndef RTAX_RTTVAR
+#define RTAX_RTTVAR RTAX_HOPS
+#endif
+
+
+struct filter_t {
+        int family;
+        int index;
+        int state;
+        int unused_only;
+        inet_prefix pfx;
+        int flushed;
+        char *flushb;
+        int flushp;
+        int flushe;
+        struct rtnl_handle *rth;
+} FIX_ALIASING;
+typedef struct filter_t filter_t;
+
+#define G_filter (*(filter_t*)&bb_common_bufsiz1)
+
+static int flush_update(void)
+{
+        if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
+                bb_perror_msg("can't send flush request");
+                return -1;
+        }
+        G_filter.flushp = 0;
+        return 0;
+}
+
+static unsigned nud_state_a2n(char *arg)
+{
+        static const char keywords[] ALIGN1 =
+                /* "ip neigh show/flush" parameters: */
+                "permanent\0" "reachable\0"   "noarp\0"  "none\0"
+                "stale\0"     "incomplete\0"  "delay\0"  "probe\0"
+                "failed\0"
+                ;
+        static uint8_t nuds[] = {
+                NUD_PERMANENT,NUD_REACHABLE, NUD_NOARP,NUD_NONE,
+                NUD_STALE,    NUD_INCOMPLETE,NUD_DELAY,NUD_PROBE,
+                NUD_FAILED
+        };
+        int id;
+
+        BUILD_BUG_ON(
+                (NUD_PERMANENT|NUD_REACHABLE| NUD_NOARP|NUD_NONE|
+                NUD_STALE|    NUD_INCOMPLETE|NUD_DELAY|NUD_PROBE|
+                NUD_FAILED) > 0xff
+        );
+
+        id = index_in_substrings(keywords, arg);
+        if (id < 0)
+                bb_error_msg_and_die(bb_msg_invalid_arg_to, arg, "nud state");
+        return nuds[id];
+}
+
+#ifndef NDA_RTA
+#define NDA_RTA(r) \
+        ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
+#endif
+
+
+static int FAST_FUNC print_neigh(const struct sockaddr_nl *who UNUSED_PARAM,
+                                 struct nlmsghdr *n, void *arg UNUSED_PARAM)
+{
+        struct ndmsg *r = NLMSG_DATA(n);
+        int len = n->nlmsg_len;
+        struct rtattr *tb[NDA_MAX+1];
+
+        if (n->nlmsg_type != RTM_NEWNEIGH && n->nlmsg_type != RTM_DELNEIGH) {
+                bb_error_msg_and_die("not RTM_NEWNEIGH: %08x %08x %08x",
+                                     n->nlmsg_len, n->nlmsg_type,
+                                     n->nlmsg_flags);
+        }
+        len -= NLMSG_LENGTH(sizeof(*r));
+        if (len < 0) {
+                bb_error_msg_and_die("BUG: wrong nlmsg len %d", len);
+        }
+
+        if (G_filter.flushb && n->nlmsg_type != RTM_NEWNEIGH)
+                return 0;
+
+        if (G_filter.family && G_filter.family != r->ndm_family)
+                return 0;
+        if (G_filter.index && G_filter.index != r->ndm_ifindex)
+                return 0;
+        if (!(G_filter.state&r->ndm_state) &&
+            !(r->ndm_flags & NTF_PROXY) &&
+            (r->ndm_state || !(G_filter.state & 0x100)) &&
+            (r->ndm_family != AF_DECnet))
+                return 0;
+
+        parse_rtattr(tb, NDA_MAX, NDA_RTA(r), n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
+
+        if (tb[NDA_DST]) {
+                if (G_filter.pfx.family) {
+                        inet_prefix dst;
+                        memset(&dst, 0, sizeof(dst));
+                        dst.family = r->ndm_family;
+                        memcpy(&dst.data, RTA_DATA(tb[NDA_DST]), RTA_PAYLOAD(tb[NDA_DST]));
+                        if (inet_addr_match(&dst, &G_filter.pfx, G_filter.pfx.bitlen))
+                                return 0;
+                }
+        }
+        if (G_filter.unused_only && tb[NDA_CACHEINFO]) {
+                struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
+                if (ci->ndm_refcnt)
+                        return 0;
+        }
+
+        if (G_filter.flushb) {
+                struct nlmsghdr *fn;
+                if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
+                        if (flush_update())
+                                return -1;
+                }
+                fn = (struct nlmsghdr*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
+                memcpy(fn, n, n->nlmsg_len);
+                fn->nlmsg_type = RTM_DELNEIGH;
+                fn->nlmsg_flags = NLM_F_REQUEST;
+                fn->nlmsg_seq = ++(G_filter.rth->seq);
+                G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
+                G_filter.flushed++;
+                if (xshow_stats < 2)
+                        return 0;
+        }
+
+        if (tb[NDA_DST]) {
+                printf("%s ",
+                       format_host(r->ndm_family,
+                                   RTA_PAYLOAD(tb[NDA_DST]),
+                                   RTA_DATA(tb[NDA_DST]))
+                );
+        }
+        if (!G_filter.index && r->ndm_ifindex)
+                printf("dev %s ", ll_index_to_name(r->ndm_ifindex));
+        if (tb[NDA_LLADDR]) {
+                SPRINT_BUF(b1);
+                printf("lladdr %s", ll_addr_n2a(RTA_DATA(tb[NDA_LLADDR]),
+                                                RTA_PAYLOAD(tb[NDA_LLADDR]),
+                                                ARPHRD_ETHER,
+                                                b1, sizeof(b1)));
+        }
+        if (r->ndm_flags & NTF_ROUTER) {
+                printf(" router");
+        }
+        if (r->ndm_flags & NTF_PROXY) {
+                printf(" proxy");
+        }
+        if (tb[NDA_CACHEINFO] && xshow_stats) {
+                struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
+                int hz = get_hz();
+
+                if (ci->ndm_refcnt)
+                        printf(" ref %d", ci->ndm_refcnt);
+                printf(" used %d/%d/%d", ci->ndm_used/hz,
+                       ci->ndm_confirmed/hz, ci->ndm_updated/hz);
+        }
+
+        if (tb[NDA_PROBES] && xshow_stats) {
+                uint32_t p = rta_getattr_u32(tb[NDA_PROBES]);
+                printf(" probes %u", p);
+        }
+
+        /*if (r->ndm_state)*/ {
+                int nud = r->ndm_state;
+                char c = ' ';
+#define PRINT_FLAG(f) \
+                if (nud & NUD_##f) { \
+                        printf("%c"#f, c); \
+                        c = ','; \
+                }
+                PRINT_FLAG(INCOMPLETE);
+                PRINT_FLAG(REACHABLE);
+                PRINT_FLAG(STALE);
+                PRINT_FLAG(DELAY);
+                PRINT_FLAG(PROBE);
+                PRINT_FLAG(FAILED);
+                PRINT_FLAG(NOARP);
+                PRINT_FLAG(PERMANENT);
+#undef PRINT_FLAG
+        }
+        bb_putchar('\n');
+
+        return 0;
+}
+
+static void ipneigh_reset_filter(void)
+{
+        memset(&G_filter, 0, sizeof(G_filter));
+        G_filter.state = ~0;
+}
+
+#define MAX_ROUNDS      10
+/* Return value becomes exitcode. It's okay to not return at all */
+static int FAST_FUNC ipneigh_list_or_flush(char **argv, int flush)
+{
+        static const char keywords[] ALIGN1 =
+                /* "ip neigh show/flush" parameters: */
+                "to\0" "dev\0"   "nud\0";
+        enum {
+                KW_to, KW_dev, KW_nud,
+        };
+        struct rtnl_handle rth;
+        struct ndmsg ndm = { 0 };
+        char *filter_dev = NULL;
+        int state_given = 0;
+        int arg;
+
+        ipneigh_reset_filter();
+
+        if (flush && !*argv)
+                bb_error_msg_and_die(bb_msg_requires_arg, "\"ip neigh flush\"");
+
+        if (!G_filter.family)
+                G_filter.family = preferred_family;
+
+        G_filter.state = (flush) ?
+                ~(NUD_PERMANENT|NUD_NOARP) : 0xFF & ~NUD_NOARP;
+
+        while (*argv) {
+                arg = index_in_substrings(keywords, *argv);
+                if (arg == KW_dev) {
+                        NEXT_ARG();
+                        filter_dev = *argv;
+                } else if (arg == KW_nud) {
+                        unsigned state;
+                        NEXT_ARG();
+                        if (!state_given) {
+                                state_given = 1;
+                                G_filter.state = 0;
+                        }
+                        if (strcmp(*argv, "all") == 0) {
+                                state = ~0;
+                                if (flush)
+                                        state &= ~NUD_NOARP;
+                        } else {
+                                state = nud_state_a2n(*argv);
+                        }
+                        if (state == 0)
+                                state = 0x100;
+                        G_filter.state |= state;
+                } else {
+                        if (arg == KW_to) {
+                                NEXT_ARG();
+                        }
+                        get_prefix(&G_filter.pfx, *argv, G_filter.family);
+                        if (G_filter.family == AF_UNSPEC)
+                                G_filter.family = G_filter.pfx.family;
+                }
+                argv++;
+        }
+
+        xrtnl_open(&rth);
+        ll_init_map(&rth);
+
+        if (filter_dev)  {
+                G_filter.index = xll_name_to_index(filter_dev);
+                if (G_filter.index == 0) {
+                        bb_error_msg_and_die("can't find device '%s'", filter_dev);
+                }
+        }
+
+        if (flush) {
+                int round = 0;
+                char flushb[4096-512];
+                G_filter.flushb = flushb;
+                G_filter.flushp = 0;
+                G_filter.flushe = sizeof(flushb);
+                G_filter.state &= ~NUD_FAILED;
+                G_filter.rth = &rth;
+
+                while (round < MAX_ROUNDS) {
+                        if (xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETNEIGH) < 0) {
+                                bb_perror_msg_and_die("can't send dump request");
+                        }
+                        G_filter.flushed = 0;
+                        if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
+                                bb_perror_msg_and_die("flush terminated");
+                        }
+                        if (G_filter.flushed == 0) {
+                                if (round == 0)
+                                        puts("Nothing to flush");
+                                else
+                                        printf("*** Flush is complete after %d round(s) ***\n", round);
+                                return 0;
+                        }
+                        round++;
+                        if (flush_update() < 0)
+                                xfunc_die();
+                        printf("\n*** Round %d, deleting %d entries ***\n", round, G_filter.flushed);
+                }
+                bb_error_msg_and_die("*** Flush not complete bailing out after %d rounds", MAX_ROUNDS);
+        }
+
+        ndm.ndm_family = G_filter.family;
+
+        if (rtnl_dump_request(&rth, RTM_GETNEIGH, &ndm, sizeof(struct ndmsg)) < 0) {
+                bb_perror_msg_and_die("can't send dump request");
+        }
+
+        if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
+                bb_error_msg_and_die("dump terminated");
+        }
+
+        return 0;
+}
+
+/* Return value becomes exitcode. It's okay to not return at all */
+int FAST_FUNC do_ipneigh(char **argv)
+{
+        static const char ip_neigh_commands[] ALIGN1 =
+                /*0-1*/ "show\0"  "flush\0";
+        int command_num;
+
+        if (!*argv)
+                return ipneigh_list_or_flush(argv, 0);
+
+        command_num = index_in_substrings(ip_neigh_commands, *argv);
+        switch (command_num) {
+                case 0: /* show */
+                        return ipneigh_list_or_flush(argv + 1, 0);
+                case 1: /* flush */
+                        return ipneigh_list_or_flush(argv + 1, 1);
+        }
+        invarg_1_to_2(*argv, applet_name);
+        return 1;
+}
diff --git a/networking/libiproute/iproute.c b/networking/libiproute/iproute.c
index 6ecd5f719..d232ee6fd 100644
--- a/networking/libiproute/iproute.c
+++ b/networking/libiproute/iproute.c
@@ -55,35 +55,12 @@ static int flush_update(void)
         return 0;
 }
 
-static unsigned get_hz(void)
-{
-        static unsigned hz_internal;
-        FILE *fp;
-
-        if (hz_internal)
-                return hz_internal;
-
-        fp = fopen_for_read("/proc/net/psched");
-        if (fp) {
-                unsigned nom, denom;
-
-                if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
-                        if (nom == 1000000)
-                                hz_internal = denom;
-                fclose(fp);
-        }
-        if (!hz_internal)
-                hz_internal = bb_clk_tck();
-        return hz_internal;
-}
-
 static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
                 struct nlmsghdr *n, void *arg UNUSED_PARAM)
 {
         struct rtmsg *r = NLMSG_DATA(n);
         int len = n->nlmsg_len;
         struct rtattr *tb[RTA_MAX+1];
-        char abuf[256];
         inet_prefix dst;
         inet_prefix src;
         int host_len = -1;
@@ -217,7 +194,7 @@ static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
 
                 if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
                         if (flush_update())
-                                bb_error_msg_and_die("flush");
+                                xfunc_die();
                 }
                 fn = (void*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
                 memcpy(fn, n, n->nlmsg_len);
@@ -240,17 +217,15 @@ static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
 
         if (tb[RTA_DST]) {
                 if (r->rtm_dst_len != host_len) {
-                        printf("%s/%u ", rt_addr_n2a(r->rtm_family,
-                                                RTA_DATA(tb[RTA_DST]),
-                                                abuf, sizeof(abuf)),
-                                        r->rtm_dst_len
-                                        );
+                        printf("%s/%u ",
+                                rt_addr_n2a(r->rtm_family, RTA_DATA(tb[RTA_DST])),
+                                r->rtm_dst_len
+                        );
                 } else {
                         printf("%s ", format_host(r->rtm_family,
                                                 RTA_PAYLOAD(tb[RTA_DST]),
-                                                RTA_DATA(tb[RTA_DST]),
-                                                abuf, sizeof(abuf))
-                                        );
+                                                RTA_DATA(tb[RTA_DST]))
+                        );
                 }
         } else if (r->rtm_dst_len) {
                 printf("0/%d ", r->rtm_dst_len);
@@ -259,17 +234,15 @@ static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
         }
         if (tb[RTA_SRC]) {
                 if (r->rtm_src_len != host_len) {
-                        printf("from %s/%u ", rt_addr_n2a(r->rtm_family,
-                                                RTA_DATA(tb[RTA_SRC]),
-                                                abuf, sizeof(abuf)),
-                                        r->rtm_src_len
-                                        );
+                        printf("from %s/%u ",
+                                rt_addr_n2a(r->rtm_family, RTA_DATA(tb[RTA_SRC])),
+                                r->rtm_src_len
+                        );
                 } else {
                         printf("from %s ", format_host(r->rtm_family,
                                                 RTA_PAYLOAD(tb[RTA_SRC]),
-                                                RTA_DATA(tb[RTA_SRC]),
-                                                abuf, sizeof(abuf))
-                                        );
+                                                RTA_DATA(tb[RTA_SRC]))
+                        );
                 }
         } else if (r->rtm_src_len) {
                 printf("from 0/%u ", r->rtm_src_len);
@@ -277,8 +250,8 @@ static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
         if (tb[RTA_GATEWAY] && G_filter.rvia.bitlen != host_len) {
                 printf("via %s ", format_host(r->rtm_family,
                                         RTA_PAYLOAD(tb[RTA_GATEWAY]),
-                                        RTA_DATA(tb[RTA_GATEWAY]),
-                                        abuf, sizeof(abuf)));
+                                        RTA_DATA(tb[RTA_GATEWAY]))
+                );
         }
         if (tb[RTA_OIF]) {
                 printf("dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
@@ -291,8 +264,7 @@ static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
                    and symbolic name will not be useful.
                  */
                 printf(" src %s ", rt_addr_n2a(r->rtm_family,
-                                        RTA_DATA(tb[RTA_PREFSRC]),
-                                        abuf, sizeof(abuf)));
+                                        RTA_DATA(tb[RTA_PREFSRC])));
         }
         if (tb[RTA_PRIORITY]) {
                 printf(" metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY]));
@@ -425,7 +397,7 @@ IF_FEATURE_IP_RULE(ARG_table,)
                         uint32_t prot;
                         NEXT_ARG();
                         if (rtnl_rtprot_a2n(&prot, *argv))
-                                invarg(*argv, "protocol");
+                                invarg_1_to_2(*argv, "protocol");
                         req.r.rtm_protocol = prot;
                         ok |= proto_ok;
 #if ENABLE_FEATURE_IP_RULE
@@ -433,7 +405,7 @@ IF_FEATURE_IP_RULE(ARG_table,)
                         uint32_t tid;
                         NEXT_ARG();
                         if (rtnl_rttable_a2n(&tid, *argv))
-                                invarg(*argv, "table");
+                                invarg_1_to_2(*argv, "table");
                         req.r.rtm_table = tid;
 #endif
                 } else if (arg == ARG_dev || arg == ARG_oif) {
@@ -619,7 +591,7 @@ static int iproute_list_or_flush(char **argv, int flush)
                         //G_filter.protocolmask = -1;
                         if (rtnl_rtprot_a2n(&prot, *argv)) {
                                 if (index_in_strings(keywords, *argv) != KW_all)
-                                        invarg(*argv, "protocol");
+                                        invarg_1_to_2(*argv, "protocol");
                                 prot = 0;
                                 //G_filter.protocolmask = 0;
                         }
@@ -644,10 +616,10 @@ static int iproute_list_or_flush(char **argv, int flush)
 #if ENABLE_FEATURE_IP_RULE
                                 uint32_t tid;
                                 if (rtnl_rttable_a2n(&tid, *argv))
-                                        invarg(*argv, "table");
+                                        invarg_1_to_2(*argv, "table");
                                 G_filter.tb = tid;
 #else
-                                invarg(*argv, "table");
+                                invarg_1_to_2(*argv, "table");
 #endif
                         }
                 } else if (arg == KW_cache) {
@@ -954,7 +926,7 @@ int FAST_FUNC do_iproute(char **argv)
                 case 11: /* flush */
                         return iproute_list_or_flush(argv+1, 1);
                 default:
-                        bb_error_msg_and_die("unknown command %s", *argv);
+                        invarg_1_to_2(*argv, applet_name);
         }
 
         return iproute_modify(cmd, flags, argv+1);
diff --git a/networking/libiproute/iprule.c b/networking/libiproute/iprule.c
index 774a3e220..dba64346f 100644
--- a/networking/libiproute/iprule.c
+++ b/networking/libiproute/iprule.c
@@ -44,7 +44,6 @@ static int FAST_FUNC print_rule(const struct sockaddr_nl *who UNUSED_PARAM,
         int len = n->nlmsg_len;
         int host_len = -1;
         struct rtattr * tb[RTA_MAX+1];
-        char abuf[256];
 
         if (n->nlmsg_type != RTM_NEWRULE)
                 return 0;
@@ -71,16 +70,14 @@ static int FAST_FUNC print_rule(const struct sockaddr_nl *who UNUSED_PARAM,
         printf("from ");
         if (tb[RTA_SRC]) {
                 if (r->rtm_src_len != host_len) {
-                        printf("%s/%u", rt_addr_n2a(r->rtm_family,
-                                                        RTA_DATA(tb[RTA_SRC]),
-                                                        abuf, sizeof(abuf)),
+                        printf("%s/%u",
+                                rt_addr_n2a(r->rtm_family, RTA_DATA(tb[RTA_SRC])),
                                 r->rtm_src_len
                         );
                 } else {
                         fputs(format_host(r->rtm_family,
                                                 RTA_PAYLOAD(tb[RTA_SRC]),
-                                                RTA_DATA(tb[RTA_SRC]),
-                                                abuf, sizeof(abuf)),
+                                                RTA_DATA(tb[RTA_SRC])),
                                 stdout
                         );
                 }
@@ -94,15 +91,13 @@ static int FAST_FUNC print_rule(const struct sockaddr_nl *who UNUSED_PARAM,
         if (tb[RTA_DST]) {
                 if (r->rtm_dst_len != host_len) {
                         printf("to %s/%u ", rt_addr_n2a(r->rtm_family,
-                                                         RTA_DATA(tb[RTA_DST]),
-                                                         abuf, sizeof(abuf)),
+                                                         RTA_DATA(tb[RTA_DST])),
                                 r->rtm_dst_len
                                 );
                 } else {
                         printf("to %s ", format_host(r->rtm_family,
                                                        RTA_PAYLOAD(tb[RTA_DST]),
-                                                       RTA_DATA(tb[RTA_DST]),
-                                                       abuf, sizeof(abuf)));
+                                                       RTA_DATA(tb[RTA_DST])));
                 }
         } else if (r->rtm_dst_len) {
                 printf("to 0/%d ", r->rtm_dst_len);
@@ -139,8 +134,8 @@ static int FAST_FUNC print_rule(const struct sockaddr_nl *who UNUSED_PARAM,
                         printf("map-to %s ",
                                 format_host(r->rtm_family,
                                             RTA_PAYLOAD(tb[RTA_GATEWAY]),
-                                            RTA_DATA(tb[RTA_GATEWAY]),
-                                            abuf, sizeof(abuf)));
+                                            RTA_DATA(tb[RTA_GATEWAY]))
+                        );
                 } else
                         printf("masquerade");
         } else if (r->rtm_type != RTN_UNICAST)
@@ -214,7 +209,7 @@ static int iprule_modify(int cmd, char **argv)
         while (*argv) {
                 key = index_in_substrings(keywords, *argv) + 1;
                 if (key == 0) /* no match found in keywords array, bail out. */
-                        invarg(*argv, applet_name);
+                        invarg_1_to_2(*argv, applet_name);
                 if (key == ARG_from) {
                         inet_prefix dst;
                         NEXT_ARG();
@@ -239,7 +234,7 @@ static int iprule_modify(int cmd, char **argv)
                         uint32_t tos;
                         NEXT_ARG();
                         if (rtnl_dsfield_a2n(&tos, *argv))
-                                invarg(*argv, "TOS");
+                                invarg_1_to_2(*argv, "TOS");
                         req.r.rtm_tos = tos;
                 } else if (key == ARG_fwmark) {
                         uint32_t fwmark;
@@ -250,7 +245,7 @@ static int iprule_modify(int cmd, char **argv)
                         uint32_t realm;
                         NEXT_ARG();
                         if (get_rt_realms(&realm, *argv))
-                                invarg(*argv, "realms");
+                                invarg_1_to_2(*argv, "realms");
                         addattr32(&req.n, sizeof(req), RTA_FLOW, realm);
                 } else if (key == ARG_table ||
                            key == ARG_lookup
@@ -258,7 +253,7 @@ static int iprule_modify(int cmd, char **argv)
                         uint32_t tid;
                         NEXT_ARG();
                         if (rtnl_rttable_a2n(&tid, *argv))
-                                invarg(*argv, "table ID");
+                                invarg_1_to_2(*argv, "table ID");
                         req.r.rtm_table = tid;
                         table_ok = 1;
                 } else if (key == ARG_dev ||
@@ -281,7 +276,7 @@ static int iprule_modify(int cmd, char **argv)
                         if (key == ARG_help)
                                 bb_show_usage();
                         if (rtnl_rtntype_a2n(&type, *argv))
-                                invarg(*argv, "type");
+                                invarg_1_to_2(*argv, "type");
                         req.r.rtm_type = type;
                 }
                 argv++;
@@ -309,7 +304,7 @@ int FAST_FUNC do_iprule(char **argv)
         if (*argv) {
                 int cmd = index_in_substrings(ip_rule_commands, *argv);
                 if (cmd < 0)
-                        invarg(*argv, applet_name);
+                        invarg_1_to_2(*argv, applet_name);
                 argv++;
                 if (cmd < 2)
                         return iprule_modify((cmd == 0) ? RTM_NEWRULE : RTM_DELRULE, argv);
diff --git a/networking/libiproute/iptunnel.c b/networking/libiproute/iptunnel.c
index a65d5e579..eb136e435 100644
--- a/networking/libiproute/iptunnel.c
+++ b/networking/libiproute/iptunnel.c
@@ -294,7 +294,7 @@ static void parse_args(char **argv, int cmd, struct ip_tunnel_parm *p)
                         if (key != ARG_inherit) {
                                 uval = get_unsigned(*argv, "TTL");
                                 if (uval > 255)
-                                        invarg(*argv, "TTL must be <=255");
+                                        invarg_1_to_2(*argv, "TTL");
                                 p->iph.ttl = uval;
                         }
                 } else if (key == ARG_tos ||
@@ -305,7 +305,7 @@ static void parse_args(char **argv, int cmd, struct ip_tunnel_parm *p)
                         key = index_in_strings(keywords, *argv);
                         if (key != ARG_inherit) {
                                 if (rtnl_dsfield_a2n(&uval, *argv))
-                                        invarg(*argv, "TOS");
+                                        invarg_1_to_2(*argv, "TOS");
                                 p->iph.tos = uval;
                         } else
                                 p->iph.tos = 1;
@@ -404,22 +404,18 @@ static int do_del(char **argv)
 
 static void print_tunnel(struct ip_tunnel_parm *p)
 {
-        char s1[256];
-        char s2[256];
-        char s3[64];
-        char s4[64];
-
-        format_host(AF_INET, 4, &p->iph.daddr, s1, sizeof(s1));
-        format_host(AF_INET, 4, &p->iph.saddr, s2, sizeof(s2));
-        inet_ntop(AF_INET, &p->i_key, s3, sizeof(s3));
-        inet_ntop(AF_INET, &p->o_key, s4, sizeof(s4));
+        char s3[INET_ADDRSTRLEN];
+        char s4[INET_ADDRSTRLEN];
 
         printf("%s: %s/ip  remote %s  local %s ",
-               p->name,
-               p->iph.protocol == IPPROTO_IPIP ? "ip" :
-               (p->iph.protocol == IPPROTO_GRE ? "gre" :
-                (p->iph.protocol == IPPROTO_IPV6 ? "ipv6" : "unknown")),
-               p->iph.daddr ? s1 : "any", p->iph.saddr ? s2 : "any");
+                p->name,
+                p->iph.protocol == IPPROTO_IPIP ? "ip" :
+                        p->iph.protocol == IPPROTO_GRE ? "gre" :
+                        p->iph.protocol == IPPROTO_IPV6 ? "ipv6" :
+                        "unknown",
+                p->iph.daddr ? format_host(AF_INET, 4, &p->iph.daddr) : "any",
+                p->iph.saddr ? format_host(AF_INET, 4, &p->iph.saddr) : "any"
+        );
         if (p->link) {
                 char *n = do_ioctl_get_ifname(p->link);
                 if (n) {
@@ -442,9 +438,11 @@ static void print_tunnel(struct ip_tunnel_parm *p)
         if (!(p->iph.frag_off & htons(IP_DF)))
                 printf(" nopmtudisc");
 
+        inet_ntop(AF_INET, &p->i_key, s3, sizeof(s3));
+        inet_ntop(AF_INET, &p->o_key, s4, sizeof(s4));
         if ((p->i_flags & GRE_KEY) && (p->o_flags & GRE_KEY) && p->o_key == p->i_key)
                 printf(" key %s", s3);
-        else if ((p->i_flags | p->o_flags) & GRE_KEY) {
+        else {
                 if (p->i_flags & GRE_KEY)
                         printf(" ikey %s ", s3);
                 if (p->o_flags & GRE_KEY)
@@ -562,7 +560,7 @@ int FAST_FUNC do_iptunnel(char **argv)
         if (*argv) {
                 int key = index_in_substrings(keywords, *argv);
                 if (key < 0)
-                        invarg(*argv, applet_name);
+                        invarg_1_to_2(*argv, applet_name);
                 argv++;
                 if (key == ARG_add)
                         return do_add(SIOCADDTUNNEL, argv);
diff --git a/networking/libiproute/utils.c b/networking/libiproute/utils.c
index d0fe30605..42025bc66 100644
--- a/networking/libiproute/utils.c
+++ b/networking/libiproute/utils.c
@@ -13,6 +13,28 @@
 #include "utils.h"
 #include "inet_common.h"
 
+unsigned get_hz(void)
+{
+        static unsigned hz_internal;
+        FILE *fp;
+
+        if (hz_internal)
+                return hz_internal;
+
+        fp = fopen_for_read("/proc/net/psched");
+        if (fp) {
+                unsigned nom, denom;
+
+                if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
+                        if (nom == 1000000)
+                                hz_internal = denom;
+                fclose(fp);
+        }
+        if (!hz_internal)
+                hz_internal = bb_clk_tck();
+        return hz_internal;
+}
+
 unsigned get_unsigned(char *arg, const char *errmsg)
 {
         unsigned long res;
@@ -25,7 +47,7 @@ unsigned get_unsigned(char *arg, const char *errmsg)
                         return res;
                 }
         }
-        invarg(arg, errmsg); /* does not return */
+        invarg_1_to_2(arg, errmsg); /* does not return */
 }
 
 uint32_t get_u32(char *arg, const char *errmsg)
@@ -40,7 +62,7 @@ uint32_t get_u32(char *arg, const char *errmsg)
                         return res;
                 }
         }
-        invarg(arg, errmsg); /* does not return */
+        invarg_1_to_2(arg, errmsg); /* does not return */
 }
 
 uint16_t get_u16(char *arg, const char *errmsg)
@@ -55,7 +77,7 @@ uint16_t get_u16(char *arg, const char *errmsg)
                         return res;
                 }
         }
-        invarg(arg, errmsg); /* does not return */
+        invarg_1_to_2(arg, errmsg); /* does not return */
 }
 
 int get_addr_1(inet_prefix *addr, char *name, int family)
@@ -208,12 +230,12 @@ uint32_t get_addr32(char *name)
 
 void incomplete_command(void)
 {
-        bb_error_msg_and_die("command line is not complete, try option \"help\"");
+        bb_error_msg_and_die("command line is not complete, try \"help\"");
 }
 
-void invarg(const char *arg, const char *opt)
+void invarg_1_to_2(const char *arg, const char *opt)
 {
-        bb_error_msg_and_die(bb_msg_invalid_arg, arg, opt);
+        bb_error_msg_and_die(bb_msg_invalid_arg_to, arg, opt);
 }
 
 void duparg(const char *key, const char *arg)
@@ -254,20 +276,21 @@ int inet_addr_match(const inet_prefix *a, const inet_prefix *b, int bits)
         return 0;
 }
 
-const char *rt_addr_n2a(int af,
-                void *addr, char *buf, int buflen)
+const char *rt_addr_n2a(int af, void *addr)
 {
         switch (af) {
         case AF_INET:
         case AF_INET6:
-                return inet_ntop(af, addr, buf, buflen);
+                return inet_ntop(af, addr,
+                        auto_string(xzalloc(INET6_ADDRSTRLEN)), INET6_ADDRSTRLEN
+                );
         default:
                 return "???";
         }
 }
 
 #ifdef RESOLVE_HOSTNAMES
-const char *format_host(int af, int len, void *addr, char *buf, int buflen)
+const char *format_host(int af, int len, void *addr)
 {
         if (resolve_hosts) {
                 struct hostent *h_ent;
@@ -286,11 +309,10 @@ const char *format_host(int af, int len, void *addr, char *buf, int buflen)
                 if (len > 0) {
                         h_ent = gethostbyaddr(addr, len, af);
                         if (h_ent != NULL) {
-                                safe_strncpy(buf, h_ent->h_name, buflen);
-                                return buf;
+                                return auto_string(xstrdup(h_ent->h_name));
                         }
                 }
         }
-        return rt_addr_n2a(af, addr, buf, buflen);
+        return rt_addr_n2a(af, addr);
 }
 #endif
diff --git a/networking/libiproute/utils.h b/networking/libiproute/utils.h
index 5fb4a862c..408d5f65f 100644
--- a/networking/libiproute/utils.h
+++ b/networking/libiproute/utils.h
@@ -66,15 +66,15 @@ extern unsigned get_unsigned(char *arg, const char *errmsg);
 extern uint32_t get_u32(char *arg, const char *errmsg);
 extern uint16_t get_u16(char *arg, const char *errmsg);
 
-extern const char *rt_addr_n2a(int af, void *addr, char *buf, int buflen);
+extern const char *rt_addr_n2a(int af, void *addr);
 #ifdef RESOLVE_HOSTNAMES
-extern const char *format_host(int af, int len, void *addr, char *buf, int buflen);
+extern const char *format_host(int af, int len, void *addr);
 #else
-#define format_host(af, len, addr, buf, buflen) \
-        rt_addr_n2a(af, addr, buf, buflen)
+#define format_host(af, len, addr) \
+        rt_addr_n2a(af, addr)
 #endif
 
-void invarg(const char *, const char *) NORETURN;
+void invarg_1_to_2(const char *, const char *) NORETURN;
 void duparg(const char *, const char *) NORETURN;
 void duparg2(const char *, const char *) NORETURN;
 int inet_addr_match(const inet_prefix *a, const inet_prefix *b, int bits);
@@ -85,6 +85,8 @@ int dnet_pton(int af, const char *src, void *addr);
 const char *ipx_ntop(int af, const void *addr, char *str, size_t len);
 int ipx_pton(int af, const char *src, void *addr);
 
+unsigned get_hz(void);
+
 POP_SAVED_FUNCTION_VISIBILITY
 
 #endif
diff --git a/networking/nbd-client.c b/networking/nbd-client.c
index a601430b6..70869d651 100644
--- a/networking/nbd-client.c
+++ b/networking/nbd-client.c
@@ -57,9 +57,8 @@ int nbdclient_main(int argc, char **argv)
                 uint32_t flags;
                 char data[124];
         } nbd_header;
-        struct bug_check {
-                char c[offsetof(struct nbd_header_t, data) == 8+8+8+4 ? 1 : -1];
-        };
+
+        BUILD_BUG_ON(offsetof(struct nbd_header_t, data) != 8+8+8+4);
 
         // Parse command line stuff (just a stub now)
         if (argc != 4)
diff --git a/networking/slattach.c b/networking/slattach.c
index a500da6d0..14e0c1941 100644
--- a/networking/slattach.c
+++ b/networking/slattach.c
@@ -27,7 +27,7 @@
 //usage:     "\n        -F      Disable RTS/CTS flow control"
 
 #include "libbb.h"
-#include "libiproute/utils.h" /* invarg() */
+#include "libiproute/utils.h" /* invarg_1_to_2() */
 
 struct globals {
         int handle;
@@ -175,7 +175,7 @@ int slattach_main(int argc UNUSED_PARAM, char **argv)
         encap = index_in_strings(proto_names, proto);
 
         if (encap < 0)
-                invarg(proto, "protocol");
+                invarg_1_to_2(proto, "protocol");
         if (encap > 3)
                 encap = 8;
 
@@ -183,7 +183,7 @@ int slattach_main(int argc UNUSED_PARAM, char **argv)
         if (opt & OPT_s_baud) {
                 baud_code = tty_value_to_baud(xatoi(baud_str));
                 if (baud_code < 0)
-                        invarg(baud_str, "baud rate");
+                        invarg_1_to_2(baud_str, "baud rate");
         }
 
         /* Trap signals in order to restore tty states upon exit */
diff --git a/networking/tc.c b/networking/tc.c
index 6d1fef993..c84c18a67 100644
--- a/networking/tc.c
+++ b/networking/tc.c
@@ -459,14 +459,14 @@ int tc_main(int argc UNUSED_PARAM, char **argv)
 
         obj = index_in_substrings(objects, *argv++);
 
-        if (obj < OBJ_qdisc)
+        if (obj < 0)
                 bb_show_usage();
         if (!*argv)
                 cmd = CMD_show; /* list is the default */
         else {
                 cmd = index_in_substrings(commands, *argv);
                 if (cmd < 0)
-                        bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+                        invarg_1_to_2(*argv, argv[-1]);
                 argv++;
         }
         memset(&msg, 0, sizeof(msg));
@@ -489,7 +489,7 @@ int tc_main(int argc UNUSED_PARAM, char **argv)
                         NEXT_ARG();
                         /* We don't care about duparg2("qdisc handle",*argv) for now */
                         if (get_qdisc_handle(&filter_qdisc, *argv))
-                                invarg(*argv, "qdisc");
+                                invarg_1_to_2(*argv, "qdisc");
                 } else
                 if (obj != OBJ_qdisc
                  && (arg == ARG_root
@@ -499,7 +499,7 @@ int tc_main(int argc UNUSED_PARAM, char **argv)
                 ) {
                         /* nothing */
                 } else {
-                        invarg(*argv, "command");
+                        invarg_1_to_2(*argv, "command");
                 }
                 NEXT_ARG();
                 if (arg == ARG_root) {
@@ -513,7 +513,7 @@ int tc_main(int argc UNUSED_PARAM, char **argv)
                         if (msg.tcm_parent)
                                 duparg(*argv, "parent");
                         if (get_tc_classid(&handle, *argv))
-                                invarg(*argv, "parent");
+                                invarg_1_to_2(*argv, "parent");
                         msg.tcm_parent = handle;
                         if (obj == OBJ_filter)
                                 filter_parent = handle;
@@ -538,7 +538,7 @@ int tc_main(int argc UNUSED_PARAM, char **argv)
                         if (filter_proto)
                                 duparg(*argv, "protocol");
                         if (ll_proto_a2n(&tmp, *argv))
-                                invarg(*argv, "protocol");
+                                invarg_1_to_2(*argv, "protocol");
                         filter_proto = tmp;
                 }
         }
diff --git a/networking/telnet.c b/networking/telnet.c
index 3bb6fb1ba..944cf1bd6 100644
--- a/networking/telnet.c
+++ b/networking/telnet.c
@@ -110,9 +110,7 @@ struct globals {
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 #define INIT_G() do { \
-        struct G_sizecheck { \
-                char G_sizecheck[sizeof(G) > COMMON_BUFSIZE ? -1 : 1]; \
-        }; \
+        BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
 } while (0)