Changeset 3621 for branches/3.3/mindi-busybox/networking – MondoRescue

branches/3.3/mindi-busybox/networking/Config.src

-              r3232
+              r3621
       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"
 …
       "Range: bytes=NNN-[MMM]" header. Allows for resuming interrupted
       downloads, seeking in multimedia players etc.
-config FEATURE_HTTPD_USE_SENDFILE
-    bool "Use sendfile system call"
-    default y
-    depends on HTTPD
-    help
-      When enabled, httpd will use the kernel sendfile() function
-      instead of read/write loop.
 config FEATURE_HTTPD_SETUID
 …
 config FEATURE_INETD_RPC
     bool "Support RPC services"
     default y
+    default n  # very rarely used, and needs Sun RPC support in libc
     depends on INETD
     select FEATURE_HAVE_RPC
 …
       Add support for routing table management to "ip".
+config FEATURE_IP_ROUTE_DIR
+    string "ip route configuration directory"
+    default "/etc/iproute2"
+    depends on FEATURE_IP_ROUTE
+    help
+      Location of the "ip" applet routing configuration.
 config FEATURE_IP_TUNNEL
     bool "ip tunnel"
 …
     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
 …
       ip tunnel -> iptunnel
       ip rule   -> iprule
+      ip neigh  -> ipneigh
       Say N unless you desparately need the short form of the ip
 …
     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"
 …
       Make ntpd usable as a NTP server. If you disable this option
       ntpd will be usable only as a NTP client.
+config FEATURE_NTPD_CONF
+    bool "Make ntpd understand /etc/ntp.conf"
+    default y
+    depends on NTPD
+    help
+      Make ntpd look in /etc/ntp.conf for peers. Only "server address"
+      is supported.
 config PSCAN
 …
       Note that for busybox telnetd to work you need several things:
       First of all, your kernel needs:
+          UNIX98_PTYS=y
+          DEVPTS_FS=y
+          CONFIG_UNIX98_PTYS=y
       Next, you need a /dev/pts directory on your root filesystem:
 …
       Creates, removes, and configures VLAN interfaces
-config WGET
-    bool "wget"
-    default y
-    help
-      wget is a utility for non-interactive download of files from HTTP
-      and FTP servers.
-config FEATURE_WGET_STATUSBAR
-    bool "Enable a nifty process meter (+2k)"
-    default y
-    depends on WGET
-    help
-      Enable the transfer progress bar for wget transfers.
-config FEATURE_WGET_AUTHENTICATION
-    bool "Enable HTTP authentication"
-    default y
-    depends on WGET
-    help
-      Support authenticated HTTP transfers.
-config FEATURE_WGET_LONG_OPTIONS
-    bool "Enable long options"
-    default y
-    depends on WGET && LONG_OPTS
-    help
-      Support long options for the wget applet.
-config FEATURE_WGET_TIMEOUT
-    bool "Enable read timeout option -T SEC"
-    default y
-    depends on WGET
-    help
-      Supports network read timeout for wget, so that wget will give
-      up and timeout when reading network data, through the -T command
-      line option.  Currently only network data read timeout is
-      supported (i.e., timeout is not applied to the DNS nor TCP
-      connection initialization).  When FEATURE_WGET_LONG_OPTIONS is
-      also enabled, the --timeout option will work in addition to -T.
 config ZCIP
     bool "zcip"

branches/3.3/mindi-busybox/networking/Kbuild.src

r3232	r3621
42	42	lib-$(CONFIG_TUNCTL) += tunctl.o
43	43	lib-$(CONFIG_VCONFIG) += vconfig.o
44		~~lib-$(CONFIG_WGET) += wget.o~~
45	44	lib-$(CONFIG_ZCIP) += zcip.o
46	45

branches/3.3/mindi-busybox/networking/arp.c

-              r3232
+              r3621
 //usage:       "Manipulate ARP cache\n"
 //usage:       "\n  -a      Display (all) hosts"
 //usage:       "\n  -s      Set new ARP entry"
 //usage:       "\n  -d      Delete a specified entry"
+//usage:       "\n  -d      Delete ARP entry"
+//usage:       "\n  -s      Set new entry"
 //usage:       "\n  -v      Verbose"
 //usage:       "\n  -n      Don't resolve names"
 //usage:       "\n  -i IF       Network interface"
 //usage:       "\n  -D      Read <hwaddr> from given device"
+//usage:       "\n  -D      Read HWADDR from IFACE"
 //usage:       "\n  -A,-p AF    Protocol family"
 //usage:       "\n  -H HWTYPE   Hardware address type"
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include "inet_common.h"
 …
     const char *device;      /* current device */
     smallint hw_set;         /* flag if hw-type was set (-H) */
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define ap         (G.ap        )
 #define hw         (G.hw        )
 …
 #define hw_set     (G.hw_set    )
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     device = ""; \
 } while (0)
 …
 /* Get the hardware address to a specified interface name */
+static void arp_getdevhw(char *ifname, struct sockaddr *sa,
+                        const struct hwtype *hwt)
+static void arp_getdevhw(char *ifname, struct sockaddr *sa)
+{
     struct ifreq ifr;
 …
     strcpy(ifr.ifr_name, ifname);
     ioctl_or_perror_and_die(sockfd, SIOCGIFHWADDR, &ifr,
                     "cant get HW-Address for '%s'", ifname);
     if (hwt && (ifr.ifr_hwaddr.sa_family != hw->type)) {
+                    "can't get HW-Address for '%s'", ifname);
+    if (hw_set && (ifr.ifr_hwaddr.sa_family != hw->type)) {
         bb_error_msg_and_die("protocol type mismatch");
+    }
 …
+        }
         bb_error_msg("device '%s' has HW address %s '%s'",
                     ifname, xhw->name,
                     xhw->print((unsigned char *) &ifr.ifr_hwaddr.sa_data));
+                ifname, xhw->name,
+                xhw->print((unsigned char *) &ifr.ifr_hwaddr.sa_data));
+    }
+}
 …
+    }
     if (option_mask32 & ARP_OPT_D) {
         arp_getdevhw(*args++, &req.arp_ha, hw_set ? hw : NULL);
+        arp_getdevhw(*args++, &req.arp_ha);
     } else {
         if (hw->input(*args++, &req.arp_ha) < 0) {
 …
+    }
     if (option_mask32 & ARP_OPT_v)
         printf("Entries: %d\tSkipped: %d\tFound: %d\n",
+        printf("Entries: %u\tSkipped: %u\tFound: %u\n",
                 entries, entries - shown, shown);
     if (!shown) {
         if (hw_set || host || device[0])
             printf("No match found in %d entries\n", entries);
+            printf("No match found in %u entries\n", entries);
+    }
     if (ENABLE_FEATURE_CLEAN_UP) {
 …
 int arp_main(int argc UNUSED_PARAM, char **argv)
+{
     const char *hw_type = "ether";
+    const char *hw_type;
     const char *protocol;
     unsigned opts;
 …
     xmove_fd(xsocket(AF_INET, SOCK_DGRAM, 0), sockfd);
     ap = get_aftype(DFLT_AF);
+    if (!ap)
+        bb_error_msg_and_die("%s: %s not supported", DFLT_AF, "address family");
+    /* Defaults are always supported */
+    //if (!ap)
+    //  bb_error_msg_and_die("%s: %s not supported", DFLT_AF, "address family");
+    hw = get_hwtype(DFLT_HW);
+    //if (!hw)
+    //  bb_error_msg_and_die("%s: %s not supported", DFLT_HW, "hardware type");
     opts = getopt32(argv, "A:p:H:t:i:adnDsv", &protocol, &protocol,
 …
     if (opts & (ARP_OPT_A | ARP_OPT_p)) {
         ap = get_aftype(protocol);
         if (ap == NULL)
+        if (!ap)
             bb_error_msg_and_die("%s: unknown %s", protocol, "address family");
+    }
     if (opts & (ARP_OPT_A | ARP_OPT_p)) {
+    if (opts & (ARP_OPT_H | ARP_OPT_t)) {
         hw = get_hwtype(hw_type);
         if (hw == NULL)
+        if (!hw)
             bb_error_msg_and_die("%s: unknown %s", hw_type, "hardware type");
         hw_set = 1;
 …
         bb_error_msg_and_die("%s: kernel only supports 'inet'", ap->name);
+    }
-    /* If no hw type specified get default */
-    if (!hw) {
-        hw = get_hwtype(DFLT_HW);
-        if (!hw)
-            bb_error_msg_and_die("%s: %s not supported", DFLT_HW, "hardware type");
+    }
     if (hw->alen <= 0) {
         bb_error_msg_and_die("%s: %s without ARP support",
 …
         return arp_del(argv);
+    }
     //if (opts & ARP_OPT_a) - default
     return arp_show(argv[0]);

branches/3.3/mindi-busybox/networking/arping.c

-              r3232
+              r3621
 //usage:     "\n    -q      Quiet"
 //usage:     "\n    -b      Keep broadcasting, don't go unicast"
 //usage:     "\n    -D      Duplicated address detection mode"
+//usage:     "\n    -D      Exit with 1 if DST_IP replies"
 //usage:     "\n    -U      Unsolicited ARP mode, update your neighbors"
 //usage:     "\n    -A      ARP answer mode, update your neighbors"
 //usage:     "\n    -c N        Stop after sending N ARP requests"
 //usage:     "\n    -w TIMEOUT  Time to wait for ARP reply, seconds"
+//usage:     "\n    -w TIMEOUT  Seconds to wait for ARP reply"
 //usage:     "\n    -I IFACE    Interface to use (default eth0)"
 //usage:     "\n    -s SRC_IP   Sender IP address"
 …
 #include "libbb.h"
+#include "common_bufsiz.h"
 /* We don't expect to see 1000+ seconds delay, unsigned is enough */
 …
     unsigned req_recv;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define src        (G.src       )
 #define dst        (G.dst       )
 …
 #define req_recv   (G.req_recv  )
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     count = -1; \
 } while (0)
 …
+}
 static bool recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)
+static void recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)
+{
     struct arphdr *ah = (struct arphdr *) buf;
 …
      && FROM->sll_pkttype != PACKET_BROADCAST
      && FROM->sll_pkttype != PACKET_MULTICAST)
         return false;
+        return;
     /* Only these types are recognized */
     if (ah->ar_op != htons(ARPOP_REQUEST) && ah->ar_op != htons(ARPOP_REPLY))
         return false;
+        return;
     /* ARPHRD check and this darned FDDI hack here :-( */
     if (ah->ar_hrd != htons(FROM->sll_hatype)
      && (FROM->sll_hatype != ARPHRD_FDDI || ah->ar_hrd != htons(ARPHRD_ETHER)))
         return false;
+        return;
     /* Protocol must be IP. */
 …
      || (ah->ar_hln != me.sll_halen)
      || (len < (int)(sizeof(*ah) + 2 * (4 + ah->ar_hln))))
         return false;
+        return;
     move_from_unaligned32(src_ip.s_addr, p + ah->ar_hln);
 …
     if (dst.s_addr != src_ip.s_addr)
         return false;
+        return;
     if (!(option_mask32 & DAD)) {
         if ((src.s_addr != dst_ip.s_addr)
             || (memcmp(p + ah->ar_hln + 4, &me.sll_addr, ah->ar_hln)))
             return false;
+         || (memcmp(p + ah->ar_hln + 4, &me.sll_addr, ah->ar_hln)))
+            return;
     } else {
         /* DAD packet was:
 …
         if ((memcmp(p, &me.sll_addr, me.sll_halen) == 0)
          || (src.s_addr && src.s_addr != dst_ip.s_addr))
             return false;
+            return;
+    }
     if (!(option_mask32 & QUIET)) {
         int s_printed = 0;
         printf("%scast re%s from %s [%s]",
+        printf("%scast re%s from %s [%02x:%02x:%02x:%02x:%02x:%02x]",
             FROM->sll_pkttype == PACKET_HOST ? "Uni" : "Broad",
             ah->ar_op == htons(ARPOP_REPLY) ? "ply" : "quest",
             inet_ntoa(src_ip),
+            ether_ntoa((struct ether_addr *) p));
+            p[0], p[1], p[2], p[3], p[4], p[5]
+        );
         if (dst_ip.s_addr != src.s_addr) {
             printf("for %s ", inet_ntoa(dst_ip));
 …
+        }
         if (memcmp(p + ah->ar_hln + 4, me.sll_addr, ah->ar_hln)) {
+            unsigned char *pp = p + ah->ar_hln + 4;
             if (!s_printed)
                 printf("for ");
+            printf("[%s]",
+                ether_ntoa((struct ether_addr *) p + ah->ar_hln + 4));
+            printf("[%02x:%02x:%02x:%02x:%02x:%02x]",
+                pp[0], pp[1], pp[2], pp[3], pp[4], pp[5]
+            );
+        }
 …
             printf(" %u.%03ums\n", diff / 1000, diff % 1000);
         } else {
             printf(" UNSOLICITED?\n");
+            puts(" UNSOLICITED?");
+        }
         fflush_all();
 …
         option_mask32 |= UNICASTING;
+    }
-    return true;
+}
 …
     //xsetuid(getuid());
-    err_str = xasprintf("interface %s %%s", device);
+    {
         unsigned opt;
 …
     target = argv[optind];
+    err_str = xasprintf("interface %s %%s", device);
     xfunc_error_retval = 2;
 …
             saddr.sin_addr = dst;
             if (setsockopt(probe_fd, SOL_SOCKET, SO_DONTROUTE, &const_int_1, sizeof(const_int_1)) == -1)
                 bb_perror_msg("setsockopt(SO_DONTROUTE)");
+            if (setsockopt_SOL_SOCKET_1(probe_fd, SO_DONTROUTE) != 0)
+                bb_perror_msg("setsockopt(%s)", "SO_DONTROUTE");
             xconnect(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr));
             getsockname(probe_fd, (struct sockaddr *) &saddr, &alen);

branches/3.3/mindi-busybox/networking/brctl.c

-              r3232
+              r3621
 #if ENABLE_FEATURE_BRCTL_FANCY
+# include <linux/if_bridge.h>
+/* #include <linux/if_bridge.h>
+ * breaks on musl: we already included netinet/in.h in libbb.h,
+ * if we include <linux/if_bridge.h> here, we get this:
+ * In file included from /usr/include/linux/if_bridge.h:18,
+ *                  from networking/brctl.c:67:
+ * /usr/include/linux/in6.h:32: error: redefinition of 'struct in6_addr'
+ * /usr/include/linux/in6.h:49: error: redefinition of 'struct sockaddr_in6'
+ * /usr/include/linux/in6.h:59: error: redefinition of 'struct ipv6_mreq'
+ */
+/* From <linux/if_bridge.h> */
+#define BRCTL_GET_VERSION 0
+#define BRCTL_GET_BRIDGES 1
+#define BRCTL_ADD_BRIDGE 2
+#define BRCTL_DEL_BRIDGE 3
+#define BRCTL_ADD_IF 4
+#define BRCTL_DEL_IF 5
+#define BRCTL_GET_BRIDGE_INFO 6
+#define BRCTL_GET_PORT_LIST 7
+#define BRCTL_SET_BRIDGE_FORWARD_DELAY 8
+#define BRCTL_SET_BRIDGE_HELLO_TIME 9
+#define BRCTL_SET_BRIDGE_MAX_AGE 10
+#define BRCTL_SET_AGEING_TIME 11
+#define BRCTL_SET_GC_INTERVAL 12
+#define BRCTL_GET_PORT_INFO 13
+#define BRCTL_SET_BRIDGE_STP_STATE 14
+#define BRCTL_SET_BRIDGE_PRIORITY 15
+#define BRCTL_SET_PORT_PRIORITY 16
+#define BRCTL_SET_PATH_COST 17
+#define BRCTL_GET_FDB_ENTRIES 18
+struct __bridge_info {
+    uint64_t designated_root;
+    uint64_t bridge_id;
+    uint32_t root_path_cost;
+    uint32_t max_age;
+    uint32_t hello_time;
+    uint32_t forward_delay;
+    uint32_t bridge_max_age;
+    uint32_t bridge_hello_time;
+    uint32_t bridge_forward_delay;
+    uint8_t  topology_change;
+    uint8_t  topology_change_detected;
+    uint8_t  root_port;
+    uint8_t  stp_enabled;
+    uint32_t ageing_time;
+    uint32_t gc_interval;
+    uint32_t hello_timer_value;
+    uint32_t tcn_timer_value;
+    uint32_t topology_change_timer_value;
+    uint32_t gc_timer_value;
+};
+/* end <linux/if_bridge.h> */
 /* FIXME: These 4 funcs are not really clean and could be improved */
 …
     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);
 …
         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);
 …
                         (unsigned long) bridx, MAX_PORTS);
             num = xioctl(fd, SIOCGIFBR, args);
             printf("bridge name\tbridge id\t\tSTP enabled\tinterfaces\n");
+            puts("bridge name\tbridge id\t\tSTP enabled\tinterfaces");
             for (i = 0; i < num; i++) {
                 char ifname[IFNAMSIZ];
 …
                 x = (unsigned char *) &bi.bridge_id;
                 for (j = 0; j < 8; j++) {
                     printf("%.2x", x[j]);
+                    printf("%02x", x[j]);
                     if (j == 1)
                         bb_putchar('.');
 …
             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);
 …
                 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,

branches/3.3/mindi-busybox/networking/dnsd.c

r3232	r3621
195	195	/* we assume (do not check) that query_string
196	196	* ends in ".in-addr.arpa" */
197		&& ~~strncmp(d->rip, query_string, strlen(d->rip)) == 0~~
	197	&& is_prefixed_with(query_string, d->rip)
198	198	) {
199	199	#if DEBUG

branches/3.3/mindi-busybox/networking/ether-wake.c

-              r3232
+              r3621
  *   doing so only works with adapters configured for unicast+broadcast Rx
  *   filter.  That configuration consumes more power.
 */
+ */
 //usage:#define ether_wake_trivial_usage
 //usage:       "[-b] [-i iface] [-p aa:bb:cc:dd[:ee:ff]] MAC"
+//usage:       "[-b] [-i IFACE] [-p aa:bb:cc:dd[:ee:ff]/a.b.c.d] MAC"
 //usage:#define ether_wake_full_usage "\n\n"
 //usage:       "Send a magic packet to wake up sleeping machines.\n"
 //usage:       "MAC must be a station address (00:11:22:33:44:55) or\n"
 //usage:       "a hostname with a known 'ethers' entry.\n"
 //usage:     "\n    -b      Send wake-up packet to the broadcast address"
 //usage:     "\n    -i iface    Interface to use (default eth0)"
 //usage:     "\n    -p pass     Append four or six byte password PW to the packet"
+//usage:     "\n    -b      Broadcast the packet"
+//usage:     "\n    -i IFACE    Interface to use (default eth0)"
+//usage:     "\n    -p PASSWORD Append four or six byte PASSWORD to the packet"
 #include "libbb.h"
 …
     if (eap) {
         bb_debug_msg("The target station address is %s\n\n", ether_ntoa(eap));
+#if !defined(__UCLIBC_MAJOR__) \
+ || __UCLIBC_MAJOR__ > 0 \
+ || __UCLIBC_MINOR__ > 9 \
+ || (__UCLIBC_MINOR__ == 9 && __UCLIBC_SUBLEVEL__ >= 30)
+#if !defined(__UCLIBC__) || UCLIBC_VERSION >= KERNEL_VERSION(0, 9, 30)
     } else if (ether_hostton(hostid, eaddr) == 0) {
         bb_debug_msg("Station address for hostname %s is %s\n\n", hostid, ether_ntoa(eaddr));
 …
+}
+static int get_fill(unsigned char *pkt, struct ether_addr *eaddr, int broadcast)
+#define PKT_HEADER_SIZE (20 + 16*6)
+static int fill_pkt_header(unsigned char *pkt, struct ether_addr *eaddr, int broadcast)
+{
     int i;
 …
+    }
     return 20 + 16*6; /* length of packet */
+    return PKT_HEADER_SIZE; /* length of packet */
+}
 …
     int s;  /* Raw socket */
     int pktsize;
     unsigned char outpack[1000];
+    unsigned char outpack[PKT_HEADER_SIZE + 6 /* max passwd size */ + 16 /* paranoia */];
     struct ether_addr eaddr;
 …
     /* fill out the header of the packet */
     pktsize = get_fill(outpack, &eaddr, flags /* & 1 OPT_BROADCAST */);
+    pktsize = fill_pkt_header(outpack, &eaddr, flags /* & 1 OPT_BROADCAST */);
     bb_debug_dump_packet(outpack, pktsize);

branches/3.3/mindi-busybox/networking/ftpd.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include <syslog.h>
 #include <netinet/tcp.h>
 …
     char msg_err[(sizeof("NNN " MSG_ERR) + 3) & 0xfffc];
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     /* Moved to main */ \
     /*strcpy(G.msg_ok  + 4, MSG_OK );*/ \
 …
+    }
     setsockopt(remote_fd, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+    setsockopt_keepalive(remote_fd);
     return remote_fd;
+}
 …
     argv[0] = "ftpd";
+    argv[1] = opt; /* "-l" or "-1" */
+#if BB_MMU
+    argv[1] = opt; /* "-lA" or "-1A" */
     argv[2] = "--";
-#else
-    /* NOMMU ftpd ls helper chdirs to argv[2],
-     * preventing peer from seeing real root. */
-    argv[2] = xrealloc_getcwd_or_warn(NULL);
-#endif
     argv[3] = G.ftp_arg;
     argv[4] = NULL;
 …
     pid = BB_MMU ? xfork() : xvfork();
     if (pid == 0) {
+#if !BB_MMU
+        int cur_fd;
+#endif
         /* child */
-#if !BB_MMU
-        /* On NOMMU, we want to execute a child - copy of ourself.
-         * In chroot we usually can't do it. Thus we chdir
-         * out of the chroot back to original root,
-         * and (see later below) execute bb_busybox_exec_path
-         * relative to current directory */
-        if (fchdir(G.root_fd) != 0)
-            _exit(127);
-        /*close(G.root_fd); - close_on_exec_on() took care of this */
-#endif
         /* NB: close _first_, then move fd! */
         close(outfd.rd);
 …
         exit(ls_main(ARRAY_SIZE(argv) - 1, (char**) argv));
 #else
+        /* + 1: we must use relative path here if in chroot.
+         * For example, execv("/proc/self/exe") will fail, since
+         * it looks for "/proc/self/exe" _relative to chroot!_ */
+        execv(bb_busybox_exec_path + 1, (char**) argv);
+        cur_fd = xopen(".", O_RDONLY | O_DIRECTORY);
+        /* On NOMMU, we want to execute a child - copy of ourself
+         * in order to unblock parent after vfork.
+         * In chroot we usually can't re-exec. Thus we escape
+         * out of the chroot back to original root.
+         */
+        if (G.root_fd >= 0) {
+            if (fchdir(G.root_fd) != 0 || chroot(".") != 0)
+                _exit(127);
+            /*close(G.root_fd); - close_on_exec_on() took care of this */
+        }
+        /* Child expects directory to list on fd #3 */
+        xmove_fd(cur_fd, 3);
+        execv(bb_busybox_exec_path, (char**) argv);
         _exit(127);
 #endif
 …
     /* parent */
     close(outfd.wr);
-#if !BB_MMU
-    free((char*)argv[2]);
-#endif
     return outfd.rd;
+}
 …
         return; /* port_or_pasv_was_seen emitted error response */
+    /* -n prevents user/groupname display,
+     * which can be problematic in chroot */
+    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 */
     if (opts & USE_CTRL_CONN) {
 …
         if (remote_fd >= 0) {
             while (1) {
+                line = xmalloc_fgetline(ls_fp);
+                unsigned len;
+                line = xmalloc_fgets(ls_fp);
                 if (!line)
                     break;
                 /* I've seen clients complaining when they
                  * are fed with ls output with bare '\n'.
                  * Pity... that would be much simpler.
+                 * Replace trailing "\n\0" with "\r\n".
                  */
+/* TODO: need to s/LF/NUL/g here */
+                xwrite_str(remote_fd, line);
+                xwrite(remote_fd, "\r\n", 2);
+                len = strlen(line);
+                if (len != 0) /* paranoia check */
+                    line[len - 1] = '\r';
+                line[len] = '\n';
+                xwrite(remote_fd, line, len + 1);
                 free(line);
+            }
 …
     const_PORT = mk_const4('P', 'O', 'R', 'T'),
     const_PWD  = mk_const3('P', 'W', 'D'),
+    /* Same as PWD. Reportedly used by windows ftp client */
+    const_XPWD = mk_const4('X', 'P', 'W', 'D'),
     const_QUIT = mk_const4('Q', 'U', 'I', 'T'),
     const_REST = mk_const4('R', 'E', 'S', 'T'),
 …
     OPT_l = (1 << 0),
     OPT_1 = (1 << 1),
+#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_A = (1 << 2),
+#endif
+    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,
 };
 …
 #endif
+{
+#if ENABLE_FEATURE_FTP_AUTHENTICATION
+    struct passwd *pw = NULL;
+#endif
     unsigned abs_timeout;
     unsigned verbose_S;
 …
     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 -n? It prevents user/group resolution, which may not work in chroot anyway */
-/* TODO: pass -A? It shows dot files */
 /* TODO: pass --group-directories-first? would be nice, but ls doesn't do that yet */
         xchdir(argv[2]);
         argv[2] = (char*)"--";
+        if (fchdir(3) != 0)
+            _exit(127);
         /* memset(&G, 0, sizeof(G)); - ls_main does it */
         return ls_main(argc, argv);
 …
         applet_name = xasprintf("%s[%u]", applet_name, (int)getpid());
-#if !BB_MMU
-    G.root_fd = xopen("/", O_RDONLY | O_DIRECTORY);
-    close_on_exec_on(G.root_fd);
-#endif
-    if (argv[optind]) {
-        xchroot(argv[optind]);
+    }
     //umask(077); - admin can set umask before starting us
+    /* Signals. We'll always take -EPIPE rather than a rude signal, thanks */
+    signal(SIGPIPE, SIG_IGN);
+    /* Signals */
+    bb_signals(0
+        /* We'll always take EPIPE rather than a rude signal, thanks */
+        + (1 << SIGPIPE)
+        /* LIST command spawns chilren. Prevent zombies */
+        + (1 << SIGCHLD)
+        , SIG_IGN);
     /* Set up options on the command socket (do we need these all? why?) */
     setsockopt(STDIN_FILENO, IPPROTO_TCP, TCP_NODELAY, &const_int_1, sizeof(const_int_1));
     setsockopt(STDIN_FILENO, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+    setsockopt_1(STDIN_FILENO, IPPROTO_TCP, TCP_NODELAY);
+    setsockopt_keepalive(STDIN_FILENO);
     /* Telnet protocol over command link may send "urgent" data,
      * we prefer it to be received in the "normal" data stream: */
     setsockopt(STDIN_FILENO, SOL_SOCKET, SO_OOBINLINE, &const_int_1, sizeof(const_int_1));
+    setsockopt_1(STDIN_FILENO, SOL_SOCKET, SO_OOBINLINE);
     WRITE_OK(FTP_GREET);
     signal(SIGALRM, timeout_handler);
+#ifdef IF_WE_WANT_TO_REQUIRE_LOGIN
+    {
+        smallint user_was_specified = 0;
+        while (1) {
+            uint32_t cmdval = cmdio_get_cmd_and_arg();
+#if ENABLE_FEATURE_FTP_AUTHENTICATION
+    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");
+                }
+            } else if (cmdval == const_PASS) {
+                if (user_was_specified)
+                    break;
+                cmdio_write_raw(STR(FTP_NEEDUSER)" Login with USER\r\n");
+            } else if (cmdval == const_QUIT) {
+                WRITE_OK(FTP_GOODBYE);
+                return 0;
+            } else {
+                cmdio_write_raw(STR(FTP_LOGINERR)" Login with USER and PASS\r\n");
+            pw = getpwnam(G.ftp_arg);
+            cmdio_write_raw(STR(FTP_GIVEPWORD)" Please specify password\r\n");
+        } else if (cmdval == const_PASS) {
+            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;
+        } else {
+            cmdio_write_raw(STR(FTP_LOGINERR)" Login with USER and PASS\r\n");
+        }
+    }
     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]) {
+        const char *basedir = argv[0];
+#if !BB_MMU
+        G.root_fd = xopen("/", O_RDONLY | O_DIRECTORY);
+        close_on_exec_on(G.root_fd);
+#endif
+        if (chroot(basedir) == 0)
+            basedir = "/";
+#if !BB_MMU
+        else {
+            close(G.root_fd);
+            G.root_fd = -1;
+        }
+#endif
+        /*
+         * If chroot failed, assume that we aren't root,
+         * and at least chdir to the specified DIR
+         * (older versions were dying with error message).
+         * If chroot worked, move current dir to new "/":
+         */
+        xchdir(basedir);
+    }
+#if ENABLE_FEATURE_FTP_AUTHENTICATION
+    change_identity(pw);
 #endif
 …
         else if (cmdval == const_SYST)
             cmdio_write_raw(STR(FTP_SYSTOK)" UNIX Type: L8\r\n");
         else if (cmdval == const_PWD)
+        else if (cmdval == const_PWD || cmdval == const_XPWD)
             handle_pwd();
         else if (cmdval == const_CWD)

branches/3.3/mindi-busybox/networking/ftpgetput.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 struct globals {
 …
     char buf[4]; /* actually [BUFSZ] */
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 enum { BUFSZ = COMMON_BUFSIZE - offsetof(struct globals, buf) };
-struct BUG_G_too_big {
-    char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
-};
 #define user           (G.user          )
 #define password       (G.password      )
 …
 #define do_continue    (G.do_continue   )
 #define buf            (G.buf           )
+#define INIT_G() do { } while (0)
+#define INIT_G() do { \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+} while (0)

branches/3.3/mindi-busybox/networking/hostname.c

-              r3232
+              r3621
         OPT_s = 0x8,
         OPT_F = 0x10,
         OPT_dfis = 0xf,
+        OPT_dfi = 0x7,
     };
 …
         opts = OPT_d;
     if (opts & OPT_dfis) {
+    if (opts & OPT_dfi) {
         /* Cases when we need full hostname (or its part) */
         struct hostent *hp;
 …
+            }
+        }
+    } else if (opts & OPT_s) {
+        strchrnul(buf, '.')[0] = '\0';
+        puts(buf);
     } else if (opts & OPT_F) {
         /* Set the hostname */

branches/3.3/mindi-busybox/networking/httpd.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #if ENABLE_PAM
 /* PAM may include <locale.h>. We may need to undefine bbox's stub define: */
 …
 # include <security/pam_misc.h>
 #endif
 #if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+#if ENABLE_FEATURE_USE_SENDFILE
 # include <sys/sendfile.h>
 #endif
 …
 #endif
     char *iobuf;            /* [IOBUF_SIZE] */
+#define hdr_buf bb_common_bufsiz1
+#define        hdr_buf bb_common_bufsiz1
+#define sizeof_hdr_buf COMMON_BUFSIZE
     char *hdr_ptr;
     int hdr_cnt;
 …
 #endif
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
     IF_FEATURE_HTTPD_BASIC_AUTH(g_realm = "Web Server Authentication";) \
 …
+            }
             *host_port++ = '\0';
             if (strncmp(host_port, "http://", 7) == 0)
+            if (is_prefixed_with(host_port, "http://"))
                 host_port += 7;
             if (*host_port == '\0') {
 …
 #endif
     if (responseNum == HTTP_MOVED_TEMPORARILY) {
+        len += sprintf(iobuf + len, "Location: %s/%s%s\r\n",
+        /* Responding to "GET /dir" with
+         * "HTTP/1.0 302 Found" "Location: /dir/"
+         * - IOW, asking them to repeat with a slash.
+         * Here, overflow IS possible, can't use sprintf:
+         * mkdir test
+         * python -c 'print("get /test?" + ("x" * 8192))' | busybox httpd -i -h .
+         */
+        len += snprintf(iobuf + len, IOBUF_SIZE-3 - len,
+                "Location: %s/%s%s\r\n",
                 found_moved_temporarily,
                 (g_query ? "?" : ""),
                 (g_query ? g_query : ""));
+        if (len > IOBUF_SIZE-3)
+            len = IOBUF_SIZE-3;
+    }
 #if ENABLE_FEATURE_HTTPD_ERROR_PAGES
     if (error_page && access(error_page, R_OK) == 0) {
         strcat(iobuf, "\r\n");
         len += 2;
         if (DEBUG)
+        iobuf[len++] = '\r';
+        iobuf[len++] = '\n';
+        if (DEBUG) {
+            iobuf[len] = '\0';
             fprintf(stderr, "headers: '%s'\n", iobuf);
+        }
         full_write(STDOUT_FILENO, iobuf, len);
         if (DEBUG)
 …
                 responseNum, responseString, infoString);
+    }
+    if (DEBUG)
+    if (DEBUG) {
+        iobuf[len] = '\0';
         fprintf(stderr, "headers: '%s'\n", iobuf);
+    }
     if (full_write(STDOUT_FILENO, iobuf, len) != len) {
         if (verbose > 1)
 …
     while (1) {
         if (hdr_cnt <= 0) {
             hdr_cnt = safe_read(STDIN_FILENO, hdr_buf, sizeof(hdr_buf));
+            hdr_cnt = safe_read(STDIN_FILENO, hdr_buf, sizeof_hdr_buf);
             if (hdr_cnt <= 0)
                 break;
 …
     /* NB: breaking out of this loop jumps to log_and_exit() */
     out_cnt = 0;
+    pfd[FROM_CGI].fd = fromCgi_rd;
+    pfd[FROM_CGI].events = POLLIN;
+    pfd[TO_CGI].fd = toCgi_wr;
     while (1) {
+        memset(pfd, 0, sizeof(pfd));
+        pfd[FROM_CGI].fd = fromCgi_rd;
+        pfd[FROM_CGI].events = POLLIN;
+        if (toCgi_wr) {
+            pfd[TO_CGI].fd = toCgi_wr;
+            if (hdr_cnt > 0) {
+                pfd[TO_CGI].events = POLLOUT;
+            } else if (post_len > 0) {
+                pfd[0].events = POLLIN;
+        /* Note: even pfd[0].events == 0 won't prevent
+         * revents == POLLHUP|POLLERR reports from closed stdin.
+         * Setting fd to -1 works: */
+        pfd[0].fd = -1;
+        pfd[0].events = POLLIN;
+        pfd[0].revents = 0; /* probably not needed, paranoia */
+        /* We always poll this fd, thus kernel always sets revents: */
+        /*pfd[FROM_CGI].events = POLLIN; - moved out of loop */
+        /*pfd[FROM_CGI].revents = 0; - not needed */
+        /* gcc-4.8.0 still doesnt fill two shorts with one insn :( */
+        /* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47059 */
+        /* hopefully one day it will... */
+        pfd[TO_CGI].events = POLLOUT;
+        pfd[TO_CGI].revents = 0; /* needed! */
+        if (toCgi_wr && hdr_cnt <= 0) {
+            if (post_len > 0) {
+                /* Expect more POST data from network */
+                pfd[0].fd = 0;
             } else {
                 /* post_len <= 0 && hdr_cnt <= 0:
 …
         /* Now wait on the set of sockets */
         count = safe_poll(pfd, toCgi_wr ? TO_CGI+1 : FROM_CGI+1, -1);
+        count = safe_poll(pfd, hdr_cnt > 0 ? TO_CGI+1 : FROM_CGI+1, -1);
         if (count <= 0) {
 #if 0
 …
         if (pfd[TO_CGI].revents) {
             /* hdr_cnt > 0 here due to the way pfd[TO_CGI].events set */
+            /* hdr_cnt > 0 here due to the way poll() called */
             /* Have data from peer and can write to CGI */
             count = safe_write(toCgi_wr, hdr_ptr, hdr_cnt);
 …
              * and there *is* data to read from the peer
              * (POSTDATA) */
             //count = post_len > (int)sizeof(hdr_buf) ? (int)sizeof(hdr_buf) : post_len;
+            //count = post_len > (int)sizeof_hdr_buf ? (int)sizeof_hdr_buf : post_len;
             //count = safe_read(STDIN_FILENO, hdr_buf, count);
             count = safe_read(STDIN_FILENO, hdr_buf, sizeof(hdr_buf));
+            count = safe_read(STDIN_FILENO, hdr_buf, sizeof_hdr_buf);
             if (count > 0) {
                 hdr_cnt = count;
 …
                 count = 0;
                 /* "Status" header format is: "Status: 302 Redirected\r\n" */
                 if (out_cnt >= 8 && memcmp(rbuf, "Status: ", 8) == 0) {
+                if (out_cnt >= 7 && memcmp(rbuf, "Status:", 7) == 0) {
                     /* send "HTTP/1.0 " */
                     if (full_write(STDOUT_FILENO, HTTP_200, 9) != 9)
                         break;
                     rbuf += 8; /* skip "Status: " */
                     count = out_cnt - 8;
+                    rbuf += 7; /* skip "Status:" */
+                    count = out_cnt - 7;
                     out_cnt = -1; /* buffering off */
                 } else if (out_cnt >= 4) {
 …
     if (what & SEND_HEADERS)
         send_headers(HTTP_OK);
 #if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+#if ENABLE_FEATURE_USE_SENDFILE
+    {
         off_t offset = range_start;
 …
+    }
     if (count < 0) {
  IF_FEATURE_HTTPD_USE_SENDFILE(fin:)
+ IF_FEATURE_USE_SENDFILE(fin:)
         if (verbose > 1)
             bb_perror_msg("error");
 …
             break;
         case PAM_ERROR_MSG:
             case PAM_TEXT_INFO:
                 s = "";
+        case PAM_TEXT_INFO:
+            s = "";
             break;
         default:
 …
     Htaccess_Proxy *p;
     for (p = proxy; p; p = p->next) {
         if (strncmp(url, p->url_from, strlen(p->url_from)) == 0)
+        if (is_prefixed_with(url, p->url_from))
             return p;
+    }
 …
     /* Determine type of request (GET/POST) */
+    urlp = strpbrk(iobuf, " \t");
+    // rfc2616: method and URI is separated by exactly one space
+    //urlp = strpbrk(iobuf, " \t"); - no, tab isn't allowed
+    urlp = strchr(iobuf, ' ');
     if (urlp == NULL)
         send_headers_and_exit(HTTP_BAD_REQUEST);
 …
         send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
 #endif
+    urlp = skip_whitespace(urlp);
+    // rfc2616: method and URI is separated by exactly one space
+    //urlp = skip_whitespace(urlp); - should not be necessary
     if (urlp[0] != '/')
         send_headers_and_exit(HTTP_BAD_REQUEST);
 …
                 /* We know only bytes=NNN-[MMM] */
                 char *s = skip_whitespace(iobuf + sizeof("Range:")-1);
                 if (strncmp(s, "bytes=", 6) == 0) {
+                if (is_prefixed_with(s, "bytes=") == 0) {
                     s += sizeof("bytes=")-1;
                     range_start = BB_STRTOOFF(s, &s, 10);
 …
 #if ENABLE_FEATURE_HTTPD_CGI
     if (strncmp(tptr, "cgi-bin/", 8) == 0) {
+    if (is_prefixed_with(tptr, "cgi-bin/")) {
         if (tptr[8] == '\0') {
             /* protect listing "cgi-bin/" */
 …
         /* set the KEEPALIVE option to cull dead connections */
         setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+        setsockopt_keepalive(n);
         if (fork() == 0) {
 …
         /* set the KEEPALIVE option to cull dead connections */
         setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+        setsockopt_keepalive(n);
         if (vfork() == 0) {

branches/3.3/mindi-busybox/networking/ifconfig.c

-              r3232
+              r3621
 #if ENABLE_FEATURE_IFCONFIG_SLIP
 # include <net/if_slip.h>
+# include <linux/if_slip.h>
 #endif
 …
     { NULL,          0,             ARG_HOSTNAME,    (IFF_UP | IFF_RUNNING) }
 };
-#if ENABLE_FEATURE_IFCONFIG_HW
-/* Input an Ethernet address and convert to binary. */
-static int in_ether(const char *bufp, struct sockaddr *sap)
+{
-    char *ptr;
-    int i, j;
-    unsigned char val;
-    unsigned char c;
-    sap->sa_family = ARPHRD_ETHER;
-    ptr = (char *) sap->sa_data;
-    i = 0;
-    do {
-        j = val = 0;
-        /* We might get a semicolon here - not required. */
-        if (i && (*bufp == ':')) {
-            bufp++;
+        }
-        do {
-            c = *bufp;
-            if (((unsigned char)(c - '0')) <= 9) {
-                c -= '0';
-            } else if ((unsigned char)((c|0x20) - 'a') <= 5) {
-                c = (unsigned char)((c|0x20) - 'a') + 10;
-            } else if (j && (c == ':' || c == 0)) {
-                break;
-            } else {
-                return -1;
+            }
-            ++bufp;
-            val <<= 4;
-            val += c;
-        } while (++j < 2);
-        *ptr++ = val;
-    } while (++i < ETH_ALEN);
-    return *bufp; /* Error if we don't end at end of string. */
+}
-#endif
 int ifconfig_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;

branches/3.3/mindi-busybox/networking/ifenslave.c

-              r3232
+              r3621
                 /* remember the error and skip it */
                 bb_perror_msg(
                     "skipping %s: can't get flags",
                     slave_ifname);
+                    "skipping %s: can't get %s",
+                    slave_ifname, "flags");
                 res = rv;
                 continue;
 …
                 /* remember the error and skip it */
                 bb_perror_msg(
                     "skipping %s: can't get settings",
                     slave_ifname);
+                    "skipping %s: can't get %s",
+                    slave_ifname, "settings");
                 res = rv;
                 continue;

branches/3.3/mindi-busybox/networking/ifplugd.c

-              r3232
+              r3621
 #include <linux/ethtool.h>
 #ifdef HAVE_NET_ETHERNET_H
+# include <net/ethernet.h>
+/* musl breakage:
+ * In file included from /usr/include/net/ethernet.h:10,
+ *                  from networking/ifplugd.c:41:
+ * /usr/include/netinet/if_ether.h:96: error: redefinition of 'struct ethhdr'
+ *
+ * Build succeeds without it on musl. Commented it out.
+ * If on your system you need it, consider removing <linux/ethtool.h>
+ * and copy-pasting its definitions here (<linux/ethtool.h> is what pulls in
+ * conflicting definition of struct ethhdr on musl).
+ */
+/* # include <net/ethernet.h> */
 #endif
 #include <linux/netlink.h>
 …
 #define __user
 #include <linux/wireless.h>
+#ifndef ETH_ALEN
+# define ETH_ALEN  6
+#endif
 /*
 …
 };
 static const char *strstatus(int status)
+{
 …
+{
     int iface_len;
+    char replybuf[1024];
+    /* Buffer was 1K, but on linux-3.9.9 it was reported to be too small.
+     * netlink.h: "limit to 8K to avoid MSG_TRUNC when PAGE_SIZE is very large".
+     * Note: on error returns (-1) we exit, no need to free replybuf.
+     */
+    enum { BUF_SIZE = 8 * 1024 };
+    char *replybuf = xmalloc(BUF_SIZE);
     iface_len = strlen(G.iface);
 …
         ssize_t bytes;
         bytes = recv(netlink_fd, &replybuf, sizeof(replybuf), MSG_DONTWAIT);
+        bytes = recv(netlink_fd, replybuf, BUF_SIZE, MSG_DONTWAIT);
         if (bytes < 0) {
             if (errno == EAGAIN)
                 return G.iface_exists;
+                goto ret;
             if (errno == EINTR)
                 continue;
             bb_perror_msg("netlink: recv");
             return -1;
 …
+    }
+ ret:
+    free(replybuf);
     return G.iface_exists;
+}
 …
     if (opts & FLAG_KILL) {
         if (pid_from_pidfile > 0)
+            kill(pid_from_pidfile, SIGQUIT);
+            /* Upstream tool use SIGINT for -k */
+            kill(pid_from_pidfile, SIGINT);
         return EXIT_SUCCESS;
+    }
 …
     while (1) {
         int iface_status_old;
-        int iface_exists_old;
         switch (bb_got_signal) {
 …
+        }
-        iface_status_old = iface_status;
-        iface_exists_old = G.iface_exists;
         if ((opts & FLAG_MONITOR)
          && (netlink_pollfd[0].revents & POLLIN)
         ) {
+            int iface_exists_old;
+            iface_exists_old = G.iface_exists;
             G.iface_exists = check_existence_through_netlink();
             if (G.iface_exists < 0) /* error */
 …
         /* note: if !G.iface_exists, returns DOWN */
+        iface_status_old = iface_status;
         iface_status = detect_link();
         if (iface_status == IFSTATUS_ERR) {
 …
             if (delay_time) {
                 /* link restored its old status before
                  * we run script. don't run the script: */
+                 * we ran script. don't run the script: */
                 delay_time = 0;
             } else {
 …
                 if (iface_status == IFSTATUS_DOWN)
                     delay_time += G.delay_down;
+                if (delay_time == 0)
+                    delay_time++;
+#if 0  /* if you are back in 1970... */
+                if (delay_time == 0) {
+                    sleep(1);
+                    delay_time = 1;
+                }
+#endif
+            }
+        }
         if (delay_time && (int)(monotonic_sec() - delay_time) >= 0) {
-            delay_time = 0;
             if (run_script(iface_status_str) != 0)
                 goto exiting;
+            delay_time = 0;
+        }
     } /* while (1) */

branches/3.3/mindi-busybox/networking/ifupdown.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 /* After libbb.h, since it needs sys/types.h on some systems */
 #include <sys/utsname.h>
 …
     char *shell;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 #define INIT_G() do { } while (0)
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
 …
                      * unlike ifconfig, ip doesnt want <class>
                      * (usually "ether" keyword). Skip it. */
                     if (strncmp(command, "hwaddress", 9) == 0) {
+                    if (is_prefixed_with(command, "hwaddress")) {
                         varvalue = skip_whitespace(skip_non_whitespace(varvalue));
+                    }
 …
                     /* Sigh...  Add a special case for 'ip' to convert from
                      * dotted quad to bit count style netmasks.  */
                     if (strncmp(command, "bnmask", 6) == 0) {
+                    if (is_prefixed_with(command, "bnmask")) {
                         unsigned res;
                         varvalue = get_var("netmask", 7, ifd);
 …
     result = execute("ip addr add %address%/%netmask% dev %iface%[[ label %label%]]", ifd, exec);
     result += execute("ip link set[[ mtu %mtu%]][[ addr %hwaddress%]] %iface% up", ifd, exec);
     /* Was: "[[ ip ....%gateway% ]]". Removed extra spaces w/o checking */
     result += execute("[[ip route add ::/0 via %gateway%]][[ prio %metric%]]", ifd, exec);
+    /* Reportedly, IPv6 needs "dev %iface%", but IPv4 does not: */
+    result += execute("[[ip route add ::/0 via %gateway% dev %iface%]][[ metric %metric%]]", ifd, exec);
 # else
     result = execute("ifconfig %iface%[[ media %media%]][[ hw %hwaddress%]][[ mtu %mtu%]] up", ifd, exec);
 …
     result += execute("ip link set %iface% up", ifd, exec);
     result += execute("ip addr add %address%/%netmask% dev %iface%", ifd, exec);
+    result += execute("[[ip route add ::/0 via %gateway%]]", ifd, exec);
+    /* Reportedly, IPv6 needs "dev %iface%", but IPv4 does not: */
+    result += execute("[[ip route add ::/0 via %gateway% dev %iface%]]", ifd, exec);
     return ((result == 4) ? 4 : 0);
+}
 …
             "dev %iface%[[ peer %pointopoint%]][[ label %label%]]", ifd, exec);
     result += execute("ip link set[[ mtu %mtu%]][[ addr %hwaddress%]] %iface% up", ifd, exec);
     result += execute("[[ip route add default via %gateway% dev %iface%[[ prio %metric%]]]]", ifd, exec);
+    result += execute("[[ip route add default via %gateway% dev %iface%[[ metric %metric%]]]]", ifd, exec);
     return ((result == 3) ? 3 : 0);
 # else
 …
     },
     { "udhcpc",
         "udhcpc " UDHCPC_CMD_OPTIONS " -p /var/run/udhcpc.%iface%.pid -i %iface%[[ -H %hostname%]][[ -c %client%]]"
+        "udhcpc " UDHCPC_CMD_OPTIONS " -p /var/run/udhcpc.%iface%.pid -i %iface%[[ -x hostname:%hostname%]][[ -c %client%]]"
                 "[[ -s %script%]][[ %udhcpc_opts%]]",
         "kill `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null",
 …
 #  endif
     for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
         if (exists_execable(ext_dhcp_clients[i].name))
+        if (executable_exists(ext_dhcp_clients[i].name))
             return execute(ext_dhcp_clients[i].startcmd, ifd, exec);
+    }
 …
 #  endif
     return execute("udhcpc " UDHCPC_CMD_OPTIONS " -p /var/run/udhcpc.%iface%.pid "
             "-i %iface%[[ -H %hostname%]][[ -c %client%]][[ -s %script%]][[ %udhcpc_opts%]]",
+            "-i %iface%[[ -x hostname:%hostname%]][[ -c %client%]][[ -s %script%]][[ %udhcpc_opts%]]",
             ifd, exec);
+}
 …
     for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
         if (exists_execable(ext_dhcp_clients[i].name)) {
+        if (executable_exists(ext_dhcp_clients[i].name)) {
             result = execute(ext_dhcp_clients[i].stopcmd, ifd, exec);
             if (result)
 …
 #endif  /* FEATURE_IFUPDOWN_IPV4 */
+static int FAST_FUNC link_up_down(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM)
+{
+    return 1;
+}
+static const struct method_t link_methods[] = {
+    { "none", link_up_down, link_up_down }
+};
+static const struct address_family_t addr_link = {
+    "link", ARRAY_SIZE(link_methods), link_methods
+};
 /* Returns pointer to the next word, or NULL.
 …
+}
 static struct interfaces_file_t *read_interfaces(const char *filename)
+static struct interfaces_file_t *read_interfaces(const char *filename, struct interfaces_file_t *defn)
+{
     /* Let's try to be compatible.
 …
      * A "\" character at the very end of the line indicates the next line
      * should be treated as a continuation of the current one.
+     *
+     * Lines  beginning with "source" are used to include stanzas from
+     * other files, so configuration can be split into many files.
+     * The word "source" is followed by the path of file to be sourced.
      */
 #if ENABLE_FEATURE_IFUPDOWN_MAPPING
 …
 #endif
     struct interface_defn_t *currif = NULL;
-    struct interfaces_file_t *defn;
     FILE *f;
     char *buf;
 …
     enum { NONE, IFACE, MAPPING } currently_processing = NONE;
+    defn = xzalloc(sizeof(*defn));
+    if (!defn)
+        defn = xzalloc(sizeof(*defn));
+    debug_noise("reading %s file:\n", filename);
     f = xfopen_for_read(filename);
 …
                 &addr_inet6,
 #endif
+                &addr_link,
                 NULL
             };
 …
             char *address_family_name;
             char *method_name;
-            llist_t *iface_list;
             currif = xzalloc(sizeof(*currif));
 …
             if (!currif->method)
                 bb_error_msg_and_die("unknown method \"%s\"", method_name);
+#if 0
+// Allegedly, Debian allows a duplicate definition:
+// iface eth0 inet static
+//     address 192.168.0.15
+//     netmask 255.255.0.0
+//     gateway 192.168.0.1
+//
+// iface eth0 inet static
+//     address 10.0.0.1
+//     netmask 255.255.255.0
+//
+// This adds *two* addresses to eth0 (probably requires use of "ip", not "ifconfig"
+//
+            llist_t *iface_list;
             for (iface_list = defn->ifaces; iface_list; iface_list = iface_list->link) {
                 struct interface_defn_t *tmp = (struct interface_defn_t *) iface_list->data;
 …
+                }
+            }
+#endif
             llist_add_to_end(&(defn->ifaces), (char*)currif);
 …
+            }
             currently_processing = NONE;
+        } else if (strcmp(first_word, "source") == 0) {
+            read_interfaces(next_word(&rest_of_line), defn);
         } else {
             switch (currently_processing) {
 …
+    }
     fclose(f);
+    debug_noise("\ndone reading %s\n\n", filename);
     return defn;
 …
 static llist_t *find_iface_state(llist_t *state_list, const char *iface)
+{
-    unsigned iface_len = strlen(iface);
     llist_t *search = state_list;
     while (search) {
+        if ((strncmp(search->data, iface, iface_len) == 0)
+         && (search->data[iface_len] == '=')
+        char *after_iface = is_prefixed_with(search->data, iface);
+        if (after_iface
+         && *after_iface == '='
         ) {
             return search;
 …
+    }
+    debug_noise("reading %s file:\n", interfaces);
+    defn = read_interfaces(interfaces);
+    debug_noise("\ndone reading %s\n\n", interfaces);
+    defn = read_interfaces(interfaces, NULL);
     /* Create a list of interfaces to work on */
 …
         bool okay = 0;
         int cmds_ret;
+        bool curr_failure = 0;
         iface = xstrdup(target_list->data);
 …
                 cmds_ret = cmds(currif);
                 if (cmds_ret == -1) {
                     bb_error_msg("don't seem to have all the variables for %s/%s",
+                    bb_error_msg("don't have all variables for %s/%s",
                             liface, currif->address_family->name);
                     any_failures = 1;
+                    any_failures = curr_failure = 1;
                 } else if (cmds_ret == 0) {
                     any_failures = 1;
+                    any_failures = curr_failure = 1;
+                }
 …
             llist_t *iface_state = find_iface_state(state_list, iface);
             if (cmds == iface_up && !any_failures) {
+            if (cmds == iface_up && !curr_failure) {
                 char *newiface = xasprintf("%s=%s", iface, liface);
                 if (!iface_state) {

branches/3.3/mindi-busybox/networking/inetd.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #if ENABLE_FEATURE_INETD_RPC
 …
     char line[256];          /* _at least_ 256, see LINE_SIZE */
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#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 line            (G.line           )
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
     rlim_ofile_cur = OPEN_MAX; \
     global_queuelen = 128; \
 …
 /* gcc generates much more code if this is inlined */
 static servtab_t *parse_one_line(void)
+static NOINLINE servtab_t *parse_one_line(void)
+{
     int argc;
 …
             free(default_local_hostname);
             default_local_hostname = sep->se_local_hostname;
+            /*sep->se_local_hostname = NULL; - redundant */
+            /* (we'll overwrite this field anyway) */
             goto more;
+        }
 …
         bb_error_msg("parse error on line %u, line is ignored",
                 parser->lineno);
-        free_servtab_strings(sep);
         /* Just "goto more" can make sep to carry over e.g.
          * "rpc"-ness (by having se_rpcver_lo != 0).
          * We will be more paranoid: */
+        free_servtab_strings(sep);
         free(sep);
         goto new;
 …
 #endif
+        }
         if (strncmp(arg, "rpc/", 4) == 0) {
+        if (is_prefixed_with(arg, "rpc/")) {
 #if ENABLE_FEATURE_INETD_RPC
             unsigned n;
 …
 #endif
     argc = 0;
     while ((arg = token[6+argc]) != NULL && argc < MAXARGV)
+    while (argc < MAXARGV && (arg = token[6+argc]) != NULL)
         sep->se_argv[argc++] = xstrdup(arg);
     /* Some inetd.conf files have no argv's, not even argv[0].
 …
+    }
 //  bb_info_msg(
 //      "ENTRY[%s][%s][%s][%d][%d][%d][%d][%d][%s][%s][%s]",
 //      sep->se_local_hostname, sep->se_service, sep->se_proto, sep->se_wait, sep->se_proto_no,
 //      sep->se_max, sep->se_count, sep->se_time, sep->se_user, sep->se_group, sep->se_program);
+    //bb_error_msg(
+    //  "ENTRY[%s][%s][%s][%d][%d][%d][%d][%d][%s][%s][%s]",
+    //  sep->se_local_hostname, sep->se_service, sep->se_proto, sep->se_wait, sep->se_proto_no,
+    //  sep->se_max, sep->se_count, sep->se_time, sep->se_user, sep->se_group, sep->se_program);
     /* check if the hostname specifier is a comma separated list
 …
     time_t t;
     t = time(NULL);
+    time(&t);
     fdprintf(s, "%.24s\r\n", ctime(&t));
+}

branches/3.3/mindi-busybox/networking/interface.c

-              r3232
+              r3621
 static const char* FAST_FUNC INET_sprint(struct sockaddr *sap, int numeric)
+{
-    static char *buff; /* defaults to NULL */
-    free(buff);
     if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
         return "[NONE SET]";
+    buff = INET_rresolve((struct sockaddr_in *) sap, numeric, 0xffffff00);
+    return buff;
+    return auto_string(INET_rresolve((struct sockaddr_in *) sap, numeric, 0xffffff00));
+}
 …
 static const char* FAST_FUNC INET6_sprint(struct sockaddr *sap, int numeric)
+{
-    static char *buff;
-    free(buff);
     if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
         return "[NONE SET]";
+    buff = INET6_rresolve((struct sockaddr_in6 *) sap, numeric);
+    return buff;
+    return auto_string(INET6_rresolve((struct sockaddr_in6 *) sap, numeric));
+}
 …
 static char* FAST_FUNC UNSPEC_print(unsigned char *ptr)
+{
+    static char *buff;
+    char *buff;
     char *pos;
     unsigned int i;
+    if (!buff)
+        buff = xmalloc(sizeof(struct sockaddr) * 3 + 1);
+    buff = auto_string(xmalloc(sizeof(struct sockaddr) * 3 + 1));
     pos = buff;
     for (i = 0; i < sizeof(struct sockaddr); i++) {
 …
 static char* FAST_FUNC ether_print(unsigned char *ptr)
+{
+    static char *buff;
+    free(buff);
+    char *buff;
     buff = xasprintf("%02X:%02X:%02X:%02X:%02X:%02X",
              (ptr[0] & 0377), (ptr[1] & 0377), (ptr[2] & 0377),
              (ptr[3] & 0377), (ptr[4] & 0377), (ptr[5] & 0377)
         );
+    return buff;
+}
+static int FAST_FUNC ether_input(const char *bufp, struct sockaddr *sap);
+    return auto_string(buff);
+}
 static const struct hwtype ether_hwtype = {
 …
     .alen  = ETH_ALEN,
     .print = ether_print,
+    .input = ether_input
+};
+static unsigned hexchar2int(char c)
+{
+    if (isdigit(c))
+        return c - '0';
+    c &= ~0x20; /* a -> A */
+    if ((unsigned)(c - 'A') <= 5)
+        return c - ('A' - 10);
+    return ~0U;
+}
+/* Input an Ethernet address and convert to binary. */
+static int FAST_FUNC ether_input(const char *bufp, struct sockaddr *sap)
+{
+    unsigned char *ptr;
+    char c;
+    int i;
+    unsigned val;
+    sap->sa_family = ether_hwtype.type;
+    ptr = (unsigned char*) sap->sa_data;
+    i = 0;
+    while ((*bufp != '\0') && (i < ETH_ALEN)) {
+        val = hexchar2int(*bufp++) * 0x10;
+        if (val > 0xff) {
+            errno = EINVAL;
+            return -1;
+        }
+        c = *bufp;
+        if (c == ':' || c == 0)
+            val >>= 4;
+        else {
+            val |= hexchar2int(c);
+            if (val > 0xff) {
+                errno = EINVAL;
+                return -1;
+            }
+        }
+        if (c != 0)
+            bufp++;
+        *ptr++ = (unsigned char) val;
+        i++;
+        /* We might get a semicolon here - not required. */
+        if (*bufp == ':') {
+            bufp++;
+        }
+    }
+    return 0;
+}
+    .input = in_ether
+};
 static const struct hwtype ppp_hwtype = {
 …
+{
     FILE *f;
     char addr6[40], devname[20];
+    char addr6[40], devname[21];
     struct sockaddr_in6 sap;
     int plen, scope, dad_status, if_idx;
 …
                     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);

branches/3.3/mindi-busybox/networking/ip.c

-              r3232
+              r3621
 //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:    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:       "        [dev STRING] [to PREFIX] }"
 //usage:#define ipaddr_full_usage "\n\n"
 //usage:       "ipaddr {add|delete} IFADDR dev STRING\n"
+//usage:       "ipaddr {add|change|replace|delete} IFADDR dev STRING\n"
 //usage:       "ipaddr {show|flush} [dev STRING] [scope SCOPE-ID]\n"
 //usage:       "    [to PREFIX] [label PATTERN]\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"
 …
  || 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)
 …
+}
 #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
 …
         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[] = {
 …
         IF_FEATURE_IP_TUNNEL(do_iptunnel,)
         IF_FEATURE_IP_RULE(do_iprule,)
+        IF_FEATURE_IP_NEIGH(do_ipneigh,)
     };
     ip_func_ptr_t ip_func;

branches/3.3/mindi-busybox/networking/ipcalc.c

-              r3232
+              r3621
 //usage:#define ipcalc_trivial_usage
+//usage:       "[OPTIONS] ADDRESS[[/]NETMASK] [NETMASK]"
+//usage:       "[OPTIONS] ADDRESS"
+//usage:       IF_FEATURE_IPCALC_FANCY("[/PREFIX]") " [NETMASK]"
 //usage:#define ipcalc_full_usage "\n\n"
 //usage:       "Calculate IP network settings from a IP address\n"

branches/3.3/mindi-busybox/networking/isrv.c

-              r2725
+              r3621
+}
-void BUG_sizeof_fd_set_is_strange(void);
 static void handle_fd_set(isrv_state_t *state, fd_set *fds, int (*h)(int, void **))
+{
 …
     int fd_cnt = FD_COUNT;
+    if (LONG_CNT * sizeof(long) != sizeof(fd_set))
+        BUG_sizeof_fd_set_is_strange();
+    BUILD_BUG_ON(LONG_CNT * sizeof(long) != sizeof(fd_set));
     fds_pos = 0;

branches/3.3/mindi-busybox/networking/isrv.h

-              r2725
+              r3621
 int isrv_register_peer(isrv_state_t *state, void *param);
+/* driver */
+/* Driver:
+ *
+ * Select on listen_fd for <linger_timeout> (or forever if 0).
+ *
+ * If we time out and we have no peers, exit.
+ * If we have peers, call do_timeout(peer_param),
+ * if it returns !0, peer is removed.
+ *
+ * If listen_fd is active, accept new connection ("peer"),
+ * call new_peer() on it, and if it returns 0,
+ * add it to fds to select on.
+ * Now, select will wait for <timeout>, not <linger_timeout>
+ * (as long as we have more than zero peers).
+ *
+ * If a peer's fd is active, we call do_rd() on it if read
+ * bit was set, and then do_wr() if write bit was also set.
+ * If either returns !0, peer is removed.
+ * Reaching this place also resets timeout counter for this peer.
+ *
+ * Note that peer must indicate that he wants to be selected
+ * for read and/or write using isrv_want_rd()/isrv_want_wr()
+ * [can be called in new_peer() or in do_rd()/do_wr()].
+ * If it never wants to be selected for write, do_wr()
+ * will never be called (can be NULL).
+ */
 void isrv_run(
     int listen_fd,

branches/3.3/mindi-busybox/networking/isrv_identd.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include <syslog.h>
 #include "isrv.h"
 …
 typedef struct identd_buf_t {
     int pos;
+    int fd_flag;
+    char buf[64 - 2*sizeof(int)];
+    char buf[64 - sizeof(int)];
 } identd_buf_t;
 …
         return peer; /* failure, unregister peer */
     buf->fd_flag = fcntl(fd, F_GETFL) | O_NONBLOCK;
+    ndelay_on(fd);
     isrv_want_rd(state, fd);
     return 0;
 …
     identd_buf_t *buf = *paramp;
     char *cur, *p;
-    int retval = 0; /* session is ok (so far) */
     int sz;
     cur = buf->buf + buf->pos;
+    if (buf->fd_flag & O_NONBLOCK)
+        fcntl(fd, F_SETFL, buf->fd_flag);
+    sz = safe_read(fd, cur, sizeof(buf->buf) - buf->pos);
+    sz = safe_read(fd, cur, sizeof(buf->buf) - 1 - buf->pos);
     if (sz < 0) {
         if (errno != EAGAIN)
             goto term; /* terminate this session if !EAGAIN */
         goto ok;
+            goto term;
+        return 0; /* "session is ok" */
+    }
 …
     if (p)
         *p = '\0';
+    if (!p && sz && buf->pos <= (int)sizeof(buf->buf))
+        goto ok;
+    if (!p && sz)
+        return 0;  /* "session is ok" */
     /* Terminate session. If we are in server mode, then
      * fd is still in nonblocking mode - we never block here */
+    if (fd == 0) fd++; /* inetd mode? then write to fd 1 */
+    if (fd == 0)
+        fd++; /* inetd mode? then write to fd 1 */
     fdprintf(fd, "%s : USERID : UNIX : %s\r\n", buf->buf, bogouser);
+    /*
+     * Why bother if we are going to close fd now anyway?
+     * if (server)
+     *  ndelay_off(fd);
+     */
  term:
     free(buf);
+    retval = 1; /* terminate */
+ ok:
+    if (buf->fd_flag & O_NONBLOCK)
+        fcntl(fd, F_SETFL, buf->fd_flag & ~O_NONBLOCK);
+    return retval;
+    return 1; /* "terminate" */
+}
 …
     identd_buf_t *buf = xzalloc(sizeof(*buf));
     /* buf->pos = 0; - xzalloc did it */
-    /* We do NOT want nonblocking I/O here! */
-    /* buf->fd_flag = 0; - xzalloc did it */
     do
         alarm(TIMEOUT);
+        /* Note: we do NOT want nonblocking I/O here! */
     while (do_rd(0, (void*)&buf) == 0);
+}
 …
     int fd;
+    setup_common_bufsiz();
     opt = getopt32(argv, "fiwb:", &bind_address);
     strcpy(bogouser, "nobody");
     if (argv[optind])
         strncpy(bogouser, argv[optind], sizeof(bogouser));
+        strncpy(bogouser, argv[optind], COMMON_BUFSIZE - 1);
     /* Daemonize if no -f and no -i and no -w */

branches/3.3/mindi-busybox/networking/libiproute/Kbuild.src

-              r2725
+              r3621
     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

branches/3.3/mindi-busybox/networking/libiproute/ip_common.h

r2725	r3621
25	25	int FAST_FUNC do_iproute(char **argv);
26	26	int FAST_FUNC do_iprule(char **argv);
27		//int FAST_FUNC do_ipneigh(char **argv);
	27	int FAST_FUNC do_ipneigh(char **argv);
28	28	int FAST_FUNC do_iptunnel(char **argv);
29	29	int FAST_FUNC do_iplink(char **argv);

branches/3.3/mindi-busybox/networking/libiproute/ip_parse_common_args.c

r2725	r3621
68	68	arg = index_in_strings(families, *argv);
69	69	if (arg < 0)
70		invarg~~(*argv, "protocol~~ family");
	70	invarg_1_to_2(*argv, "family");
71	71	/* now arg == 0, 1 or 2 */
72	72	} else {

branches/3.3/mindi-busybox/networking/libiproute/ipaddress.c

-              r3232
+              r3621
 #include "ip_common.h"  /* #include "libbb.h" is inside */
+#include "common_bufsiz.h"
 #include "rt_names.h"
 #include "utils.h"
 …
 typedef struct filter_t filter_t;
 #define G_filter (*(filter_t*)&bb_common_bufsiz1)
+#define G_filter (*(filter_t*)bb_common_bufsiz1)
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
 static void print_link_flags(unsigned flags, unsigned mdown)
 …
         unsigned m_flag = 0;
         if (tb[IFLA_LINK]) {
-            SPRINT_BUF(b1);
             int iflink = *(int*)RTA_DATA(tb[IFLA_LINK]);
             if (iflink == 0)
                 printf("@NONE: ");
             else {
                 printf("@%s: ", ll_idx_n2a(iflink, b1));
+                printf("@%s: ", ll_index_to_name(iflink));
                 m_flag = ll_index_to_flags(iflink);
                 m_flag = !(m_flag & IFF_UP);
 …
 #ifdef IFLA_MASTER
     if (tb[IFLA_MASTER]) {
+        SPRINT_BUF(b1);
+        printf("master %s ", ll_idx_n2a(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
+        printf("master %s ", ll_index_to_name(*(int*)RTA_DATA(tb[IFLA_MASTER])));
+    }
 #endif
 …
     struct ifaddrmsg *ifa = NLMSG_DATA(n);
     int len = n->nlmsg_len;
+    struct rtattr * rta_tb[IFA_MAX+1];
+    char abuf[256];
+    SPRINT_BUF(b1);
+    struct rtattr *rta_tb[IFA_MAX+1];
     if (n->nlmsg_type != RTM_NEWADDR && n->nlmsg_type != RTM_DELADDR)
 …
             label = RTA_DATA(rta_tb[IFA_LABEL]);
         else
             label = ll_idx_n2a(ifa->ifa_index, b1);
+            label = ll_index_to_name(ifa->ifa_index);
         if (fnmatch(G_filter.label, label, 0) != 0)
             return 0;
 …
     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
 …
         } 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
+            );
+        }
+    }
 …
         printf("brd %s ",
             rt_addr_n2a(ifa->ifa_family,
+                    RTA_DATA(rta_tb[IFA_BROADCAST]),
+                    abuf, sizeof(abuf))
+                RTA_DATA(rta_tb[IFA_BROADCAST]))
         );
+    }
 …
         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, b1));
+    printf("scope %s ", rtnl_rtscope_n2a(ifa->ifa_scope));
     if (ifa->ifa_flags & IFA_F_SECONDARY) {
         ifa->ifa_flags &= ~IFA_F_SECONDARY;
 …
             if (rtnl_rtscope_a2n(&scope, *argv)) {
                 if (strcmp(*argv, "all") != 0) {
                     invarg(*argv, "scope");
+                    invarg_1_to_2(*argv, "scope");
+                }
                 scope = RT_SCOPE_NOWHERE;
 …
+                    }
                     if (G_filter.label) {
-                        SPRINT_BUF(b1);
                         const char *label;
                         if (tb[IFA_LABEL])
                             label = RTA_DATA(tb[IFA_LABEL]);
                         else
                             label = ll_idx_n2a(ifa->ifa_index, b1);
+                            label = ll_index_to_name(ifa->ifa_index);
                         if (fnmatch(G_filter.label, label, 0) != 0)
                             continue;
 …
 /* Return value becomes exitcode. It's okay to not return at all */
 static int ipaddr_modify(int cmd, char **argv)
+static int ipaddr_modify(int cmd, int flags, char **argv)
+{
     static const char option[] ALIGN1 =
 …
     req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
     req.n.nlmsg_flags = NLM_F_REQUEST;
+    req.n.nlmsg_flags = NLM_F_REQUEST | flags;
     req.n.nlmsg_type = cmd;
     req.ifa.ifa_family = preferred_family;
     while (*argv) {
+        const smalluint arg = index_in_strings(option, *argv);
+        unsigned arg = index_in_strings(option, *argv);
+        /* if search fails, "local" is assumed */
+        if ((int)arg >= 0)
+            NEXT_ARG();
         if (arg <= 1) { /* peer, remote */
-            NEXT_ARG();
             if (peer_len) {
                 duparg("peer", *argv);
 …
         } else if (arg <= 3) { /* broadcast, brd */
             inet_prefix addr;
-            NEXT_ARG();
             if (brd_len) {
                 duparg("broadcast", *argv);
 …
         } else if (arg == 4) { /* anycast */
             inet_prefix addr;
-            NEXT_ARG();
             if (any_len) {
                 duparg("anycast", *argv);
 …
         } else if (arg == 5) { /* scope */
             uint32_t scope = 0;
-            NEXT_ARG();
             if (rtnl_rtscope_a2n(&scope, *argv)) {
                 invarg(*argv, "scope");
+                invarg_1_to_2(*argv, "scope");
+            }
             req.ifa.ifa_scope = scope;
             scoped = 1;
         } else if (arg == 6) { /* dev */
-            NEXT_ARG();
             d = *argv;
         } else if (arg == 7) { /* label */
-            NEXT_ARG();
             l = *argv;
             addattr_l(&req.n, sizeof(req), IFA_LABEL, l, strlen(l) + 1);
         } else {
+            if (arg == 8) /* local */
+                NEXT_ARG();
+            /* local (specified or assumed) */
             if (local_len) {
                 duparg2("local", *argv);
 …
         bb_error_msg_and_die("need \"dev IFACE\"");
+    }
     if (l && strncmp(d, l, strlen(d)) != 0) {
+    if (l && !is_prefixed_with(l, d)) {
         bb_error_msg_and_die("\"dev\" (%s) must match \"label\" (%s)", d, l);
+    }
 …
         brd = peer;
         if (brd.bitlen <= 30) {
             for (i=31; i>=brd.bitlen; i--) {
+            for (i = 31; i >= brd.bitlen; i--) {
                 if (brd_len == -1)
                     brd.data[0] |= htonl(1<<(31-i));
 …
+{
     static const char commands[] ALIGN1 =
+        "add\0""delete\0""list\0""show\0""lst\0""flush\0";
+    smalluint cmd = 2;
+        /* 0    1         2      3          4         5       6       7      8 */
+        "add\0""change\0""chg\0""replace\0""delete\0""list\0""show\0""lst\0""flush\0";
+    int cmd = 2;
+    INIT_G();
     if (*argv) {
         cmd = index_in_substrings(commands, *argv);
         if (cmd > 5)
             bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        if (cmd < 0)
+            invarg_1_to_2(*argv, applet_name);
         argv++;
+        if (cmd <= 1)
+            return ipaddr_modify((cmd == 0) ? RTM_NEWADDR : RTM_DELADDR, argv);
+    }
+    /* 2 == list, 3 == show, 4 == lst */
+    return ipaddr_list_or_flush(argv, cmd == 5);
+}
+        if (cmd <= 4) {
+            return ipaddr_modify(
+                /*cmd:*/ cmd == 4 ? RTM_DELADDR : RTM_NEWADDR,
+                /*flags:*/
+                    cmd == 0 ? NLM_F_CREATE|NLM_F_EXCL : /* add */
+                    cmd == 1 || cmd == 2 ? NLM_F_REPLACE : /* change */
+                    cmd == 3 ? NLM_F_CREATE|NLM_F_REPLACE : /* replace */
+/* delete */
+            , argv);
+        }
+    }
+    return ipaddr_list_or_flush(argv, cmd == 8);
+}

branches/3.3/mindi-busybox/networking/libiproute/iplink.c

-              r3232
+              r3621
 /*
  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *          Patrick McHardy <kaber@trash.net>
+ *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 #include <net/if.h>
+#include <net/if_packet.h>
+/*#include <net/if_packet.h> - not needed? */
 #include <netpacket/packet.h>
 #include <netinet/if_ether.h>
+#include <linux/if_vlan.h>
 #include "ip_common.h"  /* #include "libbb.h" is inside */
 #include "rt_names.h"
 #include "utils.h"
+#undef  ETH_P_8021AD
+#define ETH_P_8021AD            0x88A8
+#undef  VLAN_FLAG_REORDER_HDR
+#define VLAN_FLAG_REORDER_HDR   0x1
+#undef  VLAN_FLAG_GVRP
+#define VLAN_FLAG_GVRP          0x2
+#undef  VLAN_FLAG_LOOSE_BINDING
+#define VLAN_FLAG_LOOSE_BINDING 0x4
+#undef  VLAN_FLAG_MVRP
+#define VLAN_FLAG_MVRP          0x8
+#undef  IFLA_VLAN_PROTOCOL
+#define IFLA_VLAN_PROTOCOL      5
 #ifndef IFLA_LINKINFO
 # define IFLA_LINKINFO 18
 # define IFLA_INFO_KIND 1
+# define IFLA_INFO_DATA 2
+#endif
+#ifndef IFLA_VLAN_MAX
+# define IFLA_VLAN_ID 1
+# define IFLA_VLAN_FLAGS 2
+struct ifla_vlan_flags {
+    uint32_t    flags;
+    uint32_t    mask;
+};
 #endif
 /* taken from linux/sockios.h */
 #define SIOCSIFNAME  0x8923  /* set interface name */
+#if 0
+# define dbg(...) bb_error_msg(__VA_ARGS__)
+#else
+# define dbg(...) ((void)0)
+#endif
 /* Exits on error */
 …
+}
+static void vlan_parse_opt(char **argv, struct nlmsghdr *n, unsigned int size)
+{
+    static const char keywords[] ALIGN1 =
+        "id\0"
+        "protocol\0"
+        "reorder_hdr\0"
+        "gvrp\0"
+        "mvrp\0"
+        "loose_binding\0"
+    ;
+    static const char protocols[] ALIGN1 =
+        "802.1q\0"
+        "802.1ad\0"
+    ;
+    static const char str_on_off[] ALIGN1 =
+        "on\0"
+        "off\0"
+    ;
+    enum {
+        ARG_id = 0,
+        ARG_reorder_hdr,
+        ARG_gvrp,
+        ARG_mvrp,
+        ARG_loose_binding,
+        ARG_protocol,
+    };
+    enum {
+        PROTO_8021Q = 0,
+        PROTO_8021AD,
+    };
+    enum {
+        PARM_on = 0,
+        PARM_off
+    };
+    int arg;
+    uint16_t id, proto;
+    struct ifla_vlan_flags flags = {};
+    while (*argv) {
+        arg = index_in_substrings(keywords, *argv);
+        if (arg < 0)
+            invarg_1_to_2(*argv, "type vlan");
+        NEXT_ARG();
+        if (arg == ARG_id) {
+            id = get_u16(*argv, "id");
+            addattr_l(n, size, IFLA_VLAN_ID, &id, sizeof(id));
+        } else if (arg == ARG_protocol) {
+            arg = index_in_substrings(protocols, *argv);
+            if (arg == PROTO_8021Q)
+                proto = ETH_P_8021Q;
+            else if (arg == PROTO_8021AD)
+                proto = ETH_P_8021AD;
+            else
+                bb_error_msg_and_die("unknown VLAN encapsulation protocol '%s'",
+                                     *argv);
+            addattr_l(n, size, IFLA_VLAN_PROTOCOL, &proto, sizeof(proto));
+        } else {
+            int param = index_in_strings(str_on_off, *argv);
+            if (param < 0)
+                die_must_be_on_off(nth_string(keywords, arg));
+            if (arg == ARG_reorder_hdr) {
+                flags.mask |= VLAN_FLAG_REORDER_HDR;
+                flags.flags &= ~VLAN_FLAG_REORDER_HDR;
+                if (param == PARM_on)
+                    flags.flags |= VLAN_FLAG_REORDER_HDR;
+            } else if (arg == ARG_gvrp) {
+                flags.mask |= VLAN_FLAG_GVRP;
+                flags.flags &= ~VLAN_FLAG_GVRP;
+                if (param == PARM_on)
+                    flags.flags |= VLAN_FLAG_GVRP;
+            } else if (arg == ARG_mvrp) {
+                flags.mask |= VLAN_FLAG_MVRP;
+                flags.flags &= ~VLAN_FLAG_MVRP;
+                if (param == PARM_on)
+                    flags.flags |= VLAN_FLAG_MVRP;
+            } else { /*if (arg == ARG_loose_binding) */
+                flags.mask |= VLAN_FLAG_LOOSE_BINDING;
+                flags.flags &= ~VLAN_FLAG_LOOSE_BINDING;
+                if (param == PARM_on)
+                    flags.flags |= VLAN_FLAG_LOOSE_BINDING;
+            }
+        }
+        argv++;
+    }
+    if (flags.mask)
+        addattr_l(n, size, IFLA_VLAN_FLAGS, &flags, sizeof(flags));
+}
 #ifndef NLMSG_TAIL
 #define NLMSG_TAIL(nmsg) \
 …
 #endif
 /* Return value becomes exitcode. It's okay to not return at all */
 static int do_change(char **argv, const unsigned rtm)
+static int do_add_or_delete(char **argv, const unsigned rtm)
+{
     static const char keywords[] ALIGN1 =
         "link\0""name\0""type\0""dev\0";
+        "link\0""name\0""type\0""dev\0""address\0";
     enum {
         ARG_link,
 …
         ARG_type,
         ARG_dev,
+        ARG_address,
     };
     struct rtnl_handle rth;
 …
     } req;
     smalluint arg;
+    char *name_str = NULL, *link_str = NULL, *type_str = NULL, *dev_str = NULL;
+    char *name_str = NULL;
+    char *link_str = NULL;
+    char *type_str = NULL;
+    char *dev_str = NULL;
+    char *address_str = NULL;
     memset(&req, 0, sizeof(req));
 …
     while (*argv) {
         arg = index_in_substrings(keywords, *argv);
+        if (arg == ARG_type) {
+            NEXT_ARG();
+            type_str = *argv++;
+            dbg("type_str:'%s'", type_str);
+            break;
+        }
         if (arg == ARG_link) {
             NEXT_ARG();
             link_str = *argv;
+            dbg("link_str:'%s'", link_str);
         } else if (arg == ARG_name) {
             NEXT_ARG();
             name_str = *argv;
+        } else if (arg == ARG_type) {
+            NEXT_ARG();
+            type_str = *argv;
+            dbg("name_str:'%s'", name_str);
+        } else if (arg == ARG_address) {
+            NEXT_ARG();
+            address_str = *argv;
+            dbg("address_str:'%s'", name_str);
         } else {
             if (arg == ARG_dev) {
 …
+            }
             dev_str = *argv;
+            dbg("dev_str:'%s'", dev_str);
+        }
         argv++;
 …
         addattr_l(&req.n, sizeof(req), IFLA_INFO_KIND, type_str,
                 strlen(type_str));
+        if (*argv) {
+            struct rtattr *data = NLMSG_TAIL(&req.n);
+            addattr_l(&req.n, sizeof(req), IFLA_INFO_DATA, NULL, 0);
+            if (strcmp(type_str, "vlan") == 0)
+                vlan_parse_opt(argv, &req.n, sizeof(req));
+            data->rta_len = (void *)NLMSG_TAIL(&req.n) - (void *)data;
+        }
         linkinfo->rta_len = (void *)NLMSG_TAIL(&req.n) - (void *)linkinfo;
+    }
 …
             addattr_l(&req.n, sizeof(req), IFLA_LINK, &idx, 4);
+        }
+        if (address_str) {
+            unsigned char abuf[32];
+            int len = ll_addr_a2n(abuf, sizeof(abuf), address_str);
+            dbg("address len:%d", len);
+            if (len < 0)
+                return -1;
+            addattr_l(&req.n, sizeof(req), IFLA_ADDRESS, abuf, len);
+        }
+    }
     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);
+    }
 …
+}
+/* Other keywords recognized by iproute2-3.12.0: */
+#if 0
+        } else if (matches(*argv, "broadcast") == 0 ||
+                strcmp(*argv, "brd") == 0) {
+            NEXT_ARG();
+            len = ll_addr_a2n(abuf, sizeof(abuf), *argv);
+            if (len < 0)
+                return -1;
+            addattr_l(&req->n, sizeof(*req), IFLA_BROADCAST, abuf, len);
+        } else if (matches(*argv, "txqueuelen") == 0 ||
+                strcmp(*argv, "qlen") == 0 ||
+                matches(*argv, "txqlen") == 0) {
+            NEXT_ARG();
+            if (qlen != -1)
+                duparg("txqueuelen", *argv);
+            if (get_integer(&qlen,  *argv, 0))
+                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_1_to_2(*argv, "mtu");
+            addattr_l(&req->n, sizeof(*req), IFLA_MTU, &mtu, 4);
+                } else if (strcmp(*argv, "netns") == 0) {
+                        NEXT_ARG();
+                        if (netns != -1)
+                                duparg("netns", *argv);
+            if ((netns = get_netns_fd(*argv)) >= 0)
+                addattr_l(&req->n, sizeof(*req), IFLA_NET_NS_FD, &netns, 4);
+            else if (get_integer(&netns, *argv, 0) == 0)
+                addattr_l(&req->n, sizeof(*req), IFLA_NET_NS_PID, &netns, 4);
+            else
+                                invarg_1_to_2(*argv, "netns");
+        } else if (strcmp(*argv, "multicast") == 0) {
+            NEXT_ARG();
+            req->i.ifi_change |= IFF_MULTICAST;
+            if (strcmp(*argv, "on") == 0) {
+                req->i.ifi_flags |= IFF_MULTICAST;
+            } else if (strcmp(*argv, "off") == 0) {
+                req->i.ifi_flags &= ~IFF_MULTICAST;
+            } else
+                return on_off("multicast", *argv);
+        } else if (strcmp(*argv, "allmulticast") == 0) {
+            NEXT_ARG();
+            req->i.ifi_change |= IFF_ALLMULTI;
+            if (strcmp(*argv, "on") == 0) {
+                req->i.ifi_flags |= IFF_ALLMULTI;
+            } else if (strcmp(*argv, "off") == 0) {
+                req->i.ifi_flags &= ~IFF_ALLMULTI;
+            } else
+                return on_off("allmulticast", *argv);
+        } else if (strcmp(*argv, "promisc") == 0) {
+            NEXT_ARG();
+            req->i.ifi_change |= IFF_PROMISC;
+            if (strcmp(*argv, "on") == 0) {
+                req->i.ifi_flags |= IFF_PROMISC;
+            } else if (strcmp(*argv, "off") == 0) {
+                req->i.ifi_flags &= ~IFF_PROMISC;
+            } else
+                return on_off("promisc", *argv);
+        } else if (strcmp(*argv, "trailers") == 0) {
+            NEXT_ARG();
+            req->i.ifi_change |= IFF_NOTRAILERS;
+            if (strcmp(*argv, "off") == 0) {
+                req->i.ifi_flags |= IFF_NOTRAILERS;
+            } else if (strcmp(*argv, "on") == 0) {
+                req->i.ifi_flags &= ~IFF_NOTRAILERS;
+            } else
+                return on_off("trailers", *argv);
+        } else if (strcmp(*argv, "arp") == 0) {
+            NEXT_ARG();
+            req->i.ifi_change |= IFF_NOARP;
+            if (strcmp(*argv, "on") == 0) {
+                req->i.ifi_flags &= ~IFF_NOARP;
+            } else if (strcmp(*argv, "off") == 0) {
+                req->i.ifi_flags |= IFF_NOARP;
+            } else
+                return on_off("noarp", *argv);
+        } else if (strcmp(*argv, "vf") == 0) {
+            struct rtattr *vflist;
+            NEXT_ARG();
+            if (get_integer(&vf,  *argv, 0)) {
+                invarg_1_to_2(*argv, "vf");
+            }
+            vflist = addattr_nest(&req->n, sizeof(*req),
+                          IFLA_VFINFO_LIST);
+            len = iplink_parse_vf(vf, &argc, &argv, req);
+            if (len < 0)
+                return -1;
+            addattr_nest_end(&req->n, vflist);
+        } else if (matches(*argv, "master") == 0) {
+            int ifindex;
+            NEXT_ARG();
+            ifindex = ll_name_to_index(*argv);
+            if (!ifindex)
+                invarg_1_to_2(*argv, "master");
+            addattr_l(&req->n, sizeof(*req), IFLA_MASTER,
+                  &ifindex, 4);
+        } else if (matches(*argv, "nomaster") == 0) {
+            int ifindex = 0;
+            addattr_l(&req->n, sizeof(*req), IFLA_MASTER,
+                  &ifindex, 4);
+        } else if (matches(*argv, "dynamic") == 0) {
+            NEXT_ARG();
+            req->i.ifi_change |= IFF_DYNAMIC;
+            if (strcmp(*argv, "on") == 0) {
+                req->i.ifi_flags |= IFF_DYNAMIC;
+            } else if (strcmp(*argv, "off") == 0) {
+                req->i.ifi_flags &= ~IFF_DYNAMIC;
+            } else
+                return on_off("dynamic", *argv);
+        } else if (matches(*argv, "alias") == 0) {
+            NEXT_ARG();
+            addattr_l(&req->n, sizeof(*req), IFLA_IFALIAS,
+                  *argv, strlen(*argv));
+            argc--; argv++;
+            break;
+        } else if (strcmp(*argv, "group") == 0) {
+            NEXT_ARG();
+            if (*group != -1)
+                duparg("group", *argv);
+            if (rtnl_group_a2n(group, *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_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_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_1_to_2(*argv, "numtxqueues");
+            addattr_l(&req->n, sizeof(*req), IFLA_NUM_TX_QUEUES,
+                  &numtxqueues, 4);
+        } else if (matches(*argv, "numrxqueues") == 0) {
+            NEXT_ARG();
+            if (numrxqueues != -1)
+                duparg("numrxqueues", *argv);
+            if (get_integer(&numrxqueues, *argv, 0))
+                invarg_1_to_2(*argv, "numrxqueues");
+            addattr_l(&req->n, sizeof(*req), IFLA_NUM_RX_QUEUES,
+                  &numrxqueues, 4);
+        }
+#endif
 /* Return value becomes exitcode. It's okay to not return at all */
 int FAST_FUNC do_iplink(char **argv)
 …
         "add\0""delete\0""set\0""show\0""lst\0""list\0";
     if (*argv) {
         smalluint key = index_in_substrings(keywords, *argv);
         if (key > 5) /* invalid argument */
             bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        int key = index_in_substrings(keywords, *argv);
+        if (key < 0) /* invalid argument */
+            invarg_1_to_2(*argv, applet_name);
         argv++;
         if (key <= 1) /* add/delete */
             return do_change(argv, key ? RTM_DELLINK : RTM_NEWLINK);
         else if (key == 2) /* set */
+            return do_add_or_delete(argv, key ? RTM_DELLINK : RTM_NEWLINK);
+        if (key == 2) /* set */
             return do_set(argv);
+    }

branches/3.3/mindi-busybox/networking/libiproute/iproute.c

-              r3232
+              r3621
 #include "ip_common.h"  /* #include "libbb.h" is inside */
+#include "common_bufsiz.h"
 #include "rt_names.h"
 #include "utils.h"
 …
 typedef struct filter_t filter_t;
+#define G_filter (*(filter_t*)&bb_common_bufsiz1)
+#define G_filter (*(filter_t*)bb_common_bufsiz1)
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
 static int flush_update(void)
 …
     G_filter.flushp = 0;
     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 = sysconf(_SC_CLK_TCK);
-    return hz_internal;
+}
 …
     int len = n->nlmsg_len;
     struct rtattr *tb[RTA_MAX+1];
-    char abuf[256];
     inet_prefix dst;
     inet_prefix src;
     int host_len = -1;
-    SPRINT_BUF(b1);
     if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
 …
         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));
 …
+    }
     if (r->rtm_type != RTN_UNICAST /* && !G_filter.type - always 0 */) {
         printf("%s ", rtnl_rtntype_n2a(r->rtm_type, b1));
+        printf("%s ", rtnl_rtntype_n2a(r->rtm_type));
+    }
     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) {
 …
     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("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(" 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]));
+    }
+    if (r->rtm_flags & RTNH_F_DEAD) {
+        printf("dead ");
+    }
+    if (r->rtm_flags & RTNH_F_ONLINK) {
+        printf("onlink ");
+    }
+    if (r->rtm_flags & RTNH_F_PERVASIVE) {
+        printf("pervasive ");
+    }
+    if (r->rtm_flags & RTM_F_NOTIFY) {
+        printf("notify ");
+    }
     if (r->rtm_family == AF_INET6) {
         struct rta_cacheinfo *ci = NULL;
 …
+{
     static const char keywords[] ALIGN1 =
         "src\0""via\0""mtu\0""lock\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
         "dev\0""oif\0""to\0""metric\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_to,
         ARG_metric,
+        ARG_onlink,
     };
     enum {
 …
     char *d = NULL;
     smalluint ok = 0;
+    smalluint scope_ok = 0;
     int arg;
 …
     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 (RTN_UNICAST != 0)
+            req.r.rtm_type = RTN_UNICAST;
+    }
 …
             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();
             if (rtnl_rtprot_a2n(&prot, *argv))
                 invarg(*argv, "protocol");
+                invarg_1_to_2(*argv, "protocol");
             req.r.rtm_protocol = prot;
             ok |= proto_ok;
 …
             NEXT_ARG();
             if (rtnl_rttable_a2n(&tid, *argv))
                 invarg(*argv, "table");
+                invarg_1_to_2(*argv, "table");
             req.r.rtm_table = tid;
 #endif
 …
             metric = get_u32(*argv, "metric");
             addattr32(&req.n, sizeof(req), RTA_PRIORITY, metric);
+        } else if (arg == ARG_onlink) {
+            req.r.rtm_flags |= RTNH_F_ONLINK;
         } else {
             int type;
 …
+    }
+    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 (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;
 …
                 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
+            }
 …
     unsigned flags = 0;
     int cmd = RTM_NEWROUTE;
+    INIT_G();
     if (!*argv)
 …
             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);
+    }

branches/3.3/mindi-busybox/networking/libiproute/iprule.c

-              r3232
+              r3621
     int host_len = -1;
     struct rtattr * tb[RTA_MAX+1];
-    char abuf[256];
-    SPRINT_BUF(b1);
     if (n->nlmsg_type != RTM_NEWRULE)
 …
     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
             );
 …
             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
             );
 …
         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
                 );
 …
             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) {
 …
     if (r->rtm_tos) {
         printf("tos %s ", rtnl_dsfield_n2a(r->rtm_tos, b1));
+        printf("tos %s ", rtnl_dsfield_n2a(r->rtm_tos));
+    }
     if (tb[RTA_PROTOINFO]) {
 …
     if (r->rtm_table)
         printf("lookup %s ", rtnl_rttable_n2a(r->rtm_table, b1));
+        printf("lookup %s ", rtnl_rttable_n2a(r->rtm_table));
     if (tb[RTA_FLOW]) {
 …
         if (from) {
             printf("realms %s/",
                 rtnl_rtrealm_n2a(from, b1));
+                rtnl_rtrealm_n2a(from));
+        }
         printf("%s ",
             rtnl_rtrealm_n2a(to, b1));
+            rtnl_rtrealm_n2a(to));
+    }
 …
                 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)
         fputs(rtnl_rtntype_n2a(r->rtm_type, b1), stdout);
+        fputs(rtnl_rtntype_n2a(r->rtm_type), stdout);
     bb_putchar('\n');
 …
         key = index_in_substrings(keywords, *argv) + 1;
         if (key == 0) /* no match found in keywords array, bail out. */
             bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+            invarg_1_to_2(*argv, applet_name);
         if (key == ARG_from) {
             inet_prefix dst;
 …
             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) {
 …
             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 ||
 …
             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;
 …
                 bb_show_usage();
             if (rtnl_rtntype_a2n(&type, *argv))
                 invarg(*argv, "type");
+                invarg_1_to_2(*argv, "type");
             req.r.rtm_type = type;
+        }
 …
         "add\0""delete\0""list\0""show\0";
     if (*argv) {
         smalluint cmd = index_in_substrings(ip_rule_commands, *argv);
         if (cmd > 3)
             bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        int cmd = index_in_substrings(ip_rule_commands, *argv);
+        if (cmd < 0)
+            invarg_1_to_2(*argv, applet_name);
         argv++;
         if (cmd < 2)

branches/3.3/mindi-busybox/networking/libiproute/iptunnel.c

-              r3232
+              r3621
                 uval = get_unsigned(*argv, "TTL");
                 if (uval > 255)
                     invarg(*argv, "TTL must be <=255");
+                    invarg_1_to_2(*argv, "TTL");
                 p->iph.ttl = uval;
+            }
 …
             if (key != ARG_inherit) {
                 if (rtnl_dsfield_a2n(&uval, *argv))
                     invarg(*argv, "TOS");
+                    invarg_1_to_2(*argv, "TOS");
                 p->iph.tos = uval;
             } else
 …
 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);
 …
         printf(" ttl inherit ");
     if (p->iph.tos) {
-        SPRINT_BUF(b1);
         printf(" tos");
         if (p->iph.tos & 1)
 …
         if (p->iph.tos & ~1)
             printf("%c%s ", p->iph.tos & 1 ? '/' : ' ',
                 rtnl_dsfield_n2a(p->iph.tos & ~1, b1));
+                rtnl_dsfield_n2a(p->iph.tos & ~1));
+    }
     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 (*argv) {
         smalluint key = index_in_substrings(keywords, *argv);
         if (key > 5)
             bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        int key = index_in_substrings(keywords, *argv);
+        if (key < 0)
+            invarg_1_to_2(*argv, applet_name);
         argv++;
         if (key == ARG_add)

branches/3.3/mindi-busybox/networking/libiproute/libnetlink.c

-              r3232
+              r3621
     struct sockaddr_nl nladdr;
     struct iovec iov[2] = { { &nlh, sizeof(nlh) }, { req, len } };
+    /* Use designated initializers, struct layout is non-portable */
     struct msghdr msg = {
+        (void*)&nladdr, sizeof(nladdr),
+        iov,  2,
+        NULL, 0,
+        .msg_name = (void*)&nladdr,
+        .msg_namelen = sizeof(nladdr),
+        .msg_iov = iov,
+        .msg_iovlen = 2,
+        .msg_control = NULL,
+        .msg_controllen = 0,
+        .msg_flags = 0
     };
 …
         int status;
         struct nlmsghdr *h;
+        /* Use designated initializers, struct layout is non-portable */
         struct msghdr msg = {
+            (void*)&nladdr, sizeof(nladdr),
+            &iov, 1,
+            NULL, 0,
+            .msg_name = (void*)&nladdr,
+            .msg_namelen = sizeof(nladdr),
+            .msg_iov = &iov,
+            .msg_iovlen = 1,
+            .msg_control = NULL,
+            .msg_controllen = 0,
+            .msg_flags = 0
         };
 …
     struct iovec iov = { (void*)n, n->nlmsg_len };
     char   *buf = xmalloc(8*1024); /* avoid big stack buffer */
+    /* Use designated initializers, struct layout is non-portable */
     struct msghdr msg = {
+        (void*)&nladdr, sizeof(nladdr),
+        &iov, 1,
+        NULL, 0,
+        .msg_name = (void*)&nladdr,
+        .msg_namelen = sizeof(nladdr),
+        .msg_iov = &iov,
+        .msg_iovlen = 1,
+        .msg_control = NULL,
+        .msg_controllen = 0,
+        .msg_flags = 0
     };

branches/3.3/mindi-busybox/networking/libiproute/ll_map.c

-              r2725
+              r3621
+}
+const char FAST_FUNC *ll_idx_n2a(int idx, char *buf)
+static
+const char FAST_FUNC *ll_idx_n2a(int idx/*, char *buf*/)
+{
     struct idxmap *im;
 …
     if (im)
         return im->name;
+    snprintf(buf, 16, "if%d", idx);
+    return buf;
+    //snprintf(buf, 16, "if%d", idx);
+    //return buf;
+    return auto_string(xasprintf("if%d", idx));
+}
 const char FAST_FUNC *ll_index_to_name(int idx)
+{
+    static char nbuf[16];
+    return ll_idx_n2a(idx, nbuf);
+    //static char nbuf[16];
+    return ll_idx_n2a(idx/*, nbuf*/);
+}
 …
+{
     int ret = 0;
-    int sock_fd;
 /* caching is not warranted - no users which repeatedly call it */
 …
+        }
+    }
-    /* We have not found the interface in our cache, but the kernel
-     * may still know about it. One reason is that we may be using
-     * module on-demand loading, which means that the kernel will
-     * load the module and make the interface exist only when
-     * we explicitely request it (check for dev_load() in net/core/dev.c).
-     * I can think of other similar scenario, but they are less common...
-     * Jean II */
 #endif
+    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock_fd >= 0) {
+        struct ifreq ifr;
+        int tmp;
+        strncpy_IFNAMSIZ(ifr.ifr_name, name);
+        ifr.ifr_ifindex = -1;
+        tmp = ioctl(sock_fd, SIOCGIFINDEX, &ifr);
+        close(sock_fd);
+        if (tmp >= 0)
+            /* In theory, we should redump the interface list
+             * to update our cache, this is left as an exercise
+             * to the reader... Jean II */
+            ret = ifr.ifr_ifindex;
+    }
+    ret = if_nametoindex(name);
 /* out:*/
     if (ret <= 0)

branches/3.3/mindi-busybox/networking/libiproute/ll_map.h

-              r2725
+              r3621
 int ll_init_map(struct rtnl_handle *rth) FAST_FUNC;
 int xll_name_to_index(const char *name) FAST_FUNC;
+//static: const char *ll_idx_n2a(int idx, char *buf) FAST_FUNC;
 const char *ll_index_to_name(int idx) FAST_FUNC;
-const char *ll_idx_n2a(int idx, char *buf) FAST_FUNC;
 /* int ll_index_to_type(int idx); */
 unsigned ll_index_to_flags(int idx) FAST_FUNC;

branches/3.3/mindi-busybox/networking/libiproute/ll_proto.c

r3232	r3621
85	85	/* Keep declarations above and below in sync! */
86	86
87		static const char llproto_names[] =
	87	static const char llproto_names[] ALIGN1 =
88	88	#define __PF(f,n) #n "\0"
89	89	__PF(LOOP,loop)

branches/3.3/mindi-busybox/networking/libiproute/ll_types.c

-              r3232
+              r3621
 const char* FAST_FUNC ll_type_n2a(int type, char *buf)
+{
     static const char arphrd_name[] =
+    static const char arphrd_name[] ALIGN1 =
     /* 0,                  */ "generic" "\0"
     /* ARPHRD_LOOPBACK,    */ "loopback" "\0"
 …
     /* Keep these arrays in sync! */
     static const uint16_t arphrd_type[] = {
+    static const uint16_t arphrd_type[] ALIGN2 = {
 ,                  /* "generic" "\0" */
     ARPHRD_LOOPBACK,    /* "loopback" "\0" */

branches/3.3/mindi-busybox/networking/libiproute/rt_names.c

-              r2725
+              r3621
 #include "rt_names.h"
+#define CONFDIR          CONFIG_FEATURE_IP_ROUTE_DIR
 typedef struct rtnl_tab_t {
     const char *cached_str;
     unsigned cached_result;
+    const char *tab[256];
+    /* upstream version switched to a hash table and removed
+     * id < 256 limit. For now bbox bumps this array size from 256
+     * to 1024. If you plan to change this to a hash table,
+     * consider merging several hash tables we have (for example,
+     * awk has resizable one!
+     */
+#define RT_TABLE_MAX 1023
+    const char *tab[RT_TABLE_MAX+1];
 } rtnl_tab_t;
 …
+{
     char *token[2];
+    parser_t *parser = config_open2(file, fopen_for_read);
+    char fullname[sizeof(CONFDIR"/rt_dsfield") + 8];
+    parser_t *parser;
+    sprintf(fullname, CONFDIR"/rt_%s", file);
+    parser = config_open2(fullname, fopen_for_read);
     while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL)) {
         unsigned id = bb_strtou(token[0], NULL, 0);
         if (id > 256) {
+        if (id > RT_TABLE_MAX) {
             bb_error_msg("database %s is corrupted at line %d",
                 file, parser->lineno);
 …
+    }
     for (i = 0; i < 256; i++) {
+    for (i = 0; i <= RT_TABLE_MAX; i++) {
         if (tab->tab[i]
          && strcmp(tab->tab[i], arg) == 0
 …
     i = bb_strtou(arg, NULL, base);
     if (i > 255)
+    if (i > RT_TABLE_MAX)
         return -1;
     *id = i;
 …
     rtnl_rtprot_tab = xzalloc(sizeof(*rtnl_rtprot_tab));
     memcpy(rtnl_rtprot_tab->tab, init_tab, sizeof(init_tab));
     rtnl_tab_initialize("/etc/iproute2/rt_protos", rtnl_rtprot_tab->tab);
+}
+const char* FAST_FUNC rtnl_rtprot_n2a(int id, char *buf)
+{
     if (id < 0 || id >= 256) {
         sprintf(buf, "%d", id);
         return buf;
+    rtnl_tab_initialize("protos", rtnl_rtprot_tab->tab);
+}
+#if 0 /* UNUSED */
+const char* FAST_FUNC rtnl_rtprot_n2a(int id)
+{
+    if (id < 0 || id > RT_TABLE_MAX) {
+        return itoa(id);
+    }
 …
     if (rtnl_rtprot_tab->tab[id])
         return rtnl_rtprot_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
+    return buf;
+}
+    return itoa(id);
+}
+#endif
 int FAST_FUNC rtnl_rtprot_a2n(uint32_t *id, char *arg)
 …
     rtnl_rtscope_tab->tab[253] = "link";
     rtnl_rtscope_tab->tab[200] = "site";
+    rtnl_tab_initialize("/etc/iproute2/rt_scopes", rtnl_rtscope_tab->tab);
+}
+const char* FAST_FUNC rtnl_rtscope_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
+        return buf;
+    rtnl_tab_initialize("scopes", rtnl_rtscope_tab->tab);
+}
+const char* FAST_FUNC rtnl_rtscope_n2a(int id)
+{
+    if (id < 0 || id > RT_TABLE_MAX) {
+        return itoa(id);
+    }
 …
     if (rtnl_rtscope_tab->tab[id])
         return rtnl_rtscope_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
+    return buf;
+    return itoa(id);
+}
 …
     rtnl_rtrealm_tab = xzalloc(sizeof(*rtnl_rtrealm_tab));
     rtnl_rtrealm_tab->tab[0] = "unknown";
     rtnl_tab_initialize("/etc/iproute2/rt_realms", rtnl_rtrealm_tab->tab);
+    rtnl_tab_initialize("realms", rtnl_rtrealm_tab->tab);
+}
 …
 #if ENABLE_FEATURE_IP_RULE
+const char* FAST_FUNC rtnl_rtrealm_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
+        return buf;
+const char* FAST_FUNC rtnl_rtrealm_n2a(int id)
+{
+    if (id < 0 || id > RT_TABLE_MAX) {
+        return itoa(id);
+    }
 …
     if (rtnl_rtrealm_tab->tab[id])
         return rtnl_rtrealm_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
+    return buf;
+    return itoa(id);
+}
 #endif
 …
     rtnl_rtdsfield_tab = xzalloc(sizeof(*rtnl_rtdsfield_tab));
     rtnl_rtdsfield_tab->tab[0] = "0";
+    rtnl_tab_initialize("/etc/iproute2/rt_dsfield", rtnl_rtdsfield_tab->tab);
+}
+const char* FAST_FUNC rtnl_dsfield_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
+        return buf;
+    rtnl_tab_initialize("dsfield", rtnl_rtdsfield_tab->tab);
+}
+const char* FAST_FUNC rtnl_dsfield_n2a(int id)
+{
+    if (id < 0 || id > RT_TABLE_MAX) {
+        return itoa(id);
+    }
 …
     if (rtnl_rtdsfield_tab->tab[id])
         return rtnl_rtdsfield_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "0x%02x", id);
+    return buf;
+    return itoa(id);
+}
 …
 static void rtnl_rttable_initialize(void)
+{
+    if (rtnl_rtdsfield_tab) return;
+    if (rtnl_rttable_tab)
+        return;
     rtnl_rttable_tab = xzalloc(sizeof(*rtnl_rttable_tab));
     rtnl_rttable_tab->tab[0] = "unspec";
 …
     rtnl_rttable_tab->tab[254] = "main";
     rtnl_rttable_tab->tab[253] = "default";
+    rtnl_tab_initialize("/etc/iproute2/rt_tables", rtnl_rttable_tab->tab);
+}
+const char* FAST_FUNC rtnl_rttable_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
+        return buf;
+    rtnl_tab_initialize("tables", rtnl_rttable_tab->tab);
+}
+const char* FAST_FUNC rtnl_rttable_n2a(int id)
+{
+    if (id < 0 || id > RT_TABLE_MAX) {
+        return itoa(id);
+    }
 …
     if (rtnl_rttable_tab->tab[id])
         return rtnl_rttable_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
+    return buf;
+    return itoa(id);
+}

branches/3.3/mindi-busybox/networking/libiproute/rt_names.h

-              r2725
+              r3621
 PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
+/* buf is SPRINT_BSIZE big */
+extern const char* rtnl_rtprot_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_rtscope_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_rtrealm_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_dsfield_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_rttable_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_rtprot_n2a(int id) FAST_FUNC;
+extern const char* rtnl_rtscope_n2a(int id) FAST_FUNC;
+extern const char* rtnl_rtrealm_n2a(int id) FAST_FUNC;
+extern const char* rtnl_dsfield_n2a(int id) FAST_FUNC;
+extern const char* rtnl_rttable_n2a(int id) FAST_FUNC;
 extern int rtnl_rtprot_a2n(uint32_t *id, char *arg) FAST_FUNC;
 extern int rtnl_rtscope_a2n(uint32_t *id, char *arg) FAST_FUNC;

branches/3.3/mindi-busybox/networking/libiproute/rtm_map.c

-              r2725
+              r3621
 #include "utils.h"
 const char* FAST_FUNC rtnl_rtntype_n2a(int id, char *buf)
+const char* FAST_FUNC rtnl_rtntype_n2a(int id)
+{
     switch (id) {
 …
         return "xresolve";
     default:
+        /* buf is SPRINT_BSIZE big */
+        sprintf(buf, "%d", id);
+        return buf;
+        return itoa(id);
+    }
+}

branches/3.3/mindi-busybox/networking/libiproute/rtm_map.h

r2725	r3621
5	5	PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
6	6
7		const char rtnl_rtntype_n2a(int id~~, char buf~~) FAST_FUNC;
	7	const char *rtnl_rtntype_n2a(int id) FAST_FUNC;
8	8	int rtnl_rtntype_a2n(int id, char arg) FAST_FUNC;
9	9

branches/3.3/mindi-busybox/networking/libiproute/utils.c

-              r3232
+              r3621
 #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)
+{
 …
+        }
+    }
     invarg(arg, errmsg); /* does not return */
+    invarg_1_to_2(arg, errmsg); /* does not return */
+}
 …
+        }
+    }
     invarg(arg, errmsg); /* does not return */
+    invarg_1_to_2(arg, errmsg); /* does not return */
+}
 …
+        }
+    }
     invarg(arg, errmsg); /* does not return */
+    invarg_1_to_2(arg, errmsg); /* does not return */
+}
 …
 void incomplete_command(void)
+{
     bb_error_msg_and_die("command line is not complete, try option \"help\"");
+}
 void invarg(const char *arg, const char *opt)
+{
     bb_error_msg_and_die(bb_msg_invalid_arg, arg, opt);
+    bb_error_msg_and_die("command line is not complete, try \"help\"");
+}
+void invarg_1_to_2(const char *arg, const char *opt)
+{
+    bb_error_msg_and_die(bb_msg_invalid_arg_to, arg, opt);
+}
 …
+}
+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) {
 …
             h_ent = gethostbyaddr(addr, len, af);
             if (h_ent != NULL) {
+                safe_strncpy(buf, h_ent->h_name, buflen);
+                return buf;
+            }
+        }
+    }
+    return rt_addr_n2a(af, addr, buf, buflen);
+                return auto_string(xstrdup(h_ent->h_name));
+            }
+        }
+    }
+    return rt_addr_n2a(af, addr);
+}
 #endif

branches/3.3/mindi-busybox/networking/libiproute/utils.h

-              r3232
+              r3621
 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 ipx_pton(int af, const char *src, void *addr);
+unsigned get_hz(void);
 POP_SAVED_FUNCTION_VISIBILITY

branches/3.3/mindi-busybox/networking/nameif.c

-              r3232
+              r3621
             *next++ = '\0';
         /* Check for selectors, mac= is assumed */
         if (strncmp(selector, "bus=", 4) == 0) {
+        if (is_prefixed_with(selector, "bus=")) {
             ch->bus_info = xstrdup(selector + 4);
             found_selector++;
         } else if (strncmp(selector, "driver=", 7) == 0) {
+        } else if (is_prefixed_with(selector, "driver=")) {
             ch->driver = xstrdup(selector + 7);
             found_selector++;
         } else if (strncmp(selector, "phyaddr=", 8) == 0) {
+        } else if (is_prefixed_with(selector, "phyaddr=")) {
             ch->phy_address = xatoi_positive(selector + 8);
             found_selector++;
 …
 #endif
             lmac = xmalloc(ETH_ALEN);
             ch->mac = ether_aton_r(selector + (strncmp(selector, "mac=", 4) != 0 ? 0 : 4), lmac);
+            ch->mac = ether_aton_r(selector + (is_prefixed_with(selector, "mac=") ? 4 : 0), lmac);
             if (ch->mac == NULL)
                 bb_error_msg_and_die("can't parse %s", selector);
 …
                 continue;
             /* if we came here, all selectors have matched */
             break;
+            goto found;
+        }
         /* Nothing found for current interface */
+        if (!ch)
+            continue;
+        continue;
+ found:
         if (strcmp(ifr.ifr_name, ch->ifname) != 0) {
             strcpy(ifr.ifr_newname, ch->ifname);
 …
         if (ENABLE_FEATURE_CLEAN_UP)
             delete_eth_table(ch);
+    }
+    } /* while */
     if (ENABLE_FEATURE_CLEAN_UP) {
+        for (ch = clist; ch; ch = ch->next)
+        ethtable_t *next;
+        for (ch = clist; ch; ch = next) {
+            next = ch->next;
             delete_eth_table(ch);
+        }
         config_close(parser);
     };

branches/3.3/mindi-busybox/networking/nbd-client.c

-              r3232
+              r3621
         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)
 …
         // Find and connect to server
         sock = create_and_connect_stream_or_die(host, xatou16(port));
         setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &const_int_1, sizeof(const_int_1));
+        setsockopt_1(sock, IPPROTO_TCP, TCP_NODELAY);
         // Log on to the server

branches/3.3/mindi-busybox/networking/nc.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 //config:config NC
 …
 //config:
 //config:config NC_EXTRA
 //config:   bool "Netcat extensions (-eiw and filename)"
+//config:   bool "Netcat extensions (-eiw and -f FILE)"
 //config:   default y
 //config:   depends on NC
 …
 //config:     The code is about 2.5k bigger. It enables
 //config:     -s ADDR, -n, -u, -v, -o FILE, -z options, but loses
 //config:     busybox-specific extensions: -f FILE and -ll.
+//config:     busybox-specific extensions: -f FILE.
 #if ENABLE_NC_110_COMPAT
 …
 //usage:       "Open a pipe to IP:PORT" IF_NC_EXTRA(" or FILE")
 //usage:    NC_OPTIONS_STR
-//usage:    IF_NC_EXTRA(
-//usage:     "\n    -e PROG Run PROG after connect"
 //usage:    IF_NC_SERVER(
 //usage:     "\n    -l  Listen mode, for inbound connects"
 //usage:    IF_NC_EXTRA(
+//usage:     "\n        (use -l twice with -e for persistent server)")
+//usage:     "\n        (use -ll with -e for persistent server)"
+//usage:    )
 //usage:     "\n    -p PORT Local port"
 //usage:    )
+//usage:     "\n    -w SEC  Timeout for connect"
+//usage:    IF_NC_EXTRA(
+//usage:     "\n    -w SEC  Connect timeout"
 //usage:     "\n    -i SEC  Delay interval for lines sent"
 //usage:     "\n    -f FILE Use file (ala /dev/ttyS0) instead of network"
+//usage:     "\n    -e PROG Run PROG after connect"
 //usage:    )
 //usage:
 …
+                    }
+                )
                 /* optind points to argv[arvc] (NULL) now.
+                /* optind points to argv[argc] (NULL) now.
                 ** FIXME: we assume that getopt will not count options
                 ** possibly present on "-e PROG ARGS" and will not
 …
         xmove_fd(cfd, 0);
         xdup2(0, 1);
         xdup2(0, 2);
+        /*xdup2(0, 2); - original nc 1.10 does this, we don't */
         IF_NC_EXTRA(BB_EXECVP(execparam[0], execparam);)
+        /* Don't print stuff or it will go over the wire... */
+        _exit(127);
+        IF_NC_EXTRA(bb_perror_msg_and_die("can't execute '%s'", execparam[0]);)
+    }
 …
     FD_SET(STDIN_FILENO, &readfds);
+#define iobuf bb_common_bufsiz1
+    setup_common_bufsiz();
     for (;;) {
         int fd;
 …
             bb_perror_msg_and_die("select");
-#define iobuf bb_common_bufsiz1
         fd = STDIN_FILENO;
         while (1) {
             if (FD_ISSET(fd, &testfds)) {
                 nread = safe_read(fd, iobuf, sizeof(iobuf));
+                nread = safe_read(fd, iobuf, COMMON_BUFSIZE);
                 if (fd == cfd) {
                     if (nread < 1)
 …
                         /* Close outgoing half-connection so they get EOF,
                          * but leave incoming alone so we can see response */
                         shutdown(cfd, 1);
+                        shutdown(cfd, SHUT_WR);
                         FD_CLR(STDIN_FILENO, &readfds);
+                    }

branches/3.3/mindi-busybox/networking/nc_bloaty.c

-              r3232
+              r3621
  *   on the command line, but accept() says that it came from different addr)
  *   are closed, but we don't exit - we continue to listen/accept.
+ * Since bbox 1.22:
+ * - nc exits when _both_ stdin and network are closed.
+ *   This makes these two commands:
+ *    echo "Yes" | nc 127.0.0.1 1234
+ *    echo "no" | nc -lp 1234
+ *   exchange their data _and exit_ instead of being stuck.
  */
 …
 //usage:    IF_NC_SERVER(
 //usage:     "\n    -l  Listen mode, for inbound connects"
+//usage:     "\n    -lk With -e, provides persistent server"
+/* -ll does the same as -lk, but its our extension, while -k is BSD'd,
+ * presumably more widely known. Therefore we advertise it, not -ll.
+ * I would like to drop -ll support, but our "small" nc supports it,
+ * and Rob uses it.
+ */
 //usage:    )
 //usage:     "\n    -p PORT Local port"
 …
     jmp_buf jbuf;                /* timer crud */
-    fd_set ding1;                /* for select loop */
-    fd_set ding2;
     char bigbuf_in[BIGSIZ];      /* data buffers */
     char bigbuf_net[BIGSIZ];
 …
 #define remend     (G.remend    )
 #define jbuf       (G.jbuf      )
-#define ding1      (G.ding1     )
-#define ding2      (G.ding2     )
 #define bigbuf_in  (G.bigbuf_in )
 #define bigbuf_net (G.bigbuf_net)
 …
     OPT_w = (1 << 5),
     OPT_l = (1 << 6) * ENABLE_NC_SERVER,
+    OPT_i = (1 << (6+ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+    OPT_o = (1 << (7+ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+    OPT_z = (1 << (8+ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+    OPT_k = (1 << 7) * ENABLE_NC_SERVER,
+    OPT_i = (1 << (6+2*ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+    OPT_o = (1 << (7+2*ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+    OPT_z = (1 << (8+2*ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
 };
 #define o_nflag   (option_mask32 & OPT_n)
 #define o_udpmode (option_mask32 & OPT_u)
-#if ENABLE_NC_SERVER
-#define o_listen  (option_mask32 & OPT_l)
-#else
-#define o_listen  0
-#endif
 #if ENABLE_NC_EXTRA
 #define o_ofile   (option_mask32 & OPT_o)
 …
  given host/port args, any connections from elsewhere are rejected.  This
  in conjunction with local-address binding should limit things nicely... */
 static void dolisten(void)
+static void dolisten(int is_persistent, char **proggie)
+{
     int rr;
 …
     } else {
         /* TCP */
+ another:
         arm(o_wait); /* wrap this in a timer, too; 0 = forever */
         if (setjmp(jbuf) == 0) {
 …
         } else
             bb_error_msg_and_die("timeout");
+        if (is_persistent && proggie) {
+            /* -l -k -e PROG */
+            signal(SIGCHLD, SIG_IGN); /* no zombies please */
+            if (xvfork() != 0) {
+                /* parent: go back and accept more connections */
+                close(rr);
+                goto another;
+            }
+            /* child */
+            signal(SIGCHLD, SIG_DFL);
+        }
         xmove_fd(rr, netfd); /* dump the old socket, here's our new one */
         /* find out what address the connection was *to* on our end, in case we're
 …
             free(remhostname);
+    }
+    if (proggie)
+        doexec(proggie);
+}
 …
     unsigned rnleft;
     unsigned netretry;              /* net-read retry counter */
+    unsigned wretry;                /* net-write sanity counter */
+    unsigned wfirst;                /* one-shot flag to skip first net read */
+    unsigned fds_open;
     /* if you don't have all this FD_* macro hair in sys/types.h, you'll have to
      either find it or do your own bit-bashing: *ding1 |= (1 << fd), etc... */
+    FD_SET(netfd, &ding1);                /* global: the net is open */
+    fd_set ding1;                   /* for select loop */
+    fd_set ding2;
+    FD_ZERO(&ding1);
+    FD_SET(netfd, &ding1);
+    FD_SET(STDIN_FILENO, &ding1);
+    fds_open = 2;
     netretry = 2;
-    wfirst = 0;
     rzleft = rnleft = 0;
     if (o_interval)
         sleep(o_interval);                /* pause *before* sending stuff, too */
-    errno = 0;                        /* clear from sleep, close, whatever */
     /* and now the big ol' select shoveling loop ... */
+    while (FD_ISSET(netfd, &ding1)) {        /* i.e. till the *net* closes! */
+        wretry = 8200;                        /* more than we'll ever hafta write */
+        if (wfirst) {                        /* any saved stdin buffer? */
+            wfirst = 0;                        /* clear flag for the duration */
+            goto shovel;                        /* and go handle it first */
+        }
+    /* nc 1.10 has "while (FD_ISSET(netfd)" here */
+    while (fds_open) {
+        unsigned wretry = 8200;               /* net-write sanity counter */
         ding2 = ding1;                        /* FD_COPY ain't portable... */
     /* some systems, notably linux, crap into their select timers on return, so
 …
      from the net during that time, assume it's dead and close it too. */
         if (rr == 0) {
             if (!FD_ISSET(STDIN_FILENO, &ding1))
+            if (!FD_ISSET(STDIN_FILENO, &ding1)) {
                 netretry--;                        /* we actually try a coupla times. */
+            if (!netretry) {
+                if (o_verbose > 1)                /* normally we don't care */
+                    fprintf(stderr, "net timeout\n");
+                close(netfd);
+                return 0;                        /* not an error! */
+                if (!netretry) {
+                    if (o_verbose > 1)         /* normally we don't care */
+                        fprintf(stderr, "net timeout\n");
+                    /*close(netfd); - redundant, exit will do it */
+                    return 0;                  /* not an error! */
+                }
+            }
         } /* select timeout */
 …
                     bb_perror_msg("net read");
+                }
+                FD_CLR(netfd, &ding1);                /* net closed, we'll finish up... */
+                FD_CLR(netfd, &ding1);                /* net closed */
+                fds_open--;
                 rzleft = 0;                        /* can't write anymore: broken pipe */
             } else {
 …
      mobygrams are kinda fun and exercise the reassembler. */
             if (rr <= 0) {                        /* at end, or fukt, or ... */
+                FD_CLR(STDIN_FILENO, &ding1);                /* disable and close stdin */
+                close(STDIN_FILENO);
+// Does it make sense to shutdown(net_fd, SHUT_WR)
+// to let other side know that we won't write anything anymore?
+// (and what about keeping compat if we do that?)
+                FD_CLR(STDIN_FILENO, &ding1); /* disable stdin */
+                /*close(STDIN_FILENO); - not really necessary */
+                /* Let peer know we have no more data */
+                /* nc 1.10 doesn't do this: */
+                shutdown(netfd, SHUT_WR);
+                fds_open--;
             } else {
                 rzleft = rr;
 …
      not sure if the order of this matters, but write net -> stdout first. */
-    /* sanity check.  Works because they're both unsigned... */
-        if ((rzleft > 8200) || (rnleft > 8200)) {
-            holler_error("bogus buffers: %u, %u", rzleft, rnleft);
-            rzleft = rnleft = 0;
+        }
-    /* net write retries sometimes happen on UDP connections */
-        if (!wretry) {                        /* is something hung? */
-            holler_error("too many output retries");
-            return 1;
+        }
         if (rnleft) {
             rr = write(STDOUT_FILENO, np, rnleft);
 …
                 if (o_ofile) /* log the stdout */
                     oprint('<', (unsigned char *)np, rr);
                 np += rr;                        /* fix up ptrs and whatnot */
                 rnleft -= rr;                        /* will get sanity-checked above */
                 wrote_out += rr;                /* global count */
+                np += rr;
+                rnleft -= rr;
+                wrote_out += rr; /* global count */
+            }
 Debug("wrote %d to stdout, errno %d", rr, errno);
 …
                 zp += rr;
                 rzleft -= rr;
                 wrote_net += rr;                /* global count */
+                wrote_net += rr; /* global count */
+            }
 Debug("wrote %d to net, errno %d", rr, errno);
 …
         if (o_interval) {                        /* cycle between slow lines, or ... */
             sleep(o_interval);
-            errno = 0;                        /* clear from sleep */
             continue;                        /* ...with hairy select loop... */
+        }
         if ((rzleft) || (rnleft)) {                /* shovel that shit till they ain't */
+        if (rzleft || rnleft) {                  /* shovel that shit till they ain't */
             wretry--;                        /* none left, and get another load */
+    /* net write retries sometimes happen on UDP connections */
+            if (!wretry) {                   /* is something hung? */
+                holler_error("too many output retries");
+                return 1;
+            }
             goto shovel;
+        }
     } /* while ding1:netfd is open */
+    } /* while (fds_open) */
     /* XXX: maybe want a more graceful shutdown() here, or screw around with
 …
     char **proggie;
     int x;
+    unsigned cnt_l = 0;
     unsigned o_lport = 0;
 …
             char *optpos = *proggie + 1;
             /* Skip all valid opts w/o params */
             optpos = optpos + strspn(optpos, "nuv"IF_NC_SERVER("l")IF_NC_EXTRA("z"));
+            optpos = optpos + strspn(optpos, "nuv"IF_NC_SERVER("lk")IF_NC_EXTRA("z"));
             if (*optpos == 'e' && !optpos[1]) {
                 *optpos = '\0';
 …
     // -g -G -t -r deleted, unimplemented -a deleted too
     opt_complementary = "?2:vv:w+"; /* max 2 params; -v is a counter; -w N */
     getopt32(argv, "np:s:uvw:" IF_NC_SERVER("l")
+    opt_complementary = "?2:vv:ll:w+"; /* max 2 params; -v and -l are counters; -w N */
+    getopt32(argv, "np:s:uvw:" IF_NC_SERVER("lk")
             IF_NC_EXTRA("i:o:z"),
             &str_p, &str_s, &o_wait
             IF_NC_EXTRA(, &str_i, &str_o), &o_verbose);
+            IF_NC_EXTRA(, &str_i, &str_o), &o_verbose IF_NC_SERVER(, &cnt_l));
     argv += optind;
 #if ENABLE_NC_EXTRA
 …
         o_interval = xatou_range(str_i, 1, 0xffff);
 #endif
+#if ENABLE_NC_SERVER
     //if (option_mask32 & OPT_l) /* listen mode */
+    if (option_mask32 & OPT_k) /* persistent server mode */
+        cnt_l = 2;
+#endif
     //if (option_mask32 & OPT_n) /* numeric-only, no DNS lookups */
     //if (option_mask32 & OPT_o) /* hexdump log */
 …
         socket_want_pktinfo(netfd);
     if (!ENABLE_FEATURE_UNIX_LOCAL
      || o_listen
+     || cnt_l != 0 /* listen */
      || ouraddr->u.sa.sa_family != AF_UNIX
     ) {
 …
+    }
 #if 0
     setsockopt(netfd, SOL_SOCKET, SO_RCVBUF, &o_rcvbuf, sizeof o_rcvbuf);
     setsockopt(netfd, SOL_SOCKET, SO_SNDBUF, &o_sndbuf, sizeof o_sndbuf);
+    setsockopt_SOL_SOCKET_int(netfd, SO_RCVBUF, o_rcvbuf);
+    setsockopt_SOL_SOCKET_int(netfd, SO_SNDBUF, o_sndbuf);
 #endif
 …
 #endif
-    FD_SET(STDIN_FILENO, &ding1);                        /* stdin *is* initially open */
     if (proggie) {
         close(0); /* won't need stdin */
+        close(STDIN_FILENO); /* won't need stdin */
         option_mask32 &= ~OPT_o; /* -o with -e is meaningless! */
+    }
 …
 #endif
     if (o_listen) {
         dolisten();
+    if (cnt_l != 0) {
+        dolisten((cnt_l - 1), proggie);
         /* dolisten does its own connect reporting */
-        if (proggie) /* -e given? */
-            doexec(proggie);
         x = readwrite(); /* it even works with UDP! */
     } else {

branches/3.3/mindi-busybox/networking/netstat.c

-              r3232
+              r3621
 /* When there are IPv6 connections the IPv6 addresses will be
  * truncated to none-recognition. The '-W' option makes the
  * address columns wide enough to accomodate for longest possible
+ * address columns wide enough to accommodate for longest possible
  * IPv6 addresses, i.e. addresses of the form
  * xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:ddd.ddd.ddd.ddd
 …
 #define ADDR_WIDE                51  /* INET6_ADDRSTRLEN + 5 for the port number */
 #if ENABLE_FEATURE_NETSTAT_WIDE
 # define FMT_NET_CONN_DATA       "%s   %6ld %6ld %-*s %-*s %-12s"
+# define FMT_NET_CONN_DATA       "%s   %6lu %6lu %-*s %-*s %-12s"
 # define FMT_NET_CONN_HEADER     "\nProto Recv-Q Send-Q %-*s %-*s State       %s\n"
 #else
 # define FMT_NET_CONN_DATA       "%s   %6ld %6ld %-23s %-23s %-12s"
+# define FMT_NET_CONN_DATA       "%s   %6lu %6lu %-23s %-23s %-12s"
 # define FMT_NET_CONN_HEADER     "\nProto Recv-Q Send-Q %-23s %-23s State       %s\n"
 #endif
 …
     long inode = -1;
     if (strncmp(lname, "socket:[", sizeof("socket:[")-1) == 0) {
+    if (is_prefixed_with(lname, "socket:[")) {
         /* "socket:[12345]", extract the "12345" as inode */
         inode = bb_strtoul(lname + sizeof("socket:[")-1, (char**)&lname, 0);
         if (*lname != ']')
             inode = -1;
     } else if (strncmp(lname, "[0000]:", sizeof("[0000]:")-1) == 0) {
+    } else if (is_prefixed_with(lname, "[0000]:")) {
         /* "[0000]:12345", extract the "12345" as inode */
         inode = bb_strtoul(lname + sizeof("[0000]:")-1, NULL, 0);
 …
             "%32[0-9A-Fa-f]:%X %X "
             "%lX:%lX %*X:%*X "
             "%*X %d %*d %ld ",
+            "%*X %d %*d %lu ",
             local_addr, &param->local_port,
             rem_addr, &param->rem_port, &param->state,
 …
     strcat(ss_flags, "]");
     printf("%-5s %-6ld %-11s %-10s %-13s %6lu ",
+    printf("%-5s %-6lu %-11s %-10s %-13s %6lu ",
         ss_proto, refcnt, ss_flags, ss_type, ss_state, inode
         );
 …
     /* TODO: currently we stop at first NUL byte. Is it a problem? */
     line += path_ofs;
     *strchrnul(line, '\n') = '\0';
+    chomp(line);
     while (*line)
         fputc_printable(*line++, stdout);

branches/3.3/mindi-busybox/networking/nslookup.c

-              r3232
+              r3621
     len_and_sockaddr *lsa;
+    if (!server)
+        return;
     /* NB: this works even with, say, "[::1]:5353"! :) */
     lsa = xhost2sockaddr(server, 53);
 …
     /*_res.options |= RES_USE_INET6;*/
+    if (argv[2])
+        set_default_dns(argv[2]);
+    set_default_dns(argv[2]);
     server_print();
+    /* getaddrinfo and friends are free to request a resolver
+     * reinitialization. Just in case, set_default_dns() again
+     * after getaddrinfo (in server_print). This reportedly helps
+     * with bug 675 "nslookup does not properly use second argument"
+     * at least on Debian Wheezy and Openwrt AA (eglibc based).
+     */
+    set_default_dns(argv[2]);
     return print_host(argv[1], "Name:");
+}

branches/3.3/mindi-busybox/networking/ntpd.c

-              r3232
+              r3621
  * NTP client/server, based on OpenNTPD 3.9p1
+ *
  * Author: Adam Tkac <vonsch@gmail.com>
+ * Busybox port author: Adam Tkac (C) 2009 <vonsch@gmail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ * OpenNTPd 3.9p1 copyright holders:
+ *   Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
+ *   Copyright (c) 2004 Alexander Guy <alexander.guy@andern.org>
+ *
+ * OpenNTPd code is licensed under ISC-style licence:
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ ***********************************************************************
+ *
  * Parts of OpenNTPD clock syncronization code is replaced by
  * code which is based on ntp-4.2.6, whuch carries the following
+ * code which is based on ntp-4.2.6, which carries the following
  * copyright notice:
+ *
+ ***********************************************************************
+ *                                                                     *
+ * Copyright (c) University of Delaware 1992-2009                      *
+ *                                                                     *
+ * Permission to use, copy, modify, and distribute this software and   *
+ * its documentation for any purpose with or without fee is hereby     *
+ * granted, provided that the above copyright notice appears in all    *
+ * copies and that both the copyright notice and this permission       *
+ * notice appear in supporting documentation, and that the name        *
+ * University of Delaware not be used in advertising or publicity      *
+ * pertaining to distribution of the software without specific,        *
+ * written prior permission. The University of Delaware makes no       *
+ * representations about the suitability this software for any         *
+ * purpose. It is provided "as is" without express or implied          *
+ * warranty.                                                           *
+ *                                                                     *
+ * Copyright (c) University of Delaware 1992-2009
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose with or without fee is hereby
+ * granted, provided that the above copyright notice appears in all
+ * copies and that both the copyright notice and this permission
+ * notice appear in supporting documentation, and that the name
+ * University of Delaware not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission. The University of Delaware makes no
+ * representations about the suitability this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
  ***********************************************************************
  */
 //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    -N  Run at high priority"
 //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:    )
 //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)"
+//usage:    IF_FEATURE_NTPD_CONF(
+//usage:     "\n        If -p is not given, 'server HOST' lines"
+//usage:     "\n        from /etc/ntp.conf are used"
+//usage:    )
+//usage:    IF_FEATURE_NTPD_SERVER(
+//usage:     "\n    -l  Also run as server on port 123"
+//usage:     "\n    -I IFACE Bind server to IFACE, implies -l"
+//usage:    )
+// -l and -p options are not compatible with "standard" ntpd:
+// it has them as "-l logfile" and "-p pidfile".
+// -S and -w are not compat either, "standard" ntpd has no such opts.
 #include "libbb.h"
 …
 # define IPTOS_LOWDELAY 0x10
 #endif
-#ifndef IP_PKTINFO
-# error "Sorry, your kernel has to support IP_PKTINFO"
-#endif
 /* Verbosity control (max level of -dddd options accepted).
  * max 5 is very talkative (and bloated). 2 is non-bloated,
+ * max 6 is very talkative (and bloated). 3 is non-bloated,
  * production level setting.
  */
 #define MAX_VERBOSE     2
+#define MAX_VERBOSE     3
 …
  * then the time is stepped, all datapoints are discarded,
  * and we go back to steady state.
+ *
+ * Made some changes to speed up re-syncing after our clock goes bad
+ * (tested with suspending my laptop):
+ * - 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:
+ *   e.g. at poll = 10 (1024 secs), step was done within 5 minutes
+ *   after first reply which indicated that our clock is 14 seconds off.
+ * - on step, do not discard d_dispersion data of the existing datapoints,
+ *   do not clear reachable_bits. This prevents discarding first ~8
+ *   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 */
+/* Clock discipline parameters and constants */
+#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 */
+#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 */
+#define STEP_THRESHOLD  0.125
+#define WATCH_THRESHOLD 128     /* stepout threshold (sec). std ntpd uses 900 (11 mins (!)) */
+ */
+#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 SLEW_THRESHOLD 0.125
+/* 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
+#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 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.
+ * 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)
+/*
+ * Actively lower poll when we see such big offsets.
+ * With SLEW_THRESHOLD = 0.125, it means we try to sync more aggressively
+ * if offset increases over ~0.04 sec
+ */
+//#define POLLDOWN_OFFSET (SLEW_THRESHOLD / 3)
 #define MINDISP         0.01    /* minimum dispersion (sec) */
 #define MAXDISP         16      /* maximum dispersion (sec) */
 …
     uint8_t          lastpkt_stratum;
     uint8_t          reachable_bits;
         /* when to send new query (if p_fd == -1)
          * or when receive times out (if p_fd >= 0): */
+    /* when to send new query (if p_fd == -1)
+     * or when receive times out (if p_fd >= 0): */
     double           next_action_time;
     double           p_xmttime;
+    double           p_raw_delay;
+    /* p_raw_delay is set even by "high delay" packets */
+    /* lastpkt_delay isn't */
     double           lastpkt_recv_time;
     double           lastpkt_delay;
 …
     /* last sent packet: */
     msg_t            p_xmt_msg;
+    char             p_hostname[1];
 } peer_t;
 …
     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),
 …
 #if ENABLE_FEATURE_NTPD_SERVER
     int      listen_fd;
+    char     *if_name;
 # define G_listen_fd (G.listen_fd)
 #else
 …
 #define G_precision_sec  0.002
     uint8_t  stratum;
-    /* Bool. After set to 1, never goes back to 0: */
-    smallint initial_poll_complete;
 #define STATE_NSET      0       /* initial state, "nothing is set" */
 //#define STATE_FSET    1       /* frequency set from file */
 #define STATE_SPIK      2       /* spike detected */
+//#define STATE_SPIK    2       /* spike detected */
 //#define STATE_FREQ    3       /* initial frequency */
 #define STATE_SYNC      4       /* clock synchronized (normal operation) */
 …
 #define G (*ptr_to_globals)
-static const int const_IPTOS_LOWDELAY = IPTOS_LOWDELAY;
 #define VERB1 if (MAX_VERBOSE && G.verbose)
 …
 #define VERB4 if (MAX_VERBOSE >= 4 && G.verbose >= 4)
 #define VERB5 if (MAX_VERBOSE >= 5 && G.verbose >= 5)
+#define VERB6 if (MAX_VERBOSE >= 6 && G.verbose >= 6)
 …
     sum = 0;
     for (i = 0; i < NUM_DATAPOINTS; i++) {
         VERB4 {
+        VERB5 {
             bb_error_msg("datapoint[%d]: off:%f disp:%f(%f) age:%f%s",
                 i,
 …
     p->filter_jitter = sum > G_precision_sec ? sum : G_precision_sec;
     VERB3 bb_error_msg("filter offset:%+f disp:%f jitter:%f",
+    VERB4 bb_error_msg("filter offset:%+f disp:%f jitter:%f",
             p->filter_offset,
             p->filter_dispersion,
 …
+{
     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:
+     * after step (tested with suspending laptop for ~30 secs),
+     * this caused all previous data to be considered invalid,
+     * making us needing to collect full ~8 datapoins per peer
+     * after step in order to start trusting them.
+     * In turn, this was making poll interval decrease even after
+     * step was done. (Poll interval decreases already before step
+     * in this scenario, because we see large offsets and end up with
+     * no good peer to select).
+     */
     for (i = 0; i < NUM_DATAPOINTS; i++) {
 …
             p->filter_datapoint[i].d_recv_time  = G.cur_time;
             p->filter_datapoint[i].d_offset     = 0;
             p->filter_datapoint[i].d_dispersion = MAXDISP;
+            /*p->filter_datapoint[i].d_dispersion = MAXDISP;*/
+        }
+    }
 …
         p->lastpkt_recv_time += offset;
     } else {
         p->reachable_bits = 0;
+        /*p->reachable_bits = 0;*/
         p->lastpkt_recv_time = G.cur_time;
+    }
     filter_datapoints(p); /* recalc p->filter_xxx */
     VERB5 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
+    VERB6 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
+}
 static void
+add_peers(char *s)
+{
+resolve_peer_hostname(peer_t *p, int loop_on_fail)
+{
+    len_and_sockaddr *lsa;
+ again:
+    lsa = host2sockaddr(p->p_hostname, 123);
+    if (!lsa) {
+        /* error message already emitted by host2sockaddr() */
+        if (!loop_on_fail)
+            return;
+//FIXME: do this to avoid infinite looping on typo in a hostname?
+//well... in which case, what is a good value for loop_on_fail?
+        //if (--loop_on_fail == 0)
+        //  xfunc_die();
+        sleep(5);
+        goto again;
+    }
+    free(p->p_lsa);
+    free(p->p_dotted);
+    p->p_lsa = lsa;
+    p->p_dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
+}
+static void
+add_peers(const char *s)
+{
+    llist_t *item;
     peer_t *p;
+    p = xzalloc(sizeof(*p));
+    p->p_lsa = xhost2sockaddr(s, 123);
+    p->p_dotted = xmalloc_sockaddr2dotted_noport(&p->p_lsa->u.sa);
+    p = xzalloc(sizeof(*p) + strlen(s));
+    strcpy(p->p_hostname, s);
+    resolve_peer_hostname(p, /*loop_on_fail=*/ 1);
+    /* Names like N.<country2chars>.pool.ntp.org are randomly resolved
+     * to a pool of machines. Sometimes different N's resolve to the same IP.
+     * It is not useful to have two peers with same IP. We skip duplicates.
+     */
+    for (item = G.ntp_peers; item != NULL; item = item->link) {
+        peer_t *pp = (peer_t *) item->data;
+        if (strcmp(p->p_dotted, pp->p_dotted) == 0) {
+            bb_error_msg("duplicate peer %s (%s)", s, p->p_dotted);
+            free(p->p_lsa);
+            free(p->p_dotted);
+            free(p);
+            return;
+        }
+    }
     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);
 …
         if (family == AF_INET)
 #endif
             setsockopt(fd, IPPROTO_IP, IP_TOS, &const_IPTOS_LOWDELAY, sizeof(const_IPTOS_LOWDELAY));
+            setsockopt_int(fd, IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY);
         free(local_lsa);
+    }
 …
      * Save the real transmit timestamp locally.
      */
     p->p_xmt_msg.m_xmttime.int_partl = random();
     p->p_xmt_msg.m_xmttime.fractionl = random();
+    p->p_xmt_msg.m_xmttime.int_partl = rand();
+    p->p_xmt_msg.m_xmttime.fractionl = rand();
     p->p_xmttime = gettime1900d();
+    /* Were doing it only if sendto worked, but
+     * loss of sync detection needs reachable_bits updated
+     * even if sending fails *locally*:
+     * "network is unreachable" because cable was pulled?
+     * We still need to declare "unsync" if this condition persists.
+     */
+    p->reachable_bits <<= 1;
     if (do_sendto(p->p_fd, /*from:*/ NULL, /*to:*/ &p->p_lsa->u.sa, /*addrlen:*/ p->p_lsa->len,
 …
         close(p->p_fd);
         p->p_fd = -1;
+        /*
+         * We know that we sent nothing.
+         * We can retry *soon* without fearing
+         * that we are flooding the peer.
+         */
         set_next(p, RETRY_INTERVAL);
         return;
+    }
-    p->reachable_bits <<= 1;
     set_next(p, RESPONSE_INTERVAL);
+}
 …
 /* Note that there is no provision to prevent several run_scripts
  * to be done in quick succession. In fact, it happens rather often
+ * to be started in quick succession. In fact, it happens rather often
  * if initial syncronization results in a step.
  * You will see "step" and then "stratum" script runs, sometimes
 …
     char *argv[3];
     char *env1, *env2, *env3, *env4;
+    G.last_script_run = G.cur_time;
     if (!G.script_name)
 …
     free(env3);
     free(env4);
-    G.last_script_run = G.cur_time;
+}
 …
     VERB2 {
         tval = tvc.tv_sec;
         strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&tval));
+        strftime_YYYYMMDDHHMMSS(buf, sizeof(buf), &tval);
         bb_error_msg("current time is %s.%06u", buf, (unsigned)tvc.tv_usec);
+    }
     tval = tvn.tv_sec;
     strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&tval));
+    strftime_YYYYMMDDHHMMSS(buf, sizeof(buf), &tval);
     bb_error_msg("setting time to %s.%06u (offset %+fs)", buf, (unsigned)tvn.tv_usec, 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;
+}
 /*
 …
     if ((p->reachable_bits & (p->reachable_bits-1)) == 0) {
         /* One or zero bits in reachable_bits */
         VERB3 bb_error_msg("peer %s unfit for selection: unreachable", p->p_dotted);
+        VERB4 bb_error_msg("peer %s unfit for selection: unreachable", p->p_dotted);
         return 0;
+    }
 …
      || p->lastpkt_stratum >= MAXSTRAT
     ) {
         VERB3 bb_error_msg("peer %s unfit for selection: bad status/stratum", p->p_dotted);
+        VERB4 bb_error_msg("peer %s unfit for selection: bad status/stratum", p->p_dotted);
         return 0;
+    }
 …
     /* rd is root_distance(p) */
     if (rd > MAXDIST + FREQ_TOLERANCE * (1 << G.poll_exp)) {
         VERB3 bb_error_msg("peer %s unfit for selection: root distance too high", p->p_dotted);
+        VERB4 bb_error_msg("peer %s unfit for selection: root distance too high", p->p_dotted);
         return 0;
+    }
 …
     num_points = 0;
     item = G.ntp_peers;
     if (G.initial_poll_complete) while (item != NULL) {
+    while (item != NULL) {
         double rd, offset;
 …
+        }
         VERB4 bb_error_msg("interval: [%f %f %f] %s",
+        VERB5 bb_error_msg("interval: [%f %f %f] %s",
                 offset - rd,
                 offset,
 …
     num_candidates = num_points / 3;
     if (num_candidates == 0) {
         VERB3 bb_error_msg("no valid datapoints, no peer selected");
+        VERB3 bb_error_msg("no valid datapoints%s", ", no peer selected");
         return NULL;
+    }
 …
         num_falsetickers++;
         if (num_falsetickers * 2 >= num_candidates) {
+            VERB3 bb_error_msg("too many falsetickers:%d (candidates:%d), no peer selected",
+                    num_falsetickers, num_candidates);
+            VERB3 bb_error_msg("falsetickers:%d, candidates:%d%s",
+                    num_falsetickers, num_candidates,
+                    ", no peer selected");
             return NULL;
+        }
+    }
     VERB3 bb_error_msg("selected interval: [%f, %f]; candidates:%d falsetickers:%d",
+    VERB4 bb_error_msg("selected interval: [%f, %f]; candidates:%d falsetickers:%d",
             low, high, num_candidates, num_falsetickers);
 …
         /* x.opt_rd == root_distance(p); */
         survivor[num_survivors].metric = MAXDIST * p->lastpkt_stratum + point[i].opt_rd;
         VERB4 bb_error_msg("survivor[%d] metric:%f peer:%s",
+        VERB5 bb_error_msg("survivor[%d] metric:%f peer:%s",
             num_survivors, survivor[num_survivors].metric, p->p_dotted);
         num_survivors++;
 …
      */
     if (num_survivors < MIN_SELECTED) {
+        VERB3 bb_error_msg("num_survivors %d < %d, no peer selected",
+                num_survivors, MIN_SELECTED);
+        VERB3 bb_error_msg("survivors:%d%s",
+                num_survivors,
+                ", no peer selected");
         return NULL;
+    }
 …
         if (num_survivors <= MIN_CLUSTERED) {
             VERB3 bb_error_msg("num_survivors %d <= %d, not discarding more",
+            VERB4 bb_error_msg("num_survivors %d <= %d, not discarding more",
                     num_survivors, MIN_CLUSTERED);
             break;
 …
                 max_idx = i;
+            }
             VERB5 bb_error_msg("survivor %d selection_jitter^2:%f",
+            VERB6 bb_error_msg("survivor %d selection_jitter^2:%f",
                     i, selection_jitter_sq);
+        }
         max_selection_jitter = SQRT(max_selection_jitter / num_survivors);
         VERB4 bb_error_msg("max_selection_jitter (at %d):%f min_jitter:%f",
+        VERB5 bb_error_msg("max_selection_jitter (at %d):%f min_jitter:%f",
                 max_idx, max_selection_jitter, min_jitter);
 …
          */
         if (max_selection_jitter < min_jitter) {
             VERB3 bb_error_msg("max_selection_jitter:%f < min_jitter:%f, num_survivors:%d, not discarding more",
+            VERB4 bb_error_msg("max_selection_jitter:%f < min_jitter:%f, num_survivors:%d, not discarding more",
                     max_selection_jitter, min_jitter, num_survivors);
             break;
 …
          * and go around again.
          */
         VERB5 bb_error_msg("dropping survivor %d", max_idx);
+        VERB6 bb_error_msg("dropping survivor %d", max_idx);
         num_survivors--;
         while (max_idx < num_survivors) {
 …
         for (i = 1; i < num_survivors; i++) {
             if (G.last_update_peer == survivor[i].p) {
                 VERB4 bb_error_msg("keeping old synced peer");
+                VERB5 bb_error_msg("keeping old synced peer");
                 p = G.last_update_peer;
                 goto keep_old;
 …
     G.last_update_peer = p;
  keep_old:
     VERB3 bb_error_msg("selected peer %s filter_offset:%+f age:%f",
+    VERB4 bb_error_msg("selected peer %s filter_offset:%+f age:%f",
             p->p_dotted,
             p->filter_offset,
 …
      * the current time.
      */
     VERB3 bb_error_msg("disc_state=%d last update offset=%f recv_time=%f",
+    VERB4 bb_error_msg("disc_state=%d last update offset=%f recv_time=%f",
             disc_state, offset, recv_time);
     G.discipline_state = disc_state;
 …
     double freq_drift;
 #endif
+#if !USING_KERNEL_PLL_LOOP || USING_INITIAL_FREQ_ESTIMATION
     double since_last_update;
+#endif
     double etemp, dtemp;
 …
      */
     if (recv_time <= G.last_update_recv_time) {
         VERB3 bb_error_msg("same or older datapoint: %f >= %f, not using it",
                 G.last_update_recv_time, recv_time);
+        VERB3 bb_error_msg("update from %s: same or older datapoint, not using it",
+            p->p_dotted);
         return 0; /* "leave poll interval as is" */
+    }
 …
      * and frequency errors.
      */
+#if !USING_KERNEL_PLL_LOOP || USING_INITIAL_FREQ_ESTIMATION
     since_last_update = recv_time - G.reftime;
+#endif
 #if !USING_KERNEL_PLL_LOOP
     freq_drift = 0;
 …
         /* Ignore updates until the stepout threshold */
         if (since_last_update < WATCH_THRESHOLD) {
             VERB3 bb_error_msg("measuring drift, datapoint ignored, %f sec remains",
+            VERB4 bb_error_msg("measuring drift, datapoint ignored, %f sec remains",
                     WATCH_THRESHOLD - since_last_update);
             return 0; /* "leave poll interval as is" */
 …
      */
     if (abs_offset > STEP_THRESHOLD) {
+#if 0
+        double remains;
+// This "spike state" seems to be useless, peer selection already drops
+// occassional "bad" datapoints. If we are here, there were _many_
+// large offsets. When a few first large offsets are seen,
+// we end up in "no valid datapoints, no peer selected" state.
+// Only when enough of them are seen (which means it's not a fluke),
+// we end up here. Looks like _our_ clock is off.
         switch (G.discipline_state) {
         case STATE_SYNC:
             /* The first outlyer: ignore it, switch to SPIK state */
+            VERB3 bb_error_msg("offset:%+f - spike detected", offset);
+            VERB3 bb_error_msg("update from %s: offset:%+f, spike%s",
+                p->p_dotted, offset,
+                "");
             G.discipline_state = STATE_SPIK;
             return -1; /* "decrease poll interval" */
 …
              * is found or the stepout threshold is exceeded.
              */
+            if (since_last_update < WATCH_THRESHOLD) {
+                VERB3 bb_error_msg("spike detected, datapoint ignored, %f sec remains",
+                        WATCH_THRESHOLD - since_last_update);
+            remains = WATCH_THRESHOLD - since_last_update;
+            if (remains > 0) {
+                VERB3 bb_error_msg("update from %s: offset:%+f, spike%s",
+                    p->p_dotted, offset,
+                    ", datapoint ignored");
                 return -1; /* "decrease poll interval" */
+            }
             /* fall through: we need to step */
         } /* switch */
+#endif
         /* Step the time and clamp down the poll interval.
 …
          * intervals.
          */
         VERB3 bb_error_msg("stepping time by %+f; poll_exp=MINPOLL", offset);
+        VERB4 bb_error_msg("stepping time by %+f; poll_exp=MINPOLL", offset);
         step_time(offset);
         if (option_mask32 & OPT_q) {
 …
+        }
+        G.polladj_count = 0;
+        G.poll_exp = MINPOLL;
+        G.stratum = MAXSTRAT;
+        clamp_pollexp_and_set_MAXSTRAT();
         run_script("step", offset);
+        recv_time += offset;
 #if USING_INITIAL_FREQ_ESTIMATION
 …
         abs_offset = offset = 0;
         set_new_values(STATE_SYNC, offset, recv_time);
     } else { /* abs_offset <= STEP_THRESHOLD */
+        if (G.poll_exp < MINPOLL && G.initial_poll_complete) {
+            VERB3 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
 …
         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) {
 …
             set_new_values(STATE_SYNC, offset, recv_time);
 #endif
             VERB3 bb_error_msg("transitioning to FREQ, datapoint ignored");
+            VERB4 bb_error_msg("transitioning to FREQ, datapoint ignored");
             return 0; /* "leave poll interval as is" */
 …
+    }
-    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;
 …
     dtemp += MAXD(p->filter_dispersion + FREQ_TOLERANCE * (G.cur_time - p->lastpkt_recv_time) + abs_offset, MINDISP);
     G.rootdisp = p->lastpkt_rootdisp + dtemp;
     VERB3 bb_error_msg("updating leap/refid/reftime/rootdisp from peer %s", p->p_dotted);
+    VERB4 bb_error_msg("updating leap/refid/reftime/rootdisp from peer %s", p->p_dotted);
     /* We are in STATE_SYNC now, but did not do adjtimex yet.
 …
     G.discipline_wander = SQRT(etemp + (dtemp - etemp) / AVG);
     VERB3 bb_error_msg("discipline freq_drift=%.9f(int:%ld corr:%e) wander=%f",
+    VERB4 bb_error_msg("discipline freq_drift=%.9f(int:%ld corr:%e) wander=%f",
             G.discipline_freq_drift,
             (long)(G.discipline_freq_drift * 65536e6),
 …
             G.discipline_wander);
 #endif
     VERB3 {
+    VERB4 {
         memset(&tmx, 0, sizeof(tmx));
         if (adjtimex(&tmx) < 0)
 …
 #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 = G.poll_exp - 4;
+    tmx.constant = (int)G.poll_exp - 4;
     /* EXPERIMENTAL.
      * The below if statement should be unnecessary, but...
 …
      * 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);
 …
      * Not sure why. Perhaps it is normal.
      */
     VERB3 bb_error_msg("adjtimex:%d freq:%ld offset:%+ld status:0x%x",
+    VERB4 bb_error_msg("adjtimex:%d freq:%ld offset:%+ld status:0x%x",
                 rc, tmx.freq, tmx.offset, tmx.status);
     G.kernel_freq_drift = tmx.freq / 65536;
+    VERB2 bb_error_msg("update from:%s offset:%+f jitter:%f clock drift:%+.3fppm tc:%d",
+            p->p_dotted, offset, G.discipline_jitter, (double)tmx.freq / 65536, (int)tmx.constant);
+    VERB2 bb_error_msg("update from:%s offset:%+f delay:%f jitter:%f clock drift:%+.3fppm tc:%d",
+            p->p_dotted,
+            offset,
+            p->lastpkt_delay,
+            G.discipline_jitter,
+            (double)tmx.freq / 65536,
+            (int)tmx.constant
+    );
     return 1; /* "ok to increase poll interval" */
 …
  */
 static unsigned
+retry_interval(void)
+{
+    /* Local problem, want to retry soon */
+    unsigned interval, r;
+    interval = RETRY_INTERVAL;
+    r = random();
+    interval += r % (unsigned)(RETRY_INTERVAL / 4);
+    VERB3 bb_error_msg("chose retry interval:%u", interval);
+poll_interval(int upper_bound)
+{
+    unsigned interval, r, mask;
+    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)", interval, G.poll_exp);
     return interval;
+}
+static unsigned
+poll_interval(int exponent)
+{
+    unsigned interval, r;
+    exponent = G.poll_exp + exponent;
+    if (exponent < 0)
+        exponent = 0;
+    interval = 1 << exponent;
+    r = random();
+    interval += ((r & (interval-1)) >> 4) + ((r >> 8) & 1); /* + 1/16 of interval, max */
+    VERB3 bb_error_msg("chose poll interval:%u (poll_exp:%d exp:%d)", interval, G.poll_exp, exponent);
+    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
 …
     msg_t       msg;
     double      T1, T2, T3, T4;
+    double      offset;
+    double      prev_delay, delay;
     unsigned    interval;
     datapoint_t *datapoint;
     peer_t      *q;
+    offset = 0;
     /* We can recvfrom here and check from.IP, but some multihomed
      * 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);
+    }
 …
      || 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
+        interval = poll_interval(0);
+        bb_error_msg("reply from %s: peer is unsynced, next query in %us", p->p_dotted, interval);
+        goto set_next_and_ret;
+        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;
+    }
 …
 //  if (msg.m_rootdelay / 2 + msg.m_rootdisp >= MAXDISP || p->lastpkt_reftime > msg.m_xmt)
 //      return;                 /* invalid header values */
-    p->lastpkt_status = msg.m_status;
-    p->lastpkt_stratum = msg.m_stratum;
-    p->lastpkt_rootdelay = sfp_to_d(msg.m_rootdelay);
-    p->lastpkt_rootdisp = sfp_to_d(msg.m_rootdisp);
-    p->lastpkt_refid = msg.m_refid;
     /*
 …
     T4 = G.cur_time;
-    p->lastpkt_recv_time = T4;
-    VERB5 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
-    p->datapoint_idx = p->reachable_bits ? (p->datapoint_idx + 1) % NUM_DATAPOINTS : 0;
-    datapoint = &p->filter_datapoint[p->datapoint_idx];
-    datapoint->d_recv_time = T4;
-    datapoint->d_offset    = ((T2 - T1) + (T3 - T4)) / 2;
     /* The delay calculation is a special case. In cases where the
      * server and client clocks are running at different rates and
 …
      * the delay is clamped not less than the system precision.
      */
+    p->lastpkt_delay = (T4 - T1) - (T3 - T2);
+    if (p->lastpkt_delay < G_precision_sec)
+        p->lastpkt_delay = G_precision_sec;
+    delay = (T4 - T1) - (T3 - T2);
+    if (delay < G_precision_sec)
+        delay = G_precision_sec;
+    /*
+     * If this packet's delay is much bigger than the last one,
+     * it's better to just ignore it than use its much less precise value.
+     */
+    prev_delay = p->p_raw_delay;
+    p->p_raw_delay = delay;
+    if (p->reachable_bits && delay > prev_delay * BAD_DELAY_GROWTH) {
+        bb_error_msg("reply from %s: delay %f is too high, ignoring", p->p_dotted, delay);
+        goto pick_normal_interval;
+    }
+    p->lastpkt_delay = delay;
+    p->lastpkt_recv_time = T4;
+    VERB6 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
+    p->lastpkt_status = msg.m_status;
+    p->lastpkt_stratum = msg.m_stratum;
+    p->lastpkt_rootdelay = sfp_to_d(msg.m_rootdelay);
+    p->lastpkt_rootdisp = sfp_to_d(msg.m_rootdisp);
+    p->lastpkt_refid = msg.m_refid;
+    p->datapoint_idx = p->reachable_bits ? (p->datapoint_idx + 1) % NUM_DATAPOINTS : 0;
+    datapoint = &p->filter_datapoint[p->datapoint_idx];
+    datapoint->d_recv_time = T4;
+    datapoint->d_offset    = offset = ((T2 - T1) + (T3 - T4)) / 2;
     datapoint->d_dispersion = LOG2D(msg.m_precision_exp) + G_precision_sec;
     if (!p->reachable_bits) {
 …
         int i;
         for (i = 0; i < NUM_DATAPOINTS; i++) {
             p->filter_datapoint[i].d_offset = datapoint->d_offset;
+            p->filter_datapoint[i].d_offset = offset;
+        }
+    }
 …
         bb_error_msg("reply from %s: offset:%+f delay:%f status:0x%02x strat:%d refid:0x%08x rootdelay:%f reach:0x%02x",
             p->p_dotted,
             datapoint->d_offset,
+            offset,
             p->lastpkt_delay,
             p->lastpkt_status,
 …
     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) {
+                VERB3 bb_error_msg("offset:%+f > POLLDOWN_OFFSET", q->filter_offset);
+                goto poll_down;
+                VERB4 bb_error_msg("offset:%+f > POLLDOWN_OFFSET", q->filter_offset);
+                adjust_poll(-POLLADJ_LIMIT * 3);
+                rc = 0;
+            }
+        }
+    }
+    /* else: no peer selected, rc = -1: we want to poll more often */
+#endif
+        }
+    } else {
+        /* No peer selected.
+         * If poll interval is small, increase it.
+         */
+        if (G.poll_exp < BIGPOLL)
+            goto increase_interval;
+    }
     if (rc != 0) {
 …
             /* 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++;
+                    VERB3 bb_error_msg("polladj: discipline_jitter:%f ++poll_exp=%d",
+                            G.discipline_jitter, G.poll_exp);
+                }
+            } else {
+                VERB3 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);
+                    }
+                    VERB3 bb_error_msg("polladj: discipline_jitter:%f --poll_exp=%d",
+                            G.discipline_jitter, G.poll_exp);
+                }
+            } else {
+                VERB3 bb_error_msg("polladj: decr:%d", G.polladj_count);
+            }
+            VERB3 if (rc > 0)
+                bb_error_msg("want smaller interval: offset/jitter = %u",
+                    G.offset_to_jitter_ratio);
+            adjust_poll(-G.poll_exp * 2);
+        }
+    }
     /* Decide when to send new query for this peer */
+    interval = poll_interval(0);
+ set_next_and_ret:
+ pick_normal_interval:
+    interval = poll_interval(INT_MAX);
+    if (fabs(offset) >= BIGOFF && interval > BIGOFF_INTERVAL) {
+        /* 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,
+         * or _our_ clock is wrong now and _all_ peers will show similar
+         * largish offsets too.
+         * I observed this with laptop suspend stopping clock.
+         * In any case, it makes sense to make next request soonish:
+         * cases 1 and 2: get a better datapoint,
+         * case 3: allows to resync faster.
+         */
+        interval = BIGOFF_INTERVAL;
+    }
     set_next(p, interval);
+}
 …
         bb_error_msg("malformed packet received from %s: size %u", addr, (int)size);
         free(addr);
+        goto bail;
+    }
+    /* Respond only to client and symmetric active packets */
+    if ((msg.m_status & MODE_MASK) != MODE_CLIENT
+     && (msg.m_status & MODE_MASK) != MODE_SYM_ACT
+    ) {
         goto bail;
+    }
 …
     llist_t *peers;
     srandom(getpid());
+    srand(getpid());
     if (getuid())
 …
     /* Set some globals */
+    G.discipline_jitter = G_precision_sec;
     G.stratum = MAXSTRAT;
     if (BURSTPOLL != 0)
 …
     /* 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);
+    if (!(opts & (OPT_p|OPT_l)))
+        bb_show_usage();
+            &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;
 …
         while (peers)
             add_peers(llist_pop(&peers));
+    } else {
+    }
+#if ENABLE_FEATURE_NTPD_CONF
+    else {
+        parser_t *parser;
+        char *token[3];
+        parser = config_open("/etc/ntp.conf");
+        while (config_read(parser, token, 3, 1, "# \t", PARSE_NORMAL)) {
+            if (strcmp(token[0], "server") == 0 && token[1]) {
+                add_peers(token[1]);
+                continue;
+            }
+            bb_error_msg("skipping %s:%u: unimplemented command '%s'",
+                "/etc/ntp.conf", parser->lineno, token[0]
+            );
+        }
+        config_close(parser);
+    }
+#endif
+    if (G.peer_cnt == 0) {
+        if (!(opts & OPT_l))
+            bb_show_usage();
         /* -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
 …
     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
+        setsockopt_int(G_listen_fd, IPPROTO_IP, IP_TOS, 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)
 …
                     /* Time to send new req */
                     if (--cnt == 0) {
+                        G.initial_poll_complete = 1;
+                        VERB4 bb_error_msg("disabling burst mode");
+                        G.polladj_count = 0;
+                        G.poll_exp = MINPOLL;
+                    }
                     send_query_to_peer(p);
 …
                     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);
+                    /* What if don't see it because it changed its IP? */
+                    if (p->reachable_bits == 0)
+                        resolve_peer_hostname(p, /*loop_on_fail=*/ 0);
                     set_next(p, timeout);
+                }
 …
         gettime1900d(); /* sets G.cur_time */
         if (nfds <= 0) {
+            if (G.script_name && G.cur_time - G.last_script_run > 11*60) {
+            if (!bb_got_signal /* poll wasn't interrupted by a signal */
+             && G.cur_time - G.last_script_run > 11*60
+            ) {
                 /* Useful for updating battery-backed RTC and such */
                 run_script("periodic", G.last_update_offset);
                 gettime1900d(); /* sets G.cur_time */
+            }
             continue;
+            goto check_unsync;
+        }
 …
                 gettime1900d(); /* sets G.cur_time */
+            }
+        }
+ check_unsync:
+        if (G.ntp_peers && G.stratum != MAXSTRAT) {
+            for (item = G.ntp_peers; item != NULL; item = item->link) {
+                peer_t *p = (peer_t *) item->data;
+                if (p->reachable_bits)
+                    goto have_reachable_peer;
+            }
+            /* No peer responded for last 8 packets, panic */
+            clamp_pollexp_and_set_MAXSTRAT();
+            run_script("unsync", 0.0);
+ have_reachable_peer: ;
+        }
     } /* while (!bb_got_signal) */

branches/3.3/mindi-busybox/networking/ping.c

-              r3232
+              r3621
 #include <netinet/ip_icmp.h>
 #include "libbb.h"
+#include "common_bufsiz.h"
 #ifdef __BIONIC__
 …
 //usage:# define ping_full_usage "\n\n"
 //usage:       "Send ICMP ECHO_REQUEST packets to network hosts\n"
+//usage:    IF_PING6(
 //usage:     "\n    -4,-6       Force IP or IPv6 name resolution"
+//usage:    )
 //usage:     "\n    -c CNT      Send only CNT pings"
 //usage:     "\n    -s SIZE     Send SIZE data bytes in packets (default:56)"
 …
 //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:     "\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
 …
     MAXWAIT = 10,
     PINGINTERVAL = 1, /* 1 second */
+    pingsock = 0,
 };
+static void
+#if ENABLE_PING6
+create_icmp_socket(len_and_sockaddr *lsa)
+#else
+create_icmp_socket(void)
+#define create_icmp_socket(lsa) create_icmp_socket()
+#endif
+{
+    int sock;
+#if ENABLE_PING6
+    if (lsa->u.sa.sa_family == AF_INET6)
+        sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
+    else
+#endif
+        sock = socket(AF_INET, SOCK_RAW, 1); /* 1 == ICMP */
+    if (sock < 0) {
+        if (errno == EPERM)
+            bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+        bb_perror_msg_and_die(bb_msg_can_not_create_raw_socket);
+    }
+    xmove_fd(sock, pingsock);
+}
 #if !ENABLE_FEATURE_FANCY_PING
 …
     char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 #define INIT_G() do { } while (0)
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
 static void noresp(int ign UNUSED_PARAM)
 …
+{
     struct icmp *pkt;
+    int pingsock, c;
+    pingsock = create_icmp_socket();
+    int c;
     pkt = (struct icmp *) G.packet;
     memset(pkt, 0, sizeof(G.packet));
+    /*memset(pkt, 0, sizeof(G.packet)); already is */
     pkt->icmp_type = ICMP_ECHO;
     pkt->icmp_cksum = inet_cksum((uint16_t *) pkt, sizeof(G.packet));
 …
     /* listen for replies */
     while (1) {
+#if 0
         struct sockaddr_in from;
         socklen_t fromlen = sizeof(from);
 …
         c = recvfrom(pingsock, G.packet, sizeof(G.packet), 0,
                 (struct sockaddr *) &from, &fromlen);
+#else
+        c = recv(pingsock, G.packet, sizeof(G.packet), 0);
+#endif
         if (c < 0) {
             if (errno != EINTR)
 …
+{
     struct icmp6_hdr *pkt;
     int pingsock, c;
+    int c;
     int sockopt;
-    pingsock = create_icmp6_socket();
     pkt = (struct icmp6_hdr *) G.packet;
     memset(pkt, 0, sizeof(G.packet));
+    /*memset(pkt, 0, sizeof(G.packet)); already is */
     pkt->icmp6_type = ICMP6_ECHO_REQUEST;
     sockopt = offsetof(struct icmp6_hdr, icmp6_cksum);
     setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, &sockopt, sizeof(sockopt));
+    setsockopt_int(pingsock, SOL_RAW, IPV6_CHECKSUM, sockopt);
     xsendto(pingsock, G.packet, DEFDATALEN + sizeof(struct icmp6_hdr), &lsa->u.sa, lsa->len);
 …
     /* listen for replies */
     while (1) {
+#if 0
         struct sockaddr_in6 from;
         socklen_t fromlen = sizeof(from);
 …
         c = recvfrom(pingsock, G.packet, sizeof(G.packet), 0,
                 (struct sockaddr *) &from, &fromlen);
+#else
+        c = recv(pingsock, G.packet, sizeof(G.packet), 0);
+#endif
         if (c < 0) {
             if (errno != EINTR)
 …
             continue;
+        }
+        if (c >= ICMP_MINLEN) {         /* icmp6_hdr */
+            pkt = (struct icmp6_hdr *) G.packet;
+        if (c >= ICMP_MINLEN) { /* icmp6_hdr */
             if (pkt->icmp6_type == ICMP6_ECHO_REPLY)
                 break;
 …
     alarm(5); /* give the host 5000ms to respond */
+    create_icmp_socket(lsa);
 #if ENABLE_PING6
     if (lsa->u.sa.sa_family == AF_INET6)
 …
 /* Full(er) version */
 #define OPT_STRING ("qvc:s:t:w:W:I:4" IF_PING6("6"))
+#define OPT_STRING ("qvc:s:t:w:W:I:np:4" IF_PING6("6"))
 enum {
     OPT_QUIET = 1 << 0,
 …
     OPT_W = 1 << 6,
     OPT_I = 1 << 7,
+    OPT_IPV4 = 1 << 8,
+    OPT_IPV6 = (1 << 9) * ENABLE_PING6,
+    /*OPT_n = 1 << 8, - ignored */
+    OPT_p = 1 << 9,
+    OPT_IPV4 = 1 << 10,
+    OPT_IPV6 = (1 << 11) * ENABLE_PING6,
 };
 struct globals {
-    int pingsock;
     int if_index;
     char *str_I;
 …
     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 */
 …
 #endif
     } pingaddr;
     char rcvd_tbl[MAX_DUP_CHK / 8];
+    unsigned char rcvd_tbl[MAX_DUP_CHK / 8];
 } FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define pingsock     (G.pingsock    )
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define if_index     (G.if_index    )
 #define source_lsa   (G.source_lsa  )
 #define str_I        (G.str_I       )
 #define datalen      (G.datalen     )
-#define ntransmitted (G.ntransmitted)
-#define nreceived    (G.nreceived   )
-#define nrepeats     (G.nrepeats    )
 #define pingcount    (G.pingcount   )
 #define opt_ttl      (G.opt_ttl     )
 …
 #define pingaddr     (G.pingaddr    )
 #define rcvd_tbl     (G.rcvd_tbl    )
-void BUG_ping_globals_too_big(void);
 #define INIT_G() do { \
+    if (sizeof(G) > COMMON_BUFSIZE) \
+        BUG_ping_globals_too_big(); \
+    pingsock = -1; \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
     datalen = DEFDATALEN; \
     timeout = MAXWAIT; \
 …
+#define A(bit)      rcvd_tbl[(bit)>>3]  /* identify byte in array */
+#define B(bit)      (1 << ((bit) & 0x07))   /* identify bit in byte */
+#define SET(bit)    (A(bit) |= B(bit))
+#define CLR(bit)    (A(bit) &= (~B(bit)))
+#define TST(bit)    (A(bit) & B(bit))
+/**************************************************************************/
+#define BYTE(bit)   rcvd_tbl[(bit)>>3]
+#define MASK(bit)   (1 << ((bit) & 7))
+#define SET(bit)    (BYTE(bit) |= MASK(bit))
+#define CLR(bit)    (BYTE(bit) &= (~MASK(bit)))
+#define TST(bit)    (BYTE(bit) & MASK(bit))
 static void print_stats_and_exit(int junk) NORETURN;
 static void print_stats_and_exit(int junk UNUSED_PARAM)
+{
+    unsigned long ul;
+    unsigned long nrecv;
     signal(SIGINT, SIG_IGN);
+    printf("\n--- %s ping statistics ---\n", hostname);
+    printf("%lu packets transmitted, ", ntransmitted);
+    printf("%lu packets received, ", nreceived);
+    if (nrepeats)
+        printf("%lu duplicates, ", nrepeats);
+    if (ntransmitted)
+        ntransmitted = (ntransmitted - nreceived) * 100 / ntransmitted;
+    printf("%lu%% packet loss\n", ntransmitted);
+    nrecv = G.nreceived;
+    printf("\n--- %s ping statistics ---\n"
+        "%lu packets transmitted, "
+        "%lu packets received, ",
+        hostname, G.ntransmitted, nrecv
+    );
+    if (G.nrepeats)
+        printf("%lu duplicates, ", G.nrepeats);
+    ul = G.ntransmitted;
+    if (ul != 0)
+        ul = (ul - nrecv) * 100 / ul;
+    printf("%lu%% packet loss\n", ul);
     if (tmin != UINT_MAX) {
         unsigned tavg = tsum / (nreceived + nrepeats);
+        unsigned tavg = tsum / (nrecv + G.nrepeats);
         printf("round-trip min/avg/max = %u.%03u/%u.%03u/%u.%03u ms\n",
             tmin / 1000, tmin % 1000,
 …
+    }
     /* if condition is true, exit with 1 -- 'failure' */
     exit(nreceived == 0 || (deadline && nreceived < pingcount));
+    exit(nrecv == 0 || (deadline && nrecv < pingcount));
+}
 …
     int sz;
     CLR((uint16_t)ntransmitted % MAX_DUP_CHK);
     ntransmitted++;
+    CLR((uint16_t)G.ntransmitted % MAX_DUP_CHK);
+    G.ntransmitted++;
     size_pkt += datalen;
 …
         bb_error_msg_and_die(bb_msg_write_error);
     if (pingcount == 0 || deadline || ntransmitted < pingcount) {
+    if (pingcount == 0 || deadline || G.ntransmitted < pingcount) {
         /* Didn't send all pings yet - schedule next in 1s */
         signal(SIGALRM, sp);
 …
         unsigned expire = timeout;
         if (nreceived) {
+        if (G.nreceived) {
             /* approx. 2*tmax, in seconds (2 RTT) */
             expire = tmax / (512*1024);
 …
     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 */
     pkt->icmp_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
+    pkt->icmp_seq = htons(G.ntransmitted); /* don't ++ here, it can be a macro */
     pkt->icmp_id = myid;
 …
     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;*/
     pkt->icmp6_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
+    pkt->icmp6_seq = htons(G.ntransmitted); /* don't ++ here, it can be a macro */
     pkt->icmp6_id = myid;
     /*if (datalen >= 4)*/
         *(uint32_t*)(&pkt->icmp6_data8[4]) = monotonic_us();
+        *(bb__aliased_uint32_t*)(&pkt->icmp6_data8[4]) = monotonic_us();
     //TODO? pkt->icmp_cksum = inet_cksum(...);
 …
         uint16_t recv_seq, int ttl)
+{
+    unsigned char *b, m;
     const char *dupmsg = " (DUP!)";
     unsigned triptime = triptime; /* for gcc */
-    ++nreceived;
     if (tp) {
 …
+    }
+    if (TST(recv_seq % MAX_DUP_CHK)) {
+        ++nrepeats;
+        --nreceived;
+    b = &BYTE(recv_seq % MAX_DUP_CHK);
+    m = MASK(recv_seq % MAX_DUP_CHK);
+    /*if TST(recv_seq % MAX_DUP_CHK):*/
+    if (*b & m) {
+        ++G.nrepeats;
     } else {
+        SET(recv_seq % MAX_DUP_CHK);
+        /*SET(recv_seq % MAX_DUP_CHK):*/
+        *b |= m;
+        ++G.nreceived;
         dupmsg += 7;
+    }
 …
     int sockopt;
-    pingsock = create_icmp_socket();
     pingaddr.sin = lsa->u.sin;
     if (source_lsa) {
 …
         xbind(pingsock, &source_lsa->u.sa, source_lsa->len);
+    }
-    if (str_I)
-        setsockopt_bindtodevice(pingsock, str_I);
     /* enable broadcast pings */
 …
      * broadcast ping etc) */
     sockopt = (datalen * 2) + 7 * 1024; /* giving it a bit of extra room */
     setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt));
+    setsockopt_SOL_SOCKET_int(pingsock, SO_RCVBUF, sockopt);
     if (opt_ttl != 0) {
         setsockopt(pingsock, IPPROTO_IP, IP_TTL, &opt_ttl, sizeof(opt_ttl));
+        setsockopt_int(pingsock, IPPROTO_IP, IP_TTL, opt_ttl);
         /* above doesnt affect packets sent to bcast IP, so... */
         setsockopt(pingsock, IPPROTO_IP, IP_MULTICAST_TTL, &opt_ttl, sizeof(opt_ttl));
+        setsockopt_int(pingsock, IPPROTO_IP, IP_MULTICAST_TTL, opt_ttl);
+    }
 …
+        }
         unpack4(G.rcv_packet, c, &from);
         if (pingcount && nreceived >= pingcount)
+        if (pingcount && G.nreceived >= pingcount)
             break;
+    }
+}
 #if ENABLE_PING6
-extern int BUG_bad_offsetof_icmp6_cksum(void);
 static void ping6(len_and_sockaddr *lsa)
+{
 …
     char control_buf[CMSG_SPACE(36)];
-    pingsock = create_icmp6_socket();
     pingaddr.sin6 = lsa->u.sin6;
-    /* untested whether "-I addr" really works for IPv6: */
     if (source_lsa)
         xbind(pingsock, &source_lsa->u.sa, source_lsa->len);
-    if (str_I)
-        setsockopt_bindtodevice(pingsock, str_I);
 #ifdef ICMP6_FILTER
 …
         if (setsockopt(pingsock, IPPROTO_ICMPV6, ICMP6_FILTER, &filt,
                     sizeof(filt)) < 0)
             bb_error_msg_and_die("setsockopt(ICMP6_FILTER)");
+            bb_error_msg_and_die("setsockopt(%s)", "ICMP6_FILTER");
+    }
 #endif /*ICMP6_FILTER*/
 …
      * broadcast ping etc) */
     sockopt = (datalen * 2) + 7 * 1024; /* giving it a bit of extra room */
     setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt));
+    setsockopt_SOL_SOCKET_int(pingsock, SO_RCVBUF, sockopt);
     sockopt = offsetof(struct icmp6_hdr, icmp6_cksum);
+    if (offsetof(struct icmp6_hdr, icmp6_cksum) != 2)
+        BUG_bad_offsetof_icmp6_cksum();
+    setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, &sockopt, sizeof(sockopt));
+    BUILD_BUG_ON(offsetof(struct icmp6_hdr, icmp6_cksum) != 2);
+    setsockopt_int(pingsock, SOL_RAW, IPV6_CHECKSUM, sockopt);
     /* request ttl info to be returned in ancillary data */
     setsockopt(pingsock, SOL_IPV6, IPV6_HOPLIMIT, &const_int_1, sizeof(const_int_1));
+    setsockopt_1(pingsock, SOL_IPV6, IPV6_HOPLIMIT);
     if (if_index)
 …
+        }
         unpack6(G.rcv_packet, c, &from, hoplimit);
         if (pingcount && nreceived >= pingcount)
+        if (pingcount && G.nreceived >= pingcount)
             break;
+    }
 …
+    }
     printf(": %d data bytes\n", datalen);
+    create_icmp_socket(lsa);
+    /* untested whether "-I addr" really works for IPv6: */
+    if (str_I)
+        setsockopt_bindtodevice(pingsock, str_I);
     G.sizeof_rcv_packet = datalen + MAXIPLEN + MAXICMPLEN;
 …
+{
     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_p)
+        G.pattern = xstrtou_range(str_p, 16, 0, 255);
     myid = (uint16_t) getpid();
     hostname = argv[optind];

branches/3.3/mindi-busybox/networking/pscan.c

r3232	r3621
158	158	if (ENABLE_FEATURE_CLEAN_UP) free(lsap);
159	159
160		printf("%~~d closed, %d open, %d~~ timed out (or blocked) ports\n",
	160	printf("%u closed, %u open, %u timed out (or blocked) ports\n",
161	161	closed_ports,
162	162	open_ports,

branches/3.3/mindi-busybox/networking/route.c

-              r3232
+              r3621
 #define RTF_IRTT        0x0100  /* Initial round trip time      */
 #define RTF_REJECT      0x0200  /* Reject route                 */
+#define RTF_NONEXTHOP   0x00200000 /* route with no nexthop */
 #endif
 …
+;
 static const int flags_ipvx[] = { /* MUST match tbl_ipvx[] values above. */
+static const uint16_t flags_ipvx[] = { /* MUST match tbl_ipvx[] values above. */
 #ifdef RTF_REJECT
     RTF_REJECT,
 …
             rt->rt_flags |= RTF_IRTT;
             rt->rt_irtt = xatoul(args_m1);
             rt->rt_irtt *= (sysconf(_SC_CLK_TCK) / 100);    /* FIXME */
+            rt->rt_irtt *= (bb_clk_tck() / 100);    /* FIXME */
 #if 0                   /* FIXME: do we need to check anything of this? */
             if (rt->rt_irtt < 1 || rt->rt_irtt > (120 * HZ)) {
 …
 #endif
+static const unsigned flagvals[] = { /* Must agree with flagchars[]. */
+static const
+IF_NOT_FEATURE_IPV6(uint16_t)
+IF_FEATURE_IPV6(unsigned)
+flagvals[] = { /* Must agree with flagchars[]. */
+    RTF_UP,
     RTF_GATEWAY,
     RTF_HOST,
 …
     RTF_DEFAULT,
     RTF_ADDRCONF,
+    RTF_CACHE
+    RTF_CACHE,
+    RTF_REJECT,
+    RTF_NONEXTHOP, /* this one doesn't fit into 16 bits */
 #endif
 };
-#define IPV4_MASK (RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
-#define IPV6_MASK (RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE)
 /* Must agree with flagvals[]. */
 static const char flagchars[] ALIGN1 =
     "GHRDM"
+    "UGHRDM"
 #if ENABLE_FEATURE_IPV6
     "DAC"
+    "DAC!n"
 #endif
+;
+#define IPV4_MASK (RTF_UP|RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
+#define IPV6_MASK (RTF_UP|RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE|RTF_REJECT|RTF_NONEXTHOP)
 static void set_flags(char *flagstr, int flags)
+{
     int i;
-    *flagstr++ = 'U';
     for (i = 0; (*flagstr = flagchars[i]) != 0; i++) {
 …
     char devname[64], flags[16], *sdest, *sgw;
     unsigned long d, g, m;
+    int r;
     int flgs, ref, use, metric, mtu, win, ir;
     struct sockaddr_in s_addr;
 …
             netstatfmt ? "  MSS Window  irtt" : "Metric Ref    Use");
+    if (fscanf(fp, "%*[^\n]\n") < 0) { /* Skip the first line. */
+        goto ERROR;                /* Empty or missing line, or read error. */
+    /* Skip the first line. */
+    r = fscanf(fp, "%*[^\n]\n");
+    if (r < 0) {
+        /* Empty line, read error, or EOF. Yes, if routing table
+         * is completely empty, /proc/net/route has no header.
+         */
+        goto ERROR;
+    }
     while (1) {
-        int r;
         r = fscanf(fp, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
                 devname, &d, &g, &flgs, &ref, &use, &metric, &m,
                 &mtu, &win, &ir);
         if (r != 11) {
+ ERROR:
             if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
                 break;
+            }
+ ERROR:
+            bb_error_msg_and_die("fscanf");
+            bb_perror_msg_and_die(bb_msg_read_error);
+        }
 …
         r = fscanf(fp, "%32s%x%*s%x%32s%x%x%x%x%s\n",
                 addr6x+14, &prefix_len, &slen, addr6x+40+7,
                 &metric, &use, &refcnt, &iflags, iface);
+                &metric, &refcnt, &use, &iflags, iface);
         if (r != 9) {
             if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 …
+            }
  ERROR:
             bb_error_msg_and_die("fscanf");
+            bb_perror_msg_and_die(bb_msg_read_error);
+        }
 …
+        }
-        if (!(iflags & RTF_UP)) { /* Skip interfaces that are down. */
-            continue;
+        }
         set_flags(flags, (iflags & IPV6_MASK));

branches/3.3/mindi-busybox/networking/slattach.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "libiproute/utils.h" /* invarg() */
+#include "common_bufsiz.h"
+#include "libiproute/utils.h" /* invarg_1_to_2() */
 struct globals {
 …
     struct termios saved_state;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define handle       (G.handle      )
 #define saved_disc   (G.saved_disc  )
 #define saved_state  (G.saved_state )
 #define INIT_G() do { } while (0)
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
 …
     if (encap < 0)
         invarg(proto, "protocol");
+        invarg_1_to_2(proto, "protocol");
     if (encap > 3)
         encap = 8;
 …
         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");
+    }

branches/3.3/mindi-busybox/networking/tc.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include "libiproute/utils.h"
 …
     uint32_t filter_proto;
 } FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+struct BUG_G_too_big {
+        char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
+};
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define filter_ifindex (G.filter_ifindex)
 #define filter_qdisc (G.filter_qdisc)
 …
 #define filter_prio (G.filter_prio)
 #define filter_proto (G.filter_proto)
+#define INIT_G() do { } while (0)
+#define INIT_G() do { \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+} while (0)
 /* Allocates a buffer containing the name of a class id.
 …
     if (use_iec) {
         if (tmp >= 1000.0*1024.0*1024.0)
             snprintf(buf, len, "%.0fMibit", tmp/1024.0*1024.0);
         else if (tmp >= 1000.0*1024)
+        if (tmp >= 1000*1024*1024)
+            snprintf(buf, len, "%.0fMibit", tmp/(1024*1024));
+        else if (tmp >= 1000*1024)
             snprintf(buf, len, "%.0fKibit", tmp/1024);
         else
             snprintf(buf, len, "%.0fbit", tmp);
     } else {
         if (tmp >= 1000.0*1000000.0)
             snprintf(buf, len, "%.0fMbit", tmp/1000000.0);
         else if (tmp >= 1000.0 * 1000.0)
             snprintf(buf, len, "%.0fKbit", tmp/1000.0);
+        if (tmp >= 1000*1000000)
+            snprintf(buf, len, "%.0fMbit", tmp/1000000);
+        else if (tmp >= 1000*1000)
+            snprintf(buf, len, "%.0fKbit", tmp/1000);
         else
             snprintf(buf, len, "%.0fbit",  tmp);
 …
                         struct nlmsghdr *hdr, void *arg UNUSED_PARAM)
+{
-    struct tcmsg *msg = NLMSG_DATA(hdr);
-    int len = hdr->nlmsg_len;
-    struct rtattr * tb[TCA_MAX+1];
     return 0;
+}
 …
     obj = index_in_substrings(objects, *argv++);
     if (obj < OBJ_qdisc)
+    if (obj < 0)
         bb_show_usage();
     if (!*argv)
 …
         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++;
+    }
 …
             /* 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
 …
             /* nothing */
         } else {
             invarg(*argv, "command");
+            invarg_1_to_2(*argv, "command");
+        }
         NEXT_ARG();
 …
                 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)
 …
                 duparg(*argv, "protocol");
             if (ll_proto_a2n(&tmp, *argv))
                 invarg(*argv, "protocol");
+                invarg_1_to_2(*argv, "protocol");
             filter_proto = tmp;
+        }

branches/3.3/mindi-busybox/networking/tcpudp.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 /* Wants <limits.h> etc, thus included after libbb.h: */
 …
     char *env_var[1]; /* actually bigger */
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define verbose      (G.verbose     )
 #define max_per_host (G.max_per_host)
 …
 #define env_var      (G.env_var     )
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     cmax = 30; \
     env_cur = &env_var[0]; \

branches/3.3/mindi-busybox/networking/telnet.c

-              r3232
+              r3621
 #include <netinet/in.h>
 #include "libbb.h"
+#include "common_bufsiz.h"
 #ifdef __BIONIC__
 …
     struct termios termios_raw;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define INIT_G() do { \
+    struct G_sizecheck { \
+        char G_sizecheck[sizeof(G) > COMMON_BUFSIZE ? -1 : 1]; \
+    }; \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
 } while (0)
 …
 static void iac_flush(void)
+{
     write(netfd, G.iacbuf, G.iaclen);
+    full_write(netfd, G.iacbuf, G.iaclen);
     G.iaclen = 0;
+}
-#define write_str(fd, str) write(fd, str, sizeof(str) - 1)
 static void doexit(int ev) NORETURN;
 …
         rawmode();
     write_str(1, "\r\nConsole escape. Commands are:\r\n\n"
+    full_write1_str("\r\nConsole escape. Commands are:\r\n\n"
             " l go to line mode\r\n"
             " c go to character mode\r\n"
 …
+    }
     write_str(1, "continuing...\r\n");
+    full_write1_str("continuing...\r\n");
     if (bb_got_signal)
 …
     put_iac(c);
+    put_iac((x >> 8) & 0xff);
+    put_iac(x & 0xff);
+    put_iac((y >> 8) & 0xff);
+    put_iac(y & 0xff);
+    /* "... & 0xff" implicitly done below */
+    put_iac(x >> 8);
+    put_iac(x);
+    put_iac(y >> 8);
+    put_iac(y);
     put_iac(IAC);
 …
     xmove_fd(create_and_connect_stream_or_die(host, port), netfd);
     setsockopt(netfd, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+    setsockopt_keepalive(netfd);
     signal(SIGINT, record_signo);

branches/3.3/mindi-busybox/networking/telnetd.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include <syslog.h>
 …
     int maxfd;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     G.loginpath = "/bin/login"; \
     G.issuefile = "/etc/issue.net"; \
 …
     /* SO_KEEPALIVE by popular demand */
     setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+    setsockopt_keepalive(sock);
 #if ENABLE_FEATURE_TELNETD_STANDALONE
     ts->sockfd_read = sock;
 …
             if (ts->shell_pid == pid) {
                 ts->shell_pid = -1;
+// man utmp:
+// When init(8) finds that a process has exited, it locates its utmp entry
+// by ut_pid, sets ut_type to DEAD_PROCESS, and clears ut_user, ut_host
+// and ut_time with null bytes.
+// [same applies to other processes which maintain utmp entries, like telnetd]
+//
+// We do not bother actually clearing fields:
+// it might be interesting to know who was logged in and from where
+                update_utmp(pid, DEAD_PROCESS, /*tty_name:*/ NULL, /*username:*/ NULL, /*hostname:*/ NULL);
+                update_utmp_DEAD_PROCESS(pid);
                 break;
+            }
 …
  kill_session:
         if (ts->shell_pid > 0)
             update_utmp(ts->shell_pid, DEAD_PROCESS, /*tty_name:*/ NULL, /*username:*/ NULL, /*hostname:*/ NULL);
+            update_utmp_DEAD_PROCESS(ts->shell_pid);
         free_session(ts);
         ts = next;

branches/3.3/mindi-busybox/networking/telnetd.ctrlSQ.patch

-              r2725
+              r3621
 +#ifdef TIOCPKT
 +   int control;
 +   static const char lflow_on[] =
++   static const char lflow_on[] ALIGN1 =
 +       {IAC, SB, TELOPT_LFLOW, LFLOW_ON, IAC, SE};
 +   static const char lflow_off[] =
++   static const char lflow_off[] ALIGN1 =
 +       {IAC, SB, TELOPT_LFLOW, LFLOW_OFF, IAC, SE};
 +# define RESERVED sizeof(lflow_on)

branches/3.3/mindi-busybox/networking/tftp.c

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include <syslog.h>
 …
     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;
 …
 #endif
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+struct BUG_G_too_big {
     char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
+};
 #define INIT_G() do { } while (0)
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+} while (0)
 #define G_error_pkt_reason (G.error_pkt[3])
 …
             block_nr = 0;
+        }
     } else { /* tftp */
         /* Open file (must be after changing user) */
 …
     len_and_sockaddr *our_lsa;
     len_and_sockaddr *peer_lsa;
+    char *local_file, *mode, *user_opt;
+    char *mode, *user_opt;
+    char *local_file = local_file;
     const char *error_msg;
     int opt, result, opcode;
 …
+    }
+    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 */
 /* 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(&&)
 …
         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, "/.")) {

branches/3.3/mindi-busybox/networking/traceroute.c

-              r3232
+              r3621
 //usage:#define traceroute_trivial_usage
+//usage:       "[-"IF_TRACEROUTE6("46")"FIldnrv] [-f 1ST_TTL] [-m MAXTTL] [-p PORT] [-q PROBES]\n"
+//usage:       "    [-s SRC_IP] [-t TOS] [-w WAIT_SEC] [-g GATEWAY] [-i IFACE]\n"
+//usage:       "[-"IF_TRACEROUTE6("46")"FIlnrv] [-f 1ST_TTL] [-m MAXTTL] [-q PROBES] [-p PORT]\n"
+//usage:       "    [-t TOS] [-w WAIT_SEC]"
+//usage:       IF_FEATURE_TRACEROUTE_SOURCE_ROUTE(" [-g GATEWAY]")" [-s SRC_IP] [-i IFACE]\n"
 //usage:       "    [-z PAUSE_MSEC] HOST [BYTES]"
 //usage:#define traceroute_full_usage "\n\n"
 …
 //usage:     "\n    -4,-6   Force IP or IPv6 name resolution"
 //usage:    )
+//usage:     "\n    -F  Set the don't fragment bit"
+//usage:     "\n    -F  Set don't fragment bit"
+//usage:    IF_FEATURE_TRACEROUTE_USE_ICMP(
 //usage:     "\n    -I  Use ICMP ECHO instead of UDP datagrams"
+//usage:     "\n    -l  Display the TTL value of the returned packet"
+//usage:     "\n    -d  Set SO_DEBUG options to socket"
+//usage:    )
+//usage:     "\n    -l  Display TTL value of the returned packet"
+//Currently disabled (TRACEROUTE_SO_DEBUG==0)
+////usage:     "\n  -d  Set SO_DEBUG options to socket"
 //usage:     "\n    -n  Print numeric addresses"
 //usage:     "\n    -r  Bypass routing tables, send directly to HOST"
+//usage:    IF_FEATURE_TRACEROUTE_VERBOSE(
 //usage:     "\n    -v  Verbose"
+//usage:     "\n    -m  Max time-to-live (max number of hops)"
+//usage:     "\n    -p  Base UDP port number used in probes"
+//usage:    )
+//usage:     "\n    -f N    First number of hops (default 1)"
+//usage:     "\n    -m N    Max number of hops"
+//usage:     "\n    -q N    Number of probes per hop (default 3)"
+//usage:     "\n    -p N    Base UDP port number used in probes"
 //usage:     "\n        (default 33434)"
 //usage:     "\n    -q  Number of probes per TTL (default 3)"
 //usage:     "\n    -s  IP address to use as the source address"
 //usage:     "\n    -t  Type-of-service in probe packets (default 0)"
 //usage:     "\n    -w  Time in seconds to wait for a response (default 3)"
 //usage:     "\n    -g  Loose source route gateway (8 max)"
+//usage:     "\n    -s IP   Source address"
+//usage:     "\n    -i IFACE Source interface"
+//usage:     "\n    -t N    Type-of-service in probe packets (default 0)"
+//usage:     "\n    -w SEC  Time to wait for a response (default 3)"
+//usage:     "\n    -g IP   Loose source route gateway (8 max)"
 //usage:
 //usage:#define traceroute6_trivial_usage
 //usage:       "[-dnrv] [-m MAXTTL] [-p PORT] [-q PROBES]\n"
 //usage:       "    [-s SRC_IP] [-t TOS] [-w WAIT_SEC] [-i IFACE]\n"
+//usage:       "[-nrv] [-m MAXTTL] [-q PROBES] [-p PORT]\n"
+//usage:       "    [-t TOS] [-w WAIT_SEC] [-s SRC_IP] [-i IFACE]\n"
 //usage:       "    HOST [BYTES]"
 //usage:#define traceroute6_full_usage "\n\n"
 //usage:       "Trace the route to HOST\n"
+//usage:     "\n    -d  Set SO_DEBUG options to socket"
+//Currently disabled (TRACEROUTE_SO_DEBUG==0)
+////usage:     "\n  -d  Set SO_DEBUG options to socket"
 //usage:     "\n    -n  Print numeric addresses"
 //usage:     "\n    -r  Bypass routing tables, send directly to HOST"
+//usage:    IF_FEATURE_TRACEROUTE_VERBOSE(
 //usage:     "\n    -v  Verbose"
+//usage:     "\n    -m  Max time-to-live (max number of hops)"
+//usage:     "\n    -p  Base UDP port number used in probes"
+//usage:     "\n        (default is 33434)"
+//usage:     "\n    -q  Number of probes per TTL (default 3)"
+//usage:     "\n    -s  IP address to use as the source address"
+//usage:     "\n    -t  Type-of-service in probe packets (default 0)"
+//usage:     "\n    -w  Time in seconds to wait for a response (default 3)"
+//usage:    )
+//usage:     "\n    -m N    Max number of hops"
+//usage:     "\n    -q N    Number of probes per hop (default 3)"
+//usage:     "\n    -p N    Base UDP port number used in probes"
+//usage:     "\n        (default 33434)"
+//usage:     "\n    -s IP   Source address"
+//usage:     "\n    -i IFACE Source interface"
+//usage:     "\n    -t N    Type-of-service in probe packets (default 0)"
+//usage:     "\n    -w SEC  Time wait for a response (default 3)"
 #define TRACEROUTE_SO_DEBUG 0
-/* TODO: undefs were uncommented - ??! we have config system for that! */
-/* probably ok to remove altogether */
-//#undef CONFIG_FEATURE_TRACEROUTE_VERBOSE
-//#define CONFIG_FEATURE_TRACEROUTE_VERBOSE
-//#undef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
-//#define CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
-//#undef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
-//#define CONFIG_FEATURE_TRACEROUTE_USE_ICMP
 #include <net/if.h>
 …
-/* libbb candidate? tftp uses this idiom too */
-static len_and_sockaddr* dup_sockaddr(const len_and_sockaddr *lsa)
+{
-    len_and_sockaddr *new_lsa = xzalloc(LSA_LEN_SIZE + lsa->len);
-    memcpy(new_lsa, lsa, LSA_LEN_SIZE + lsa->len);
-    return new_lsa;
+}
 static int
 wait_for_reply(len_and_sockaddr *from_lsa, struct sockaddr *to, unsigned *timestamp_us, int *left_ms)
 …
 #if ENABLE_TRACEROUTE6
     if (dest_lsa->u.sa.sa_family == AF_INET6) {
         res = setsockopt(sndsock, SOL_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
         if (res < 0)
             bb_perror_msg_and_die("setsockopt UNICAST_HOPS %d", ttl);
+        res = setsockopt_int(sndsock, SOL_IPV6, IPV6_UNICAST_HOPS, ttl);
+        if (res != 0)
+            bb_perror_msg_and_die("setsockopt(%s) %d", "UNICAST_HOPS", ttl);
         out = outip;
         len = packlen;
 …
+    {
 #if defined IP_TTL
         res = setsockopt(sndsock, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
         if (res < 0)
             bb_perror_msg_and_die("setsockopt ttl %d", ttl);
+        res = setsockopt_int(sndsock, IPPROTO_IP, IP_TTL, ttl);
+        if (res != 0)
+            bb_perror_msg_and_die("setsockopt(%s) %d", "TTL", ttl);
 #endif
         out = outicmp;
 …
     res = xsendto(sndsock, out, len, &dest_lsa->u.sa, dest_lsa->len);
     if (res != len)
         bb_info_msg("sent %d octets, ret=%d", len, res);
+        bb_error_msg("sent %d octets, ret=%d", len, res);
+}
 …
+{
     int minpacket;
+#ifdef IP_TOS
     int tos = 0;
+#endif
     int max_ttl = 30;
     int nprobes = 3;
 …
     char *pausemsecs_str;
     char *first_ttl_str;
+    char *dest_str;
 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
     llist_t *source_route_list = NULL;
 …
         bb_error_msg("warning: ip checksums disabled");
 #endif
+#ifdef IP_TOS
     if (op & OPT_TOS)
         tos = xatou_range(tos_str, 0, 255);
+#endif
     if (op & OPT_MAX_TTL)
         max_ttl = xatou_range(max_ttl_str, 1, 255);
 …
         xmove_fd(xsocket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6), rcvsock);
 # ifdef IPV6_RECVPKTINFO
+        setsockopt(rcvsock, SOL_IPV6, IPV6_RECVPKTINFO,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt(rcvsock, SOL_IPV6, IPV6_2292PKTINFO,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt_1(rcvsock, SOL_IPV6, IPV6_RECVPKTINFO);
+        setsockopt_1(rcvsock, SOL_IPV6, IPV6_2292PKTINFO);
 # else
+        setsockopt(rcvsock, SOL_IPV6, IPV6_PKTINFO,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt_1(rcvsock, SOL_IPV6, IPV6_PKTINFO);
 # endif
     } else
 …
 #if TRACEROUTE_SO_DEBUG
     if (op & OPT_DEBUG)
+        setsockopt(rcvsock, SOL_SOCKET, SO_DEBUG,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt_SOL_SOCKET_1(rcvsock, SO_DEBUG);
 #endif
     if (op & OPT_BYPASS_ROUTE)
+        setsockopt(rcvsock, SOL_SOCKET, SO_DONTROUTE,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt_SOL_SOCKET_1(rcvsock, SO_DONTROUTE);
 #if ENABLE_TRACEROUTE6
     if (af == AF_INET6) {
+        static const int two = 2;
+        if (setsockopt(rcvsock, SOL_RAW, IPV6_CHECKSUM, &two, sizeof(two)) < 0)
+            bb_perror_msg_and_die("setsockopt RAW_CHECKSUM");
+        if (setsockopt_int(rcvsock, SOL_RAW, IPV6_CHECKSUM, 2) != 0)
+            bb_perror_msg_and_die("setsockopt(%s)", "IPV6_CHECKSUM");
         xmove_fd(xsocket(af, SOCK_DGRAM, 0), sndsock);
     } else
 …
 #ifdef SO_SNDBUF
     if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, &packlen, sizeof(packlen)) < 0) {
         bb_perror_msg_and_die("SO_SNDBUF");
+    if (setsockopt_SOL_SOCKET_int(sndsock, SO_SNDBUF, packlen) != 0) {
+        bb_perror_msg_and_die("setsockopt(%s)", "SO_SNDBUF");
+    }
 #endif
 #ifdef IP_TOS
     if ((op & OPT_TOS) && setsockopt(sndsock, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
         bb_perror_msg_and_die("setsockopt tos %d", tos);
+    if ((op & OPT_TOS) && setsockopt_int(sndsock, IPPROTO_IP, IP_TOS, tos) != 0) {
+        bb_perror_msg_and_die("setsockopt(%s) %d", "TOS", tos);
+    }
 #endif
 #ifdef IP_DONTFRAG
     if (op & OPT_DONT_FRAGMNT)
+        setsockopt(sndsock, IPPROTO_IP, IP_DONTFRAG,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt_1(sndsock, IPPROTO_IP, IP_DONTFRAG);
 #endif
 #if TRACEROUTE_SO_DEBUG
     if (op & OPT_DEBUG)
+        setsockopt(sndsock, SOL_SOCKET, SO_DEBUG,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt_SOL_SOCKET_1(sndsock, SO_DEBUG);
 #endif
     if (op & OPT_BYPASS_ROUTE)
+        setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
+                &const_int_1, sizeof(const_int_1));
+        setsockopt_SOL_SOCKET_1(sndsock, SO_DONTROUTE);
     outip = xzalloc(packlen);
 …
     xsetuid(getuid());
+    printf("traceroute to %s (%s)", argv[0],
+            xmalloc_sockaddr2dotted_noport(&dest_lsa->u.sa));
+    dest_str = xmalloc_sockaddr2dotted_noport(&dest_lsa->u.sa);
+    printf("traceroute to %s (%s)", argv[0], dest_str);
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        free(dest_str);
+    }
     if (op & OPT_SOURCE)
         printf(" from %s", source);
     printf(", %d hops max, %d byte packets\n", max_ttl, packlen);
     from_lsa = dup_sockaddr(dest_lsa);
+    from_lsa = xmemdup(dest_lsa, LSA_LEN_SIZE + dest_lsa->len);
     lastaddr = xzalloc(dest_lsa->len);
     to = xzalloc(dest_lsa->len);
 …
+    }
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        free(to);
+        free(lastaddr);
+        free(from_lsa);
+    }
     return 0;
+}

branches/3.3/mindi-busybox/networking/tunctl.c

r3232	r3621
83	83	if (opts & OPT_d) {
84	84	IOCTL(fd, TUNSETPERSIST, (void *)(uintptr_t)0);
85		~~bb_info_msg("Set '%s' %spersistent", ifr.ifr_name, "non"~~);
	85	printf("Set '%s' nonpersistent\n", ifr.ifr_name);
86	86	return EXIT_SUCCESS;
87	87	}

branches/3.3/mindi-busybox/networking/udhcp/Config.src

-              r3232
+              r3621
       and restart the discover process.
+config FEATURE_UDHCPC_SANITIZEOPT
+    bool "Do not pass malformed host and domain names"
+    default y
+    depends on UDHCPC
+    help
+      If selected, udhcpc will check some options (such as option 12 -
+      hostname) and if they don't look like valid hostnames
+      (for example, if they start with dash or contain spaces),
+      they will be replaced with string "bad" when exporting
+      to the environment.
 config FEATURE_UDHCP_PORT
     bool "Enable '-P port' option for udhcpd and udhcpc"

branches/3.3/mindi-busybox/networking/udhcp/arpping.c

-              r3232
+              r3621
         uint32_t from_ip,
         uint8_t *from_mac,
+        const char *interface)
+        const char *interface,
+        unsigned timeo)
+{
     int timeout_ms;
 …
     struct sockaddr addr;   /* for interface name */
     struct arpMsg arp;
+    if (!timeo)
+        return 1;
     s = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
 …
     /* wait for arp reply, and check it */
     timeout_ms = 2000;
+    timeout_ms = (int)timeo;
     do {
         typedef uint32_t aliased_uint32_t FIX_ALIASING;
 …
          * (people did see overflows here when system time jumps):
          */
     } while ((unsigned)timeout_ms <= 2000);
+    } while ((unsigned)timeout_ms <= timeo);
  ret:
     close(s);
     log1("%srp reply received for this address", rv ? "No a" : "A");
+    log1("%srp reply received for this address", rv ? "no a" : "A");
     return rv;
+}

branches/3.3/mindi-busybox/networking/udhcp/common.c

-              r3232
+              r3621
     { 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 */
 …
     "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 */
 …
  * xmalloc_optname_optval: to estimate string length
  * from binary option length: (option[LEN] / dhcp_option_lengths[opt_type])
  * is the number of elements, multiply in by one element's string width
+ * is the number of elements, multiply it by one element's string width
  * (len_of_option_as_string[opt_type]) and you know how wide string you need.
  */
 …
     /* Just like OPTION_STRING, we use minimum length here */
     [OPTION_STATIC_ROUTES] = 5,
+    [OPTION_6RD] =    22,  /* ignored by udhcp_str2optset */
+    [OPTION_6RD] =    12,  /* ignored by udhcp_str2optset */
+    /* The above value was chosen as follows:
+     * len_of_option_as_string[] for this option is >60: it's a string of the form
+     * "32 128 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 255.255.255.255 ".
+     * Each additional ipv4 address takes 4 bytes in binary option and appends
+     * another "255.255.255.255 " 16-byte string. We can set [OPTION_6RD] = 4
+     * but this severely overestimates string length: instead of 16 bytes,
+     * it adds >60 for every 4 bytes in binary option.
+     * We cheat and declare here that option is in units of 12 bytes.
+     * This adds more than 60 bytes for every three ipv4 addresses - more than enough.
+     * (Even 16 instead of 12 should work, but let's be paranoid).
+     */
 };
 …
         char buf[256 * 2 + 2];
         *bin2hex(buf, (void*) (opt + OPT_DATA), opt[OPT_LEN]) = '\0';
         bb_info_msg("%s: 0x%02x %s", pfx, opt[OPT_CODE], buf);
+        bb_error_msg("%s: 0x%02x %s", pfx, opt[OPT_CODE], buf);
+    }
+}
 …
         if (optionptr[OPT_CODE] == code) {
             log_option("Option found", optionptr);
+            log_option("option found", optionptr);
             return optionptr + OPT_DATA;
+        }
 …
     /* log3 because udhcpc uses it a lot - very noisy */
     log3("Option 0x%02x not found", code);
+    log3("option 0x%02x not found", code);
     return NULL;
+}
 …
         return;
+    }
     log_option("Adding option", addopt);
+    log_option("adding option", addopt);
     memcpy(optionptr + end, addopt, len);
     optionptr[end + len] = DHCP_END;
 …
         int length)
+{
+    struct option_set *existing, *new, **curr;
+    char *allocated = NULL;
+    struct option_set *existing;
+    char *allocated;
+    allocated = allocate_tempopt_if_needed(optflag, buffer, &length);
+#if ENABLE_FEATURE_UDHCP_RFC3397
+    if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_DNS_STRING) {
+        /* reuse buffer and length for RFC1035-formatted string */
+        allocated = buffer = (char *)dname_enc(NULL, 0, buffer, &length);
+    }
+#endif
     existing = udhcp_find_option(*opt_list, optflag->code);
     if (!existing) {
+        log2("Attaching option %02x to list", optflag->code);
+        allocated = allocate_tempopt_if_needed(optflag, buffer, &length);
+#if ENABLE_FEATURE_UDHCP_RFC3397
+        if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_DNS_STRING) {
+            /* reuse buffer and length for RFC1035-formatted string */
+            allocated = buffer = (char *)dname_enc(NULL, 0, buffer, &length);
+        }
+#endif
+        struct option_set *new, **curr;
         /* make a new option */
+        log2("attaching option %02x to list", optflag->code);
         new = xmalloc(sizeof(*new));
         new->data = xmalloc(length + OPT_DATA);
 …
         /* add it to an existing option */
+        log2("Attaching option %02x to existing member of list", optflag->code);
+        allocated = allocate_tempopt_if_needed(optflag, buffer, &length);
+        log2("attaching option %02x to existing member of list", optflag->code);
         old_len = existing->data[OPT_LEN];
-#if ENABLE_FEATURE_UDHCP_RFC3397
-        if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_DNS_STRING) {
-            /* reuse buffer and length for RFC1035-formatted string */
-            allocated = buffer = (char *)dname_enc(existing->data + OPT_DATA, old_len, buffer, &length);
+        }
-#endif
         if (old_len + length < 255) {
             /* actually 255 is ok too, but adding a space can overlow it */
 …
                 old_len++;
+            }
             memcpy(existing->data + OPT_DATA + old_len, buffer, length);
+            memcpy(existing->data + OPT_DATA + old_len, (allocated ? allocated : buffer), length);
             existing->data[OPT_LEN] = old_len + length;
         } /* else, ignore the data, we could put this in a second option in the future */

branches/3.3/mindi-busybox/networking/udhcp/common.h

-              r3232
+              r3621
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include <netinet/udp.h>
 #include <netinet/ip.h>
 …
 //#define DHCP_SIP_SERVERS      0x78 /* RFC 3361. flag byte, then: 0: domain names, 1: IP addrs */
 //#define DHCP_STATIC_ROUTES    0x79 /* RFC 3442. (mask,ip,router) tuples */
+#define DHCP_VLAN_ID            0x84 /* 802.1P VLAN ID */
+#define DHCP_VLAN_PRIORITY      0x85 /* 802.1Q VLAN priority */
+//#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 IF_UDHCP_VERBOSE(...) __VA_ARGS__
 extern unsigned dhcp_verbose;
 # define log1(...) do { if (dhcp_verbose >= 1) bb_info_msg(__VA_ARGS__); } while (0)
+# define log1(...) do { if (dhcp_verbose >= 1) bb_error_msg(__VA_ARGS__); } while (0)
 # if CONFIG_UDHCP_DEBUG >= 2
 void udhcp_dump_packet(struct dhcp_packet *packet) FAST_FUNC;
 #  define log2(...) do { if (dhcp_verbose >= 2) bb_info_msg(__VA_ARGS__); } while (0)
+#  define log2(...) do { if (dhcp_verbose >= 2) bb_error_msg(__VA_ARGS__); } while (0)
 # else
 #  define udhcp_dump_packet(...) ((void)0)
 …
 # endif
 # if CONFIG_UDHCP_DEBUG >= 3
 #  define log3(...) do { if (dhcp_verbose >= 3) bb_info_msg(__VA_ARGS__); } while (0)
+#  define log3(...) do { if (dhcp_verbose >= 3) bb_error_msg(__VA_ARGS__); } while (0)
 # else
 #  define log3(...) ((void)0)
 …
         uint32_t from_ip,
         uint8_t *from_mac,
+        const char *interface) FAST_FUNC;
+        const char *interface,
+        unsigned timeo) FAST_FUNC;
 /* note: ip is a pointer to an IPv6 in network order, possibly misaliged */

branches/3.3/mindi-busybox/networking/udhcp/dhcpc.c

-              r3306
+              r3621
 #include "dhcpc.h"
+#include <asm/types.h>
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined(_NEWLIB_VERSION)
+# include <netpacket/packet.h>
+# include <net/ethernet.h>
+#else
+# include <linux/if_packet.h>
+# include <linux/if_ether.h>
+#include <netinet/if_ether.h>
+#include <linux/filter.h>
+#include <linux/if_packet.h>
+#ifndef PACKET_AUXDATA
+# define PACKET_AUXDATA 8
+struct tpacket_auxdata {
+    uint32_t tp_status;
+    uint32_t tp_len;
+    uint32_t tp_snaplen;
+    uint16_t tp_mac;
+    uint16_t tp_net;
+    uint16_t tp_vlan_tci;
+    uint16_t tp_padding;
+};
 #endif
+#include <linux/filter.h>
 /* "struct client_config_t client_config" is in bb_common_bufsiz1 */
 …
     "background\0"     No_argument       "b"
     "broadcast\0"      No_argument       "B"
     IF_FEATURE_UDHCPC_ARPING("arping\0" No_argument       "a")
+    IF_FEATURE_UDHCPC_ARPING("arping\0" Optional_argument "a")
     IF_FEATURE_UDHCP_PORT("client-port\0"   Required_argument "P")
+    ;
 …
 /* get a rough idea of how long an option will be (rounding up...) */
 static const uint8_t len_of_option_as_string[] = {
+static const uint8_t len_of_option_as_string[] ALIGN1 = {
     [OPTION_IP              ] = sizeof("255.255.255.255 "),
     [OPTION_IP_PAIR         ] = sizeof("255.255.255.255 ") * 2,
     [OPTION_STATIC_ROUTES   ] = sizeof("255.255.255.255/32 255.255.255.255 "),
     [OPTION_6RD             ] = sizeof("32 128 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 255.255.255.255 "),
+    [OPTION_6RD             ] = sizeof("132 128 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 255.255.255.255 "),
     [OPTION_STRING          ] = 1,
     [OPTION_STRING_HOST     ] = 1,
 …
+}
+#if ENABLE_FEATURE_UDHCPC_SANITIZEOPT
 /* Check if a given label represents a valid DNS label
  * Return pointer to the first character after the label upon success,
 …
         ch = *label;
         if ((ch|0x20) < 'a' || (ch|0x20) > 'z') {
-            if (pos == 0) {
-                /* label must begin with letter */
-                return NULL;
+            }
             if (ch < '0' || ch > '9') {
                 if (ch == '\0' || ch == '.')
 …
             //return ((name - start) < 1025); /* NS_MAXDNAME */
         name++;
+    }
+}
+        if (*name == '\0')
+            return 1; // We allow trailing dot too
+    }
+}
+#else
+# define good_hostname(name) 1
+#endif
 /* Create "opt_name=opt_value" string */
 …
     optlen = dhcp_option_lengths[type];
     upper_length = len_of_option_as_string[type]
         * ((unsigned)(len + optlen - 1) / (unsigned)optlen);
+        * ((unsigned)(len + optlen) / (unsigned)optlen);
     dest = ret = xmalloc(upper_length + strlen(opt_name) + 2);
 …
     /* call script */
     log1("Executing %s %s", client_config.script, name);
+    log1("executing %s %s", client_config.script, name);
     argv[0] = (char*) client_config.script;
     argv[1] = (char*) name;
 …
  */
 static int raw_bcast_from_client_config_ifindex(struct dhcp_packet *packet)
+static int raw_bcast_from_client_config_ifindex(struct dhcp_packet *packet, uint32_t src_nip)
+{
     return udhcp_send_raw_packet(packet,
         /*src*/ INADDR_ANY, CLIENT_PORT,
+        /*src*/ src_nip, CLIENT_PORT,
         /*dst*/ INADDR_BROADCAST, SERVER_PORT, MAC_BCAST_ADDR,
         client_config.ifindex);
+}
+static int bcast_or_ucast(struct dhcp_packet *packet, uint32_t ciaddr, uint32_t server)
+{
+    if (server)
+        return udhcp_send_kernel_packet(packet,
+            ciaddr, CLIENT_PORT,
+            server, SERVER_PORT);
+    return raw_bcast_from_client_config_ifindex(packet, ciaddr);
+}
 …
     add_client_options(&packet);
     bb_info_msg("Sending discover...");
     return raw_bcast_from_client_config_ifindex(&packet);
+    bb_error_msg("sending %s", "discover");
+    return raw_bcast_from_client_config_ifindex(&packet, INADDR_ANY);
+}
 …
     addr.s_addr = requested;
     bb_info_msg("Sending select for %s...", inet_ntoa(addr));
     return raw_bcast_from_client_config_ifindex(&packet);
+    bb_error_msg("sending select for %s", inet_ntoa(addr));
+    return raw_bcast_from_client_config_ifindex(&packet, INADDR_ANY);
+}
 …
     add_client_options(&packet);
+    bb_info_msg("Sending renew...");
+    if (server)
+        return udhcp_send_kernel_packet(&packet,
+            ciaddr, CLIENT_PORT,
+            server, SERVER_PORT);
+    return raw_bcast_from_client_config_ifindex(&packet);
+    bb_error_msg("sending %s", "renew");
+    return bcast_or_ucast(&packet, ciaddr, server);
+}
 …
     udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
     bb_info_msg("Sending decline...");
     return raw_bcast_from_client_config_ifindex(&packet);
+    bb_error_msg("sending %s", "decline");
+    return raw_bcast_from_client_config_ifindex(&packet, INADDR_ANY);
+}
 #endif
 …
     udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
+    bb_info_msg("Sending release...");
+    return udhcp_send_kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
+    bb_error_msg("sending %s", "release");
+    /* Note: normally we unicast here since "server" is not zero.
+     * However, there _are_ people who run "address-less" DHCP servers,
+     * and reportedly ISC dhcp client and Windows allow that.
+     */
+    return bcast_or_ucast(&packet, ciaddr, server);
+}
 …
     struct ip_udp_dhcp_packet packet;
     uint16_t check;
-#ifdef PACKET_AUXDATA
     unsigned char cmsgbuf[CMSG_LEN(sizeof(struct tpacket_auxdata))];
-    struct cmsghdr *cmsg;
-#endif
     struct iovec iov;
     struct msghdr msg;
+#ifdef PACKET_AUXDATA
+    struct cmsghdr *cmsg;
     /* used to use just safe_read(fd, &packet, sizeof(packet))
      * but we need to check for TP_STATUS_CSUMNOTREADY :(
 …
             if (errno == EINTR)
                 continue;
             log1("Packet read error, ignoring");
+            log1("packet read error, ignoring");
             /* NB: possible down interface, etc. Caller should pause. */
             return bytes; /* returns -1 */
 …
         break;
+    }
-#else
-    memset(&packet, 0, sizeof(packet));
-    bytes = safe_read(fd, &packet, sizeof(packet));
-    if (bytes < 0) {
-        log1("Packet read error, ignoring");
-        /* NB: possible down interface, etc. Caller should pause. */
-        return bytes; /* returns -1 */
+    }
-#endif
     if (bytes < (int) (sizeof(packet.ip) + sizeof(packet.udp))) {
         log1("Packet is too short, ignoring");
+        log1("packet is too short, ignoring");
         return -2;
+    }
 …
     if (bytes < ntohs(packet.ip.tot_len)) {
         /* packet is bigger than sizeof(packet), we did partial read */
         log1("Oversized packet, ignoring");
+        log1("oversized packet, ignoring");
         return -2;
+    }
 …
      || ntohs(packet.udp.len) != (uint16_t)(bytes - sizeof(packet.ip))
     ) {
         log1("Unrelated/bogus packet, ignoring");
+        log1("unrelated/bogus packet, ignoring");
         return -2;
+    }
 …
     packet.ip.check = 0;
     if (check != inet_cksum((uint16_t *)&packet.ip, sizeof(packet.ip))) {
         log1("Bad IP header checksum, ignoring");
+        log1("bad IP header checksum, ignoring");
         return -2;
+    }
-#ifdef PACKET_AUXDATA
     for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
         if (cmsg->cmsg_level == SOL_PACKET
 …
+        }
+    }
-#endif
     /* verify UDP checksum. IP header has to be modified for this */
 …
     packet.udp.check = 0;
     if (check && check != inet_cksum((uint16_t *)&packet, bytes)) {
         log1("Packet with bad UDP checksum received, ignoring");
+        log1("packet with bad UDP checksum received, ignoring");
         return -2;
+    }
-#ifdef PACKET_AUXDATA
  skip_udp_sum_check:
-#endif
     if (packet.data.cookie != htonl(DHCP_MAGIC)) {
         bb_info_msg("Packet with bad magic, ignoring");
+        bb_error_msg("packet with bad magic, ignoring");
         return -2;
+    }
     log1("Received a packet");
+    log1("received %s", "a packet");
     udhcp_dump_packet(&packet.data);
 …
     struct sockaddr_ll sock;
+    /*
+     * Comment:
+     *
+     *  I've selected not to see LL header, so BPF doesn't see it, too.
+     *  The filter may also pass non-IP and non-ARP packets, but we do
+     *  a more complete check when receiving the message in userspace.
+     *
+     * and filter shamelessly stolen from:
+     *
+     *  http://www.flamewarmaster.de/software/dhcpclient/
+     *
+     * There are a few other interesting ideas on that page (look under
+     * "Motivation").  Use of netlink events is most interesting.  Think
+     * of various network servers listening for events and reconfiguring.
+     * That would obsolete sending HUP signals and/or make use of restarts.
+     *
+     * Copyright: 2006, 2007 Stefan Rompf <sux@loplof.de>.
+     * License: GPL v2.
+     *
+     * TODO: make conditional?
+    log1("opening raw socket on ifindex %d", ifindex); //log2?
+    fd = xsocket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+    /* ^^^^^
+     * SOCK_DGRAM: remove link-layer headers on input (SOCK_RAW keeps them)
+     * ETH_P_IP: want to receive only packets with IPv4 eth type
      */
+    static const struct sock_filter filter_instr[] = {
+        /* load 9th byte (protocol) */
+        BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 9),
+        /* jump to L1 if it is IPPROTO_UDP, else to L4 */
+        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 0, 6),
+        /* L1: load halfword from offset 6 (flags and frag offset) */
+        BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 6),
+        /* jump to L4 if any bits in frag offset field are set, else to L2 */
+        BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x1fff, 4, 0),
+        /* L2: skip IP header (load index reg with header len) */
+        BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0),
+        /* load udp destination port from halfword[header_len + 2] */
+        BPF_STMT(BPF_LD|BPF_H|BPF_IND, 2),
+        /* jump to L3 if udp dport is CLIENT_PORT, else to L4 */
+        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 68, 0, 1),
+        /* L3: accept packet */
+        BPF_STMT(BPF_RET|BPF_K, 0xffffffff),
+        /* L4: discard packet */
+        BPF_STMT(BPF_RET|BPF_K, 0),
+    };
+    static const struct sock_fprog filter_prog = {
+        .len = sizeof(filter_instr) / sizeof(filter_instr[0]),
+        /* casting const away: */
+        .filter = (struct sock_filter *) filter_instr,
+    };
+    log1("Opening raw socket on ifindex %d", ifindex); //log2?
+    fd = xsocket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+    log1("Got raw socket fd"); //log2?
+    log1("got raw socket fd"); //log2?
     sock.sll_family = AF_PACKET;
 …
     xbind(fd, (struct sockaddr *) &sock, sizeof(sock));
+#if 0 /* Several users reported breakage when BPF filter is used */
     if (CLIENT_PORT == 68) {
         /* Use only if standard port is in use */
+        /*
+         *  I've selected not to see LL header, so BPF doesn't see it, too.
+         *  The filter may also pass non-IP and non-ARP packets, but we do
+         *  a more complete check when receiving the message in userspace.
+         *
+         * and filter shamelessly stolen from:
+         *
+         *  http://www.flamewarmaster.de/software/dhcpclient/
+         *
+         * There are a few other interesting ideas on that page (look under
+         * "Motivation").  Use of netlink events is most interesting.  Think
+         * of various network servers listening for events and reconfiguring.
+         * That would obsolete sending HUP signals and/or make use of restarts.
+         *
+         * Copyright: 2006, 2007 Stefan Rompf <sux@loplof.de>.
+         * License: GPL v2.
+         */
+        static const struct sock_filter filter_instr[] = {
+            /* load 9th byte (protocol) */
+            BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 9),
+            /* jump to L1 if it is IPPROTO_UDP, else to L4 */
+            BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 0, 6),
+            /* L1: load halfword from offset 6 (flags and frag offset) */
+            BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 6),
+            /* jump to L4 if any bits in frag offset field are set, else to L2 */
+            BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x1fff, 4, 0),
+            /* L2: skip IP header (load index reg with header len) */
+            BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0),
+            /* load udp destination port from halfword[header_len + 2] */
+            BPF_STMT(BPF_LD|BPF_H|BPF_IND, 2),
+            /* jump to L3 if udp dport is CLIENT_PORT, else to L4 */
+            BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 68, 0, 1),
+            /* L3: accept packet ("accept 0x7fffffff bytes") */
+            /* Accepting 0xffffffff works too but kernel 2.6.19 is buggy */
+            BPF_STMT(BPF_RET|BPF_K, 0x7fffffff),
+            /* L4: discard packet ("accept zero bytes") */
+            BPF_STMT(BPF_RET|BPF_K, 0),
+        };
+        static const struct sock_fprog filter_prog = {
+            .len = sizeof(filter_instr) / sizeof(filter_instr[0]),
+            /* casting const away: */
+            .filter = (struct sock_filter *) filter_instr,
+        };
         /* Ignoring error (kernel may lack support for this) */
         if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog,
                 sizeof(filter_prog)) >= 0)
+            log1("Attached filter to raw socket fd"); // log?
+    }
+#ifdef PACKET_AUXDATA
+    if (setsockopt(fd, SOL_PACKET, PACKET_AUXDATA,
+            &const_int_1, sizeof(int)) < 0
+    ) {
+            log1("attached filter to raw socket fd"); // log?
+    }
+#endif
+    if (setsockopt_1(fd, SOL_PACKET, PACKET_AUXDATA) != 0) {
         if (errno != ENOPROTOOPT)
+            log1("Can't set PACKET_AUXDATA on raw socket");
+    }
+#else
+    sock.sll_family = AF_PACKET;
+    sock.sll_protocol = htons(ETH_P_IP);
+    sock.sll_ifindex = ifindex;
+    xbind(fd, (struct sockaddr *) &sock, sizeof(sock));
+#endif
+    log1("Created raw socket");
+            log1("can't set PACKET_AUXDATA on raw socket");
+    }
+    log1("created raw socket");
     return fd;
 …
 static void change_listen_mode(int new_mode)
+{
     log1("Entering listen mode: %s",
+    log1("entering listen mode: %s",
         new_mode != LISTEN_NONE
             ? (new_mode == LISTEN_KERNEL ? "kernel" : "raw")
 …
 static void perform_renew(void)
+{
     bb_info_msg("Performing a DHCP renew");
+    bb_error_msg("performing DHCP renew");
     switch (state) {
     case BOUND:
 …
         strcpy(buffer, inet_ntoa(temp_addr));
         temp_addr.s_addr = requested_ip;
         bb_info_msg("Unicasting a release of %s to %s",
+        bb_error_msg("unicasting a release of %s to %s",
                 inet_ntoa(temp_addr), buffer);
         send_release(server_addr, requested_ip); /* unicast */
         udhcp_run_script(NULL, "deconfig");
+    }
     bb_info_msg("Entering released state");
+    bb_error_msg("entering released state");
     change_listen_mode(LISTEN_NONE);
 …
 //usage:#endif
 //usage:#define udhcpc_trivial_usage
+//usage:       "[-fbnq"IF_UDHCP_VERBOSE("v")"oCRB] [-i IFACE] [-r IP] [-s PROG] [-p PIDFILE]\n"
+//usage:       "    [-V VENDOR] [-x OPT:VAL]... [-O OPT]..." IF_FEATURE_UDHCP_PORT(" [-P N]")
+//usage:       "[-fbq"IF_UDHCP_VERBOSE("v")"RB]"IF_FEATURE_UDHCPC_ARPING(" [-a[MSEC]]")" [-t N] [-T SEC] [-A SEC/-n]\n"
+//usage:       "    [-i IFACE]"IF_FEATURE_UDHCP_PORT(" [-P PORT]")" [-s PROG] [-p PIDFILE]\n"
+//usage:       "    [-oC] [-r IP] [-V VENDOR] [-F NAME] [-x OPT:VAL]... [-O OPT]..."
 //usage:#define udhcpc_full_usage "\n"
 //usage:    IF_LONG_OPTS(
 //usage:     "\n    -i,--interface IFACE    Interface to use (default eth0)"
+//usage:    IF_FEATURE_UDHCP_PORT(
+//usage:     "\n    -P,--client-port PORT   Use PORT (default 68)"
+//usage:    )
+//usage:     "\n    -s,--script PROG    Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
 //usage:     "\n    -p,--pidfile FILE   Create pidfile"
-//usage:     "\n    -s,--script PROG    Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
 //usage:     "\n    -B,--broadcast      Request broadcast replies"
+//usage:     "\n    -t,--retries N      Send up to N discover packets"
+//usage:     "\n    -T,--timeout N      Pause between packets (default 3 seconds)"
+//usage:     "\n    -A,--tryagain N     Wait N seconds after failure (default 20)"
+//usage:     "\n    -t,--retries N      Send up to N discover packets (default 3)"
+//usage:     "\n    -T,--timeout SEC    Pause between packets (default 3)"
+//usage:     "\n    -A,--tryagain SEC   Wait if lease is not obtained (default 20)"
+//usage:     "\n    -n,--now        Exit if lease is not obtained"
+//usage:     "\n    -q,--quit       Exit after obtaining lease"
+//usage:     "\n    -R,--release        Release IP on exit"
 //usage:     "\n    -f,--foreground     Run in foreground"
 //usage:    USE_FOR_MMU(
 //usage:     "\n    -b,--background     Background if lease is not obtained"
 //usage:    )
-//usage:     "\n    -n,--now        Exit if lease is not obtained"
-//usage:     "\n    -q,--quit       Exit after obtaining lease"
-//usage:     "\n    -R,--release        Release IP on exit"
 //usage:     "\n    -S,--syslog     Log to syslog too"
 //usage:    IF_FEATURE_UDHCP_PORT(
 //usage:     "\n    -P,--client-port N  Use port N (default 68)"
+//usage:    IF_FEATURE_UDHCPC_ARPING(
+//usage:     "\n    -a[MSEC],--arping[=MSEC] Validate offered address with ARP ping"
 //usage:    )
+//usage:    IF_FEATURE_UDHCPC_ARPING(
+//usage:     "\n    -a,--arping     Use arping to validate offered address"
+//usage:    )
+//usage:     "\n    -r,--request IP     Request this IP address"
+//usage:     "\n    -o,--no-default-options Don't request any options (unless -O is given)"
 //usage:     "\n    -O,--request-option OPT Request option OPT from server (cumulative)"
-//usage:     "\n    -o,--no-default-options Don't request any options (unless -O is given)"
-//usage:     "\n    -r,--request IP     Request this IP address"
 //usage:     "\n    -x OPT:VAL      Include option OPT in sent packets (cumulative)"
 //usage:     "\n                Examples of string, numeric, and hex byte opts:"
 …
 //usage:    IF_NOT_LONG_OPTS(
 //usage:     "\n    -i IFACE    Interface to use (default eth0)"
+//usage:    IF_FEATURE_UDHCP_PORT(
+//usage:     "\n    -P PORT     Use PORT (default 68)"
+//usage:    )
+//usage:     "\n    -s PROG     Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
 //usage:     "\n    -p FILE     Create pidfile"
-//usage:     "\n    -s PROG     Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
 //usage:     "\n    -B      Request broadcast replies"
+//usage:     "\n    -t N        Send up to N discover packets"
+//usage:     "\n    -T N        Pause between packets (default 3 seconds)"
+//usage:     "\n    -A N        Wait N seconds (default 20) after failure"
+//usage:     "\n    -t N        Send up to N discover packets (default 3)"
+//usage:     "\n    -T SEC      Pause between packets (default 3)"
+//usage:     "\n    -A SEC      Wait if lease is not obtained (default 20)"
+//usage:     "\n    -n      Exit if lease is not obtained"
+//usage:     "\n    -q      Exit after obtaining lease"
+//usage:     "\n    -R      Release IP on exit"
 //usage:     "\n    -f      Run in foreground"
 //usage:    USE_FOR_MMU(
 //usage:     "\n    -b      Background if lease is not obtained"
 //usage:    )
-//usage:     "\n    -n      Exit if lease is not obtained"
-//usage:     "\n    -q      Exit after obtaining lease"
-//usage:     "\n    -R      Release IP on exit"
 //usage:     "\n    -S      Log to syslog too"
 //usage:    IF_FEATURE_UDHCP_PORT(
 //usage:     "\n    -P N        Use port N (default 68)"
+//usage:    IF_FEATURE_UDHCPC_ARPING(
+//usage:     "\n    -a[MSEC]    Validate offered address with ARP ping"
 //usage:    )
+//usage:    IF_FEATURE_UDHCPC_ARPING(
+//usage:     "\n    -a      Use arping to validate offered address"
+//usage:    )
+//usage:     "\n    -r IP       Request this IP address"
+//usage:     "\n    -o      Don't request any options (unless -O is given)"
 //usage:     "\n    -O OPT      Request option OPT from server (cumulative)"
-//usage:     "\n    -o      Don't request any options (unless -O is given)"
-//usage:     "\n    -r IP       Request this IP address"
 //usage:     "\n    -x OPT:VAL  Include option OPT in sent packets (cumulative)"
 //usage:     "\n            Examples of string, numeric, and hex byte opts:"
 …
 int udhcpc_main(int argc UNUSED_PARAM, char **argv)
+{
     uint8_t *temp, *message;
+    uint8_t *message;
     const char *str_V, *str_h, *str_F, *str_r;
+    IF_FEATURE_UDHCPC_ARPING(const char *str_a = "2000";)
     IF_FEATURE_UDHCP_PORT(char *str_P;)
     void *clientid_mac_ptr;
 …
     unsigned already_waited_sec;
     unsigned opt;
+    IF_FEATURE_UDHCPC_ARPING(unsigned arpping_ms;)
     int max_fd;
     int retval;
     fd_set rfds;
+    setup_common_bufsiz();
     /* Default options */
 …
     opt = getopt32(argv, "CV:H:h:F:i:np:qRr:s:T:t:SA:O:ox:fB"
         USE_FOR_MMU("b")
         IF_FEATURE_UDHCPC_ARPING("a")
+        IF_FEATURE_UDHCPC_ARPING("a::")
         IF_FEATURE_UDHCP_PORT("P:")
         "v"
 …
         , &list_O
         , &list_x
+        IF_FEATURE_UDHCPC_ARPING(, &str_a)
         IF_FEATURE_UDHCP_PORT(, &str_P)
         IF_UDHCP_VERBOSE(, &dhcp_verbose)
 …
+    }
 #endif
+    IF_FEATURE_UDHCPC_ARPING(arpping_ms = xatou(str_a);)
     while (list_O) {
         char *optstr = llist_pop(&list_O);
 …
     write_pidfile(client_config.pidfile);
     /* Goes to stdout (unless NOMMU) and possibly syslog */
     bb_info_msg("%s (v"BB_VER") started", applet_name);
+    bb_error_msg("started, v"BB_VER);
     /* Set up the signal pipe */
     udhcp_sp_setup();
 …
         /* If we already timed out, fall through with retval = 0, else... */
         if ((int)tv.tv_sec > 0) {
             log1("Waiting on select %u seconds", (int)tv.tv_sec);
+            log1("waiting on select %u seconds", (int)tv.tv_sec);
             timestamp_before_wait = (unsigned)monotonic_sec();
             retval = select(max_fd + 1, &rfds, NULL, NULL, &tv);
 …
 #if BB_MMU /* -b is not supported on NOMMU */
                 if (opt & OPT_b) { /* background if no lease */
                     bb_info_msg("No lease, forking to background");
+                    bb_error_msg("no lease, forking to background");
                     client_background();
                     /* do not background again! */
 …
 #endif
                 if (opt & OPT_n) { /* abort if no lease */
                     bb_info_msg("No lease, failing");
+                    bb_error_msg("no lease, failing");
                     retval = 1;
                     goto ret;
 …
                 continue;
             case REQUESTING:
                 if (!discover_retries || packet_num < discover_retries) {
+                if (packet_num < 3) {
                     /* send broadcast select packet */
                     send_select(xid, server_addr, requested_ip);
 …
                 client_config.first_secs = 0; /* make secs field count from 0 */
                 change_listen_mode(LISTEN_KERNEL);
                 log1("Entering renew state");
+                log1("entering renew state");
                 /* fall right through */
             case RENEW_REQUESTED: /* manual (SIGUSR1) renew */
 …
+                }
                 /* Timed out, enter rebinding state */
                 log1("Entering rebinding state");
+                log1("entering rebinding state");
                 state = REBINDING;
                 /* fall right through */
 …
+                }
                 /* Timed out, enter init state */
                 bb_info_msg("Lease lost, entering init state");
+                bb_error_msg("lease lost, entering init state");
                 udhcp_run_script(NULL, "deconfig");
                 state = INIT_SELECTING;
 …
             continue;
         case SIGTERM:
             bb_info_msg("Received SIGTERM");
+            bb_error_msg("received %s", "SIGTERM");
             goto ret0;
+        }
 …
             if (len == -1) {
                 /* Error is severe, reopen socket */
                 bb_info_msg("Read error: %s, reopening socket", strerror(errno));
+                bb_error_msg("read error: %s, reopening socket", strerror(errno));
                 sleep(discover_timeout); /* 3 seconds by default */
                 change_listen_mode(listen_mode); /* just close and reopen */
 …
             /* Must be a DHCPOFFER */
             if (*message == DHCPOFFER) {
+                uint8_t *temp;
 /* What exactly is server's IP? There are several values.
  * Example DHCP offer captured with tchdump:
 …
  * "Next server" and router are definitely wrong ones to use, though...
  */
+/* We used to ignore pcakets without DHCP_SERVER_ID.
+ * I've got user reports from people who run "address-less" servers.
+ * They either supply DHCP_SERVER_ID of 0.0.0.0 or don't supply it at all.
+ * They say ISC DHCP client supports this case.
+ */
+                server_addr = 0;
                 temp = udhcp_get_option(&packet, DHCP_SERVER_ID);
                 if (!temp) {
+                    bb_error_msg("no server ID, ignoring packet");
+                    continue;
+                    /* still selecting - this server looks bad */
+                    bb_error_msg("no server ID, using 0.0.0.0");
+                } else {
+                    /* it IS unaligned sometimes, don't "optimize" */
+                    move_from_unaligned32(server_addr, temp);
+                }
-                /* it IS unaligned sometimes, don't "optimize" */
-                move_from_unaligned32(server_addr, temp);
                 /*xid = packet.xid; - already is */
                 requested_ip = packet.yiaddr;
 …
         case REBINDING:
             if (*message == DHCPACK) {
+                unsigned start;
                 uint32_t lease_seconds;
                 struct in_addr temp_addr;
+                uint8_t *temp;
                 temp = udhcp_get_option(&packet, DHCP_LEASE_TIME);
 …
                             (uint32_t) 0,
                             client_config.client_mac,
+                            client_config.interface)
+                            client_config.interface,
+                            arpping_ms)
                     ) {
                         bb_info_msg("Offered address is in use "
+                        bb_error_msg("offered address is in use "
                             "(got ARP reply), declining");
                         send_decline(/*xid,*/ server_addr, packet.yiaddr);
 …
 #endif
                 /* enter bound state */
-                timeout = lease_seconds / 2;
                 temp_addr.s_addr = packet.yiaddr;
                 bb_info_msg("Lease of %s obtained, lease time %u",
+                bb_error_msg("lease of %s obtained, lease time %u",
                     inet_ntoa(temp_addr), (unsigned)lease_seconds);
                 requested_ip = packet.yiaddr;
+                start = monotonic_sec();
                 udhcp_run_script(&packet, state == REQUESTING ? "bound" : "renew");
+                already_waited_sec = (unsigned)monotonic_sec() - start;
+                timeout = lease_seconds / 2;
+                if ((unsigned)timeout < already_waited_sec) {
+                    /* Something went wrong. Back to discover state */
+                    timeout = already_waited_sec = 0;
+                }
                 state = BOUND;
 …
                 /* make future renew packets use different xid */
                 /* xid = random_xid(); ...but why bother? */
+                already_waited_sec = 0;
                 continue; /* back to main loop */
+            }
             if (*message == DHCPNAK) {
+                /* If network has more than one DHCP server,
+                 * "wrong" server can reply first, with a NAK.
+                 * Do not interpret it as a NAK from "our" server.
+                 */
+                if (server_addr != 0) {
+                    uint32_t svid;
+                    uint8_t *temp;
+                    temp = udhcp_get_option(&packet, DHCP_SERVER_ID);
+                    if (!temp) {
+ non_matching_svid:
+                        log1("%s with wrong server ID, ignoring packet",
+                            "Received DHCP NAK"
+                        );
+                        continue;
+                    }
+                    move_from_unaligned32(svid, temp);
+                    if (svid != server_addr)
+                        goto non_matching_svid;
+                }
                 /* return to init state */
                 bb_info_msg("Received DHCP NAK");
+                bb_error_msg("received %s", "DHCP NAK");
                 udhcp_run_script(&packet, "nak");
                 if (state != REQUESTING)

branches/3.3/mindi-busybox/networking/udhcp/dhcpc.h

-              r3232
+              r3621
 #if ENABLE_FEATURE_UDHCP_PORT
+#define CLIENT_PORT (client_config.port)
+#define CLIENT_PORT  (client_config.port)
+#define CLIENT_PORT6 (client_config.port)
 #else
+#define CLIENT_PORT 68
+#define CLIENT_PORT  68
+#define CLIENT_PORT6 546
 #endif

branches/3.3/mindi-busybox/networking/udhcp/dhcpd.c

-              r3232
+              r3621
 //usage:#define udhcpd_trivial_usage
 //usage:       "[-fS]" IF_FEATURE_UDHCP_PORT(" [-P N]") " [CONFFILE]"
+//usage:       "[-fS] [-I ADDR]" IF_FEATURE_UDHCP_PORT(" [-P N]") " [CONFFILE]"
 //usage:#define udhcpd_full_usage "\n\n"
 //usage:       "DHCP server\n"
 //usage:     "\n    -f  Run in foreground"
 //usage:     "\n    -S  Log to syslog too"
+//usage:     "\n    -I ADDR Local address"
+//usage:     "\n    -a MSEC Timeout for ARP ping (default 2000)"
 //usage:    IF_FEATURE_UDHCP_PORT(
 //usage:     "\n    -P N    Use port N (default 67)"
 …
      || dhcp_pkt->ciaddr == 0
     ) {
         log1("Broadcasting packet to client");
+        log1("broadcasting packet to client");
         ciaddr = INADDR_BROADCAST;
         chaddr = MAC_BCAST_ADDR;
     } else {
         log1("Unicasting packet to client ciaddr");
+        log1("unicasting packet to client ciaddr");
         ciaddr = dhcp_pkt->ciaddr;
         chaddr = dhcp_pkt->chaddr;
 …
 static void send_packet_to_relay(struct dhcp_packet *dhcp_pkt)
+{
     log1("Forwarding packet to relay");
+    log1("forwarding packet to relay");
     udhcp_send_kernel_packet(dhcp_pkt,
 …
         uint32_t static_lease_nip,
         struct dyn_lease *lease,
+        uint8_t *requested_ip_opt)
+        uint8_t *requested_ip_opt,
+        unsigned arpping_ms)
+{
     struct dhcp_packet packet;
 …
         else {
             /* Otherwise, find a free IP */
             packet.yiaddr = find_free_or_expired_nip(oldpacket->chaddr);
+            packet.yiaddr = find_free_or_expired_nip(oldpacket->chaddr, arpping_ms);
+        }
 …
     addr.s_addr = packet.yiaddr;
     bb_info_msg("Sending OFFER of %s", inet_ntoa(addr));
+    bb_error_msg("sending OFFER of %s", inet_ntoa(addr));
     /* send_packet emits error message itself if it detects failure */
     send_packet(&packet, /*force_bcast:*/ 0);
 …
     init_packet(&packet, oldpacket, DHCPNAK);
     log1("Sending NAK");
+    log1("sending %s", "NAK");
     send_packet(&packet, /*force_bcast:*/ 1);
+}
 …
     addr.s_addr = yiaddr;
     bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
+    bb_error_msg("sending ACK to %s", inet_ntoa(addr));
     send_packet(&packet, /*force_bcast:*/ 0);
 …
     unsigned opt;
     struct option_set *option;
+    char *str_I = str_I;
+    const char *str_a = "2000";
+    unsigned arpping_ms;
     IF_FEATURE_UDHCP_PORT(char *str_P;)
+#if ENABLE_FEATURE_UDHCP_PORT
+    SERVER_PORT = 67;
     CLIENT_PORT = 68;
+#endif
+    setup_common_bufsiz();
+    IF_FEATURE_UDHCP_PORT(SERVER_PORT = 67;)
+    IF_FEATURE_UDHCP_PORT(CLIENT_PORT = 68;)
 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
     opt_complementary = "vv";
 #endif
+    opt = getopt32(argv, "fSv"
+        IF_FEATURE_UDHCP_PORT("P:", &str_P)
+    opt = getopt32(argv, "fSI:va:"
+        IF_FEATURE_UDHCP_PORT("P:")
+        , &str_I
+        , &str_a
+        IF_FEATURE_UDHCP_PORT(, &str_P)
         IF_UDHCP_VERBOSE(, &dhcp_verbose)
         );
 …
         logmode |= LOGMODE_SYSLOG;
+    }
+    if (opt & 4) { /* -I */
+        len_and_sockaddr *lsa = xhost_and_af2sockaddr(str_I, 0, AF_INET);
+        server_config.server_nip = lsa->u.sin.sin_addr.s_addr;
+        free(lsa);
+    }
 #if ENABLE_FEATURE_UDHCP_PORT
     if (opt & 8) { /* -P */
+    if (opt & 32) { /* -P */
         SERVER_PORT = xatou16(str_P);
         CLIENT_PORT = SERVER_PORT + 1;
+    }
 #endif
+    arpping_ms = xatou(str_a);
     /* Would rather not do read_config before daemonization -
      * otherwise NOMMU machines will parse config twice */
 …
     /* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
     bb_info_msg("%s (v"BB_VER") started", applet_name);
+    bb_error_msg("started, v"BB_VER);
     option = udhcp_find_option(server_config.options, DHCP_LEASE_TIME);
 …
     if (udhcp_read_interface(server_config.interface,
             &server_config.ifindex,
             &server_config.server_nip,
+            (server_config.server_nip == 0 ? &server_config.server_nip : NULL),
             server_config.server_mac)
     ) {
 …
         max_sock = udhcp_sp_fd_set(&rfds, server_socket);
         if (server_config.auto_time) {
+            tv.tv_sec = timeout_end - monotonic_sec();
+            /* cast to signed is essential if tv_sec is wider than int */
+            tv.tv_sec = (int)(timeout_end - monotonic_sec());
             tv.tv_usec = 0;
+        }
 …
+        }
         if (retval < 0 && errno != EINTR) {
             log1("Error on select");
+            log1("error on select");
             continue;
+        }
 …
         switch (udhcp_sp_read(&rfds)) {
         case SIGUSR1:
             bb_info_msg("Received SIGUSR1");
+            bb_error_msg("received %s", "SIGUSR1");
             write_leases();
             /* why not just reset the timeout, eh */
             goto continue_with_autotime;
         case SIGTERM:
             bb_info_msg("Received SIGTERM");
+            bb_error_msg("received %s", "SIGTERM");
             write_leases();
             goto ret0;
 …
             /* bytes can also be -2 ("bad packet data") */
             if (bytes == -1 && errno != EINTR) {
                 log1("Read error: %s, reopening socket", strerror(errno));
+                log1("read error: %s, reopening socket", strerror(errno));
                 close(server_socket);
                 server_socket = -1;
 …
         static_lease_nip = get_static_nip_by_mac(server_config.static_leases, &packet.chaddr);
         if (static_lease_nip) {
             bb_info_msg("Found static lease: %x", static_lease_nip);
+            bb_error_msg("found static lease: %x", static_lease_nip);
             memcpy(&fake_lease.lease_mac, &packet.chaddr, 6);
             fake_lease.lease_nip = static_lease_nip;
 …
         case DHCPDISCOVER:
             log1("Received DISCOVER");
             send_offer(&packet, static_lease_nip, lease, requested_ip_opt);
+            log1("received %s", "DISCOVER");
+            send_offer(&packet, static_lease_nip, lease, requested_ip_opt, arpping_ms);
             break;
         case DHCPREQUEST:
             log1("Received REQUEST");
+            log1("received %s", "REQUEST");
 /* RFC 2131:
 …
              * ciaddr must be 0 (we do not check this)
              */
             log1("Received DECLINE");
+            log1("received %s", "DECLINE");
             if (server_id_opt
              && requested_ip_opt
 …
              * ciaddr must be filled in
              */
             log1("Received RELEASE");
+            log1("received %s", "RELEASE");
             if (server_id_opt
              && lease  /* chaddr matches this lease */
 …
         case DHCPINFORM:
             log1("Received INFORM");
+            log1("received %s", "INFORM");
             send_inform(&packet);
             break;

branches/3.3/mindi-busybox/networking/udhcp/dhcpd.h

-              r2725
+              r3621
 } FIX_ALIASING;
 #define server_config (*(struct server_config_t*)&bb_common_bufsiz1)
+#define server_config (*(struct server_config_t*)bb_common_bufsiz1)
 /* client_config sits in 2nd half of bb_common_bufsiz1 */
 #if ENABLE_FEATURE_UDHCP_PORT
+#define SERVER_PORT (server_config.port)
+#define SERVER_PORT  (server_config.port)
+#define SERVER_PORT6 (server_config.port)
 #else
+#define SERVER_PORT 67
+#define SERVER_PORT  67
+#define SERVER_PORT6 547
 #endif
 …
 struct dyn_lease *find_lease_by_mac(const uint8_t *mac) FAST_FUNC;
 struct dyn_lease *find_lease_by_nip(uint32_t nip) FAST_FUNC;
 uint32_t find_free_or_expired_nip(const uint8_t *safe_mac) FAST_FUNC;
+uint32_t find_free_or_expired_nip(const uint8_t *safe_mac, unsigned arpping_ms) FAST_FUNC;

branches/3.3/mindi-busybox/networking/udhcp/dhcprelay.c

-              r3232
+              r3621
 } FIX_ALIASING;
+#define dhcprelay_xid_list (*(struct xid_item*)&bb_common_bufsiz1)
+#define dhcprelay_xid_list (*(struct xid_item*)bb_common_bufsiz1)
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
 static struct xid_item *xid_add(uint32_t xid, struct sockaddr_in *ip, int client)
 …
     int num_sockets, max_socket;
     uint32_t our_nip;
+    INIT_G();
     server_addr.sin_family = AF_INET;

branches/3.3/mindi-busybox/networking/udhcp/domain_codec.c

-              r2725
+              r3621
  */
 #ifdef DNS_COMPR_TESTING
+# define _GNU_SOURCE
 # define FAST_FUNC /* nothing */
 # define xmalloc malloc
 …
     while (1) {
         /* note: "return NULL" below are leak-safe since
          * dst isn't yet allocated */
+         * dst isn't allocated yet */
         const uint8_t *c;
         unsigned crtpos, retpos, depth, len;
 …
                     return NULL;
                 if (dst)
+                    memcpy(dst + len, c + 1, *c);
+                    /* \3com ---> "com." */
+                    ((char*)mempcpy(dst + len, c + 1, *c))[0] = '.';
                 len += *c + 1;
                 crtpos += *c + 1;
-                if (dst)
-                    dst[len - 1] = '.';
             } else {
                 /* NUL: end of current domain name */
 …
                     retpos = depth = 0;
+                }
+                if (dst)
+                if (dst && len != 0)
+                    /* \4host\3com\0\4host and we are at \0:
+                     * \3com was converted to "com.", change dot to space.
+                     */
                     dst[len - 1] = ' ';
+            }
 …
             /* allocate dst buffer and copy pre */
             unsigned plen = strlen(pre);
+            ret = dst = xmalloc(plen + len);
+            memcpy(dst, pre, plen);
+            dst += plen;
+            ret = xmalloc(plen + len);
+            dst = stpcpy(ret, pre);
         } else {
             dst[len - 1] = '\0';
 …
     uint8_t *encoded;
+        uint8_t str[6] = { 0x00, 0x00, 0x02, 0x65, 0x65, 0x00 };
+        printf("NUL:'%s'\n",   dname_dec(str, 6, ""));
 #define DNAME_DEC(encoded,pre) dname_dec((uint8_t*)(encoded), sizeof(encoded), (pre))
     printf("'%s'\n",       DNAME_DEC("\4host\3com\0", "test1:"));

branches/3.3/mindi-busybox/networking/udhcp/dumpleases.c

-              r3232
+              r3621
 //usage:#define dumpleases_trivial_usage
 //usage:       "[-r|-a] [-f LEASEFILE]"
+//usage:       "[-r|-a] [-d] [-f LEASEFILE]"
 //usage:#define dumpleases_full_usage "\n\n"
 //usage:       "Display DHCP leases granted by udhcpd\n"
 …
 //usage:     "\n    -r,--remaining  Show remaining time"
 //usage:     "\n    -a,--absolute   Show expiration time"
+//usage:     "\n    -d,--decimal    Show time in seconds"
 //usage:    )
 //usage:    IF_NOT_LONG_OPTS(
 …
 //usage:     "\n    -r  Show remaining time"
 //usage:     "\n    -a  Show expiration time"
+//usage:     "\n    -d  Show time in seconds"
 //usage:    )
 …
     int i;
     unsigned opt;
     int64_t written_at, curr, expires_abs;
+    int64_t written_at, curr;
     const char *file = LEASES_FILE;
     struct dyn_lease lease;
-    struct in_addr addr;
     enum {
 …
         OPT_r = 0x2, // -r
         OPT_f = 0x4, // -f
+        OPT_d = 0x8, // -d
     };
 #if ENABLE_LONG_OPTS
 …
         "remaining\0" No_argument       "r"
         "file\0"      Required_argument "f"
+        "decimal\0"   No_argument       "d"
+        ;
 …
     opt_complementary = "=0:a--r:r--a";
     opt = getopt32(argv, "arf:", &file);
+    opt = getopt32(argv, "arf:d", &file);
     fd = xopen(file, O_RDONLY);
     printf("Mac Address       IP Address      Host Name           Expires %s\n", (opt & OPT_a) ? "at" : "in");
+    /*     "123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 */
     /*     "00:00:00:00:00:00 255.255.255.255 ABCDEFGHIJKLMNOPQRS Wed Jun 30 21:49:08 1993" */
+    /*     "123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 */
+    printf("Mac %-14s"       "IP %-13s"      "Host %-15s"        "Expires %s\n",
+        "Address", "Address", "Name",
+        (opt & OPT_a) ? "at" : "in"
+    );
     xread(fd, &written_at, sizeof(written_at));
 …
     while (full_read(fd, &lease, sizeof(lease)) == sizeof(lease)) {
+        struct in_addr addr;
+        int64_t expires_abs;
         const char *fmt = ":%02x" + 1;
         for (i = 0; i < 6; i++) {
 …
             continue;
+        }
+        if (opt & OPT_d) {
+            /* -d: decimal time */
+            if (!(opt & OPT_a))
+                expires_abs -= curr;
+            printf("%llu\n", (unsigned long long) expires_abs);
+            continue;
+        }
         if (!(opt & OPT_a)) { /* no -a */
             unsigned d, h, m;

branches/3.3/mindi-busybox/networking/udhcp/files.c

-              r3232
+              r3621
     const char *keyword;
     int (*handler)(const char *line, void *var) FAST_FUNC;
     void *var;
+    unsigned ofs;
     const char *def;
 };
+#define OFS(field) offsetof(struct server_config_t, field)
 static const struct config_keyword keywords[] = {
     /* keyword        handler           variable address               default */
     {"start"        , udhcp_str2nip   , &server_config.start_ip     , "192.168.0.20"},
     {"end"          , udhcp_str2nip   , &server_config.end_ip       , "192.168.0.254"},
     {"interface"    , read_str        , &server_config.interface    , "eth0"},
+    {"start"        , udhcp_str2nip   , OFS(start_ip     ), "192.168.0.20"},
+    {"end"          , udhcp_str2nip   , OFS(end_ip       ), "192.168.0.254"},
+    {"interface"    , read_str        , OFS(interface    ), "eth0"},
     /* Avoid "max_leases value not sane" warning by setting default
      * to default_end_ip - default_start_ip + 1: */
     {"max_leases"   , read_u32        , &server_config.max_leases   , "235"},
     {"auto_time"    , read_u32        , &server_config.auto_time    , "7200"},
     {"decline_time" , read_u32        , &server_config.decline_time , "3600"},
     {"conflict_time", read_u32        , &server_config.conflict_time, "3600"},
     {"offer_time"   , read_u32        , &server_config.offer_time   , "60"},
     {"min_lease"    , read_u32        , &server_config.min_lease_sec, "60"},
     {"lease_file"   , read_str        , &server_config.lease_file   , LEASES_FILE},
     {"pidfile"      , read_str        , &server_config.pidfile      , "/var/run/udhcpd.pid"},
     {"siaddr"       , udhcp_str2nip   , &server_config.siaddr_nip   , "0.0.0.0"},
+    {"max_leases"   , read_u32        , OFS(max_leases   ), "235"},
+    {"auto_time"    , read_u32        , OFS(auto_time    ), "7200"},
+    {"decline_time" , read_u32        , OFS(decline_time ), "3600"},
+    {"conflict_time", read_u32        , OFS(conflict_time), "3600"},
+    {"offer_time"   , read_u32        , OFS(offer_time   ), "60"},
+    {"min_lease"    , read_u32        , OFS(min_lease_sec), "60"},
+    {"lease_file"   , read_str        , OFS(lease_file   ), LEASES_FILE},
+    {"pidfile"      , read_str        , OFS(pidfile      ), "/var/run/udhcpd.pid"},
+    {"siaddr"       , udhcp_str2nip   , OFS(siaddr_nip   ), "0.0.0.0"},
     /* keywords with no defaults must be last! */
     {"option"       , udhcp_str2optset, &server_config.options      , ""},
     {"opt"          , udhcp_str2optset, &server_config.options      , ""},
     {"notify_file"  , read_str        , &server_config.notify_file  , NULL},
     {"sname"        , read_str        , &server_config.sname        , NULL},
     {"boot_file"    , read_str        , &server_config.boot_file    , NULL},
     {"static_lease" , read_staticlease, &server_config.static_leases, ""},
+    {"option"       , udhcp_str2optset, OFS(options      ), ""},
+    {"opt"          , udhcp_str2optset, OFS(options      ), ""},
+    {"notify_file"  , read_str        , OFS(notify_file  ), NULL},
+    {"sname"        , read_str        , OFS(sname        ), NULL},
+    {"boot_file"    , read_str        , OFS(boot_file    ), NULL},
+    {"static_lease" , read_staticlease, OFS(static_leases), ""},
 };
 enum { KWS_WITH_DEFAULTS = ARRAY_SIZE(keywords) - 6 };
 …
     for (i = 0; i < KWS_WITH_DEFAULTS; i++)
         keywords[i].handler(keywords[i].def, keywords[i].var);
+        keywords[i].handler(keywords[i].def, (char*)&server_config + keywords[i].ofs);
     parser = config_open(file);
 …
         for (k = keywords, i = 0; i < ARRAY_SIZE(keywords); k++, i++) {
             if (strcasecmp(token[0], k->keyword) == 0) {
                 if (!k->handler(token[1], k->var)) {
+                if (!k->handler(token[1], (char*)&server_config + k->ofs)) {
                     bb_error_msg("can't parse line %u in %s",
                             parser->lineno, file);
                     /* reset back to the default value */
                     k->handler(k->def, k->var);
+                    k->handler(k->def, (char*)&server_config + k->ofs);
+                }
                 break;
 …
     while (full_read(fd, &lease, sizeof(lease)) == sizeof(lease)) {
-//FIXME: what if it matches some static lease?
         uint32_t y = ntohl(lease.lease_nip);
         if (y >= server_config.start_ip && y <= server_config.end_ip) {
             signed_leasetime_t expires = ntohl(lease.expires) - (signed_leasetime_t)time_passed;
+            uint32_t static_nip;
             if (expires <= 0)
+                /* We keep expired leases: add_lease() will add
+                 * a lease with 0 seconds remaining.
+                 * Fewer IP address changes this way for mass reboot scenario.
+                 */
+                expires = 0;
+            /* Check if there is a different static lease for this IP or MAC */
+            static_nip = get_static_nip_by_mac(server_config.static_leases, lease.lease_mac);
+            if (static_nip) {
+                /* NB: we do not add lease even if static_nip == lease.lease_nip.
+                 */
                 continue;
+            }
+            if (is_nip_reserved(server_config.static_leases, lease.lease_nip))
+                continue;
             /* NB: add_lease takes "relative time", IOW,
              * lease duration, not lease deadline. */
 …
+        }
+    }
     log1("Read %d leases", i);
+    log1("read %d leases", i);
  ret:
     close(fd);

branches/3.3/mindi-busybox/networking/udhcp/leases.c

-              r3232
+              r3621
      * and therefore can't ever match */
     for (i = 0; i < server_config.max_leases; i++) {
+        if (g_leases[i].expires < oldest_time) {
+        if (g_leases[i].expires == 0 /* empty entry */
+         || g_leases[i].expires < oldest_time
+        ) {
             oldest_time = g_leases[i].expires;
             oldest_lease = &g_leases[i];
 …
                 hostname_len = sizeof(oldest->hostname);
             p = safe_strncpy(oldest->hostname, hostname, hostname_len);
+            /* sanitization (s/non-ASCII/^/g) */
+            /*
+             * Sanitization (s/bad_char/./g).
+             * The intent is not to allow only "DNS-valid" hostnames,
+             * but merely make dumpleases output safe for shells to use.
+             * We accept "0-9A-Za-z._-", all other chars turn to dots.
+             */
             while (*p) {
                 if (*p < ' ' || *p > 126)
                     *p = '^';
+                if (!isalnum(*p) && *p != '-' && *p != '_')
+                    *p = '.';
                 p++;
+            }
 …
 /* Check if the IP is taken; if it is, add it to the lease table */
 static int nobody_responds_to_arp(uint32_t nip, const uint8_t *safe_mac)
+static int nobody_responds_to_arp(uint32_t nip, const uint8_t *safe_mac, unsigned arpping_ms)
+{
     struct in_addr temp;
 …
             server_config.server_nip,
             server_config.server_mac,
+            server_config.interface);
+            server_config.interface,
+            arpping_ms);
     if (r)
         return r;
     temp.s_addr = nip;
     bb_info_msg("%s belongs to someone, reserving it for %u seconds",
+    bb_error_msg("%s belongs to someone, reserving it for %u seconds",
         inet_ntoa(temp), (unsigned)server_config.conflict_time);
     add_lease(NULL, nip, server_config.conflict_time, NULL, 0);
 …
 /* Find a new usable (we think) address */
 uint32_t FAST_FUNC find_free_or_expired_nip(const uint8_t *safe_mac)
+uint32_t FAST_FUNC find_free_or_expired_nip(const uint8_t *safe_mac, unsigned arpping_ms)
+{
     uint32_t addr;
 …
         if (!lease) {
 //TODO: DHCP servers do not always sit on the same subnet as clients: should *ping*, not arp-ping!
             if (nobody_responds_to_arp(nip, safe_mac))
+            if (nobody_responds_to_arp(nip, safe_mac, arpping_ms))
                 return nip;
         } else {
 …
     if (oldest_lease
      && is_expired_lease(oldest_lease)
      && nobody_responds_to_arp(oldest_lease->lease_nip, safe_mac)
+     && nobody_responds_to_arp(oldest_lease->lease_nip, safe_mac, arpping_ms)
     ) {
         return oldest_lease->lease_nip;

branches/3.3/mindi-busybox/networking/udhcp/packet.c

-              r3232
+              r3621
         return;
     bb_info_msg(
         //" op %x"
+    bb_error_msg(
+        //"op %x"
         //" htype %x"
         " hlen %x"
 …
     );
     *bin2hex(buf, (void *) packet->chaddr, sizeof(packet->chaddr)) = '\0';
     bb_info_msg(" chaddr %s", buf);
+    bb_error_msg("chaddr %s", buf);
+}
 #endif
 …
     bytes = safe_read(fd, packet, sizeof(*packet));
     if (bytes < 0) {
         log1("Packet read error, ignoring");
+        log1("packet read error, ignoring");
         return bytes; /* returns -1 */
+    }
 …
      || packet->cookie != htonl(DHCP_MAGIC)
     ) {
         bb_info_msg("Packet with bad magic, ignoring");
+        bb_error_msg("packet with bad magic, ignoring");
         return -2;
+    }
     log1("Received a packet");
+    log1("received %s", "a packet");
     udhcp_dump_packet(packet);
 …
      * In order to work with those buggy servers,
      * we truncate packets after end option byte.
+     *
+     * However, RFC 1542 says "The IP Total Length and UDP Length
+     * must be large enough to contain the minimal BOOTP header of 300 octets".
+     * Thus, we retain enough padding to not go below 300 BOOTP bytes.
+     * Some devices have filters which drop DHCP packets shorter than that.
      */
     padding = DHCP_OPTIONS_BUFSIZE - 1 - udhcp_end_option(packet.data.options);
+    if (padding > DHCP_SIZE - 300)
+        padding = DHCP_SIZE - 300;
     packet.ip.protocol = IPPROTO_UDP;
 …
     udhcp_dump_packet(dhcp_pkt);
     padding = DHCP_OPTIONS_BUFSIZE - 1 - udhcp_end_option(dhcp_pkt->options);
+    if (padding > DHCP_SIZE - 300)
+        padding = DHCP_SIZE - 300;
     result = safe_write(fd, dhcp_pkt, DHCP_SIZE - padding);
     msg = "write";

branches/3.3/mindi-busybox/networking/udhcp/socket.c

-              r3232
+              r3621
             return -1;
+        }
         log1("Adapter index %d", ifr->ifr_ifindex);
+        log1("adapter index %d", ifr->ifr_ifindex);
         *ifindex = ifr->ifr_ifindex;
+    }
 …
     char *colon;
     log1("Opening listen socket on *:%d %s", port, inf);
+    log1("opening listen socket on *:%d %s", port, inf);
     fd = xsocket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);

branches/3.3/mindi-busybox/networking/udhcp/static_leases.c

r2725	r3621
67	67	cur = *st_lease_pp;
68	68	while (cur) {
69		bb_~~info~~_msg("static lease: mac:%02x:%02x:%02x:%02x:%02x:%02x nip:%x",
	69	bb_error_msg("static lease: mac:%02x:%02x:%02x:%02x:%02x:%02x nip:%x",
70	70	cur->mac[0], cur->mac[1], cur->mac[2],
71	71	cur->mac[3], cur->mac[4], cur->mac[5],

branches/3.3/mindi-busybox/networking/wget.c

-              r3232
+              r3621
  */
+//config:config WGET
+//config:   bool "wget"
+//config:   default y
+//config:   help
+//config:     wget is a utility for non-interactive download of files from HTTP
+//config:     and FTP servers.
+//config:
+//config:config FEATURE_WGET_STATUSBAR
+//config:   bool "Enable a nifty process meter (+2k)"
+//config:   default y
+//config:   depends on WGET
+//config:   help
+//config:     Enable the transfer progress bar for wget transfers.
+//config:
+//config:config FEATURE_WGET_AUTHENTICATION
+//config:   bool "Enable HTTP authentication"
+//config:   default y
+//config:   depends on WGET
+//config:   help
+//config:     Support authenticated HTTP transfers.
+//config:
+//config:config FEATURE_WGET_LONG_OPTIONS
+//config:   bool "Enable long options"
+//config:   default y
+//config:   depends on WGET && LONG_OPTS
+//config:   help
+//config:     Support long options for the wget applet.
+//config:
+//config:config FEATURE_WGET_TIMEOUT
+//config:   bool "Enable timeout option -T SEC"
+//config:   default y
+//config:   depends on WGET
+//config:   help
+//config:     Supports network read and connect timeouts for wget,
+//config:     so that wget will give up and timeout, through the -T
+//config:     command line option.
+//config:
+//config:     Currently only connect and network data read timeout are
+//config:     supported (i.e., timeout is not applied to the DNS query). When
+//config:     FEATURE_WGET_LONG_OPTIONS is also enabled, the --timeout option
+//config:     will work in addition to -T.
+//config:
+//config:config FEATURE_WGET_OPENSSL
+//config:   bool "Try to connect to HTTPS using openssl"
+//config:   default y
+//config:   depends on WGET
+//config:   help
+//config:     Choose how wget establishes SSL connection for https:// URLs.
+//config:
+//config:     Busybox itself contains no SSL code. wget will spawn
+//config:     a helper program to talk over HTTPS.
+//config:
+//config:     OpenSSL has a simple SSL client for debug purposes.
+//config:     If you select "openssl" helper, wget will effectively call
+//config:     "openssl s_client -quiet -connect IP:443 2>/dev/null"
+//config:     and pipe its data through it.
+//config:     Note inconvenient API: host resolution is done twice,
+//config:     and there is no guarantee openssl's idea of IPv6 address
+//config:     format is the same as ours.
+//config:     Another problem is that s_client prints debug information
+//config:     to stderr, and it needs to be suppressed. This means
+//config:     all error messages get suppressed too.
+//config:     openssl is also a big binary, often dynamically linked
+//config:     against ~15 libraries.
+//config:
+//config:config FEATURE_WGET_SSL_HELPER
+//config:   bool "Try to connect to HTTPS using ssl_helper"
+//config:   default y
+//config:   depends on WGET
+//config:   help
+//config:     Choose how wget establishes SSL connection for https:// URLs.
+//config:
+//config:     Busybox itself contains no SSL code. wget will spawn
+//config:     a helper program to talk over HTTPS.
+//config:
+//config:     ssl_helper is a tool which can be built statically
+//config:     from busybox sources against a small embedded SSL library.
+//config:     Please see networking/ssl_helper/README.
+//config:     It does not require double host resolution and emits
+//config:     error messages to stderr.
+//config:
+//config:     Precompiled static binary may be available at
+//config:     http://busybox.net/downloads/binaries/
+//applet:IF_WGET(APPLET(wget, BB_DIR_USR_BIN, BB_SUID_DROP))
+//kbuild:lib-$(CONFIG_WGET) += wget.o
 //usage:#define wget_trivial_usage
 //usage:    IF_FEATURE_WGET_LONG_OPTIONS(
 …
 //usage:       "    [--header 'header: value'] [-Y|--proxy on/off] [-P DIR]\n"
 /* Since we ignore these opts, we don't show them in --help */
+/* //usage:    "    [--no-check-certificate] [--no-cache]" */
+/* //usage:    "    [--no-check-certificate] [--no-cache] [--passive-ftp] [-t TRIES]" */
+/* //usage:    "    [-nv] [-nc] [-nH] [-np]" */
 //usage:       "    [-U|--user-agent AGENT]" IF_FEATURE_WGET_TIMEOUT(" [-T SEC]") " URL..."
 //usage:    )
 …
 #if 0
 # define log_io(...) bb_error_msg(__VA_ARGS__)
+# define SENDFMT(fp, fmt, ...) \
+    do { \
+        log_io("> " fmt, ##__VA_ARGS__); \
+        fprintf(fp, fmt, ##__VA_ARGS__); \
+    } while (0);
 #else
 # define log_io(...) ((void)0)
+# define SENDFMT(fp, fmt, ...) fprintf(fp, fmt, ##__VA_ARGS__)
 #endif
 …
     char *allocated;
     const char *path;
+    const char *user;
+    char       *user;
+    const char *protocol;
     char       *host;
     int         port;
-    smallint    is_ftp;
 };
+static const char P_FTP[] ALIGN1 = "ftp";
+static const char P_HTTP[] ALIGN1 = "http";
+#if ENABLE_FEATURE_WGET_OPENSSL || ENABLE_FEATURE_WGET_SSL_HELPER
+static const char P_HTTPS[] ALIGN1 = "https";
+#endif
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+/* User-specified headers prevent using our corresponding built-in headers.  */
+enum {
+    HDR_HOST          = (1<<0),
+    HDR_USER_AGENT    = (1<<1),
+    HDR_RANGE         = (1<<2),
+    HDR_AUTH          = (1<<3) * ENABLE_FEATURE_WGET_AUTHENTICATION,
+    HDR_PROXY_AUTH    = (1<<4) * ENABLE_FEATURE_WGET_AUTHENTICATION,
+};
+static const char wget_user_headers[] ALIGN1 =
+    "Host:\0"
+    "User-Agent:\0"
+    "Range:\0"
+# if ENABLE_FEATURE_WGET_AUTHENTICATION
+    "Authorization:\0"
+    "Proxy-Authorization:\0"
+# endif
+    ;
+# define USR_HEADER_HOST       (G.user_headers & HDR_HOST)
+# define USR_HEADER_USER_AGENT (G.user_headers & HDR_USER_AGENT)
+# define USR_HEADER_RANGE      (G.user_headers & HDR_RANGE)
+# define USR_HEADER_AUTH       (G.user_headers & HDR_AUTH)
+# define USR_HEADER_PROXY_AUTH (G.user_headers & HDR_PROXY_AUTH)
+#else /* No long options, no user-headers :( */
+# define USR_HEADER_HOST       0
+# define USR_HEADER_USER_AGENT 0
+# define USR_HEADER_RANGE      0
+# define USR_HEADER_AUTH       0
+# define USR_HEADER_PROXY_AUTH 0
+#endif
 /* Globals */
 …
     bb_progress_t pmt;
 #endif
         char *dir_prefix;
+    char *dir_prefix;
 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
+        char *post_data;
+        char *extra_headers;
+#endif
+        char *fname_out;        /* where to direct output (-O) */
+        const char *proxy_flag; /* Use proxies if env vars are set */
+        const char *user_agent; /* "User-Agent" header field */
+    char *post_data;
+    char *extra_headers;
+    unsigned char user_headers; /* Headers mentioned by the user */
+#endif
+    char *fname_out;        /* where to direct output (-O) */
+    const char *proxy_flag; /* Use proxies if env vars are set */
+    const char *user_agent; /* "User-Agent" header field */
 #if ENABLE_FEATURE_WGET_TIMEOUT
     unsigned timeout_seconds;
+    bool die_if_timed_out;
 #endif
     int output_fd;
 …
 #define G (*ptr_to_globals)
 #define INIT_G() do { \
+        SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+    IF_FEATURE_WGET_TIMEOUT(G.timeout_seconds = 900;) \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+} while (0)
+#define FINI_G() do { \
+    FREE_PTR_TO_GLOBALS(); \
 } while (0)
 …
+}
+#if ENABLE_FEATURE_WGET_TIMEOUT
+static void alarm_handler(int sig UNUSED_PARAM)
+{
+    /* This is theoretically unsafe (uses stdio and malloc in signal handler) */
+    if (G.die_if_timed_out)
+        bb_error_msg_and_die("download timed out");
+}
+static void set_alarm(void)
+{
+    if (G.timeout_seconds) {
+        alarm(G.timeout_seconds);
+        G.die_if_timed_out = 1;
+    }
+}
+# define clear_alarm() ((void)(G.die_if_timed_out = 0))
+#else
+# define set_alarm()   ((void)0)
+# define clear_alarm() ((void)0)
+#endif
 static FILE *open_socket(len_and_sockaddr *lsa)
+{
+    int fd;
     FILE *fp;
+    set_alarm();
+    fd = xconnect_stream(lsa);
+    clear_alarm();
     /* glibc 2.4 seems to try seeking on it - ??! */
     /* hopefully it understands what ESPIPE means... */
     fp = fdopen(xconnect_stream(lsa), "r+");
     if (fp == NULL)
+    fp = fdopen(fd, "r+");
+    if (!fp)
         bb_perror_msg_and_die(bb_msg_memory_exhausted);
 …
     char *buf_ptr;
+    set_alarm();
     if (fgets(G.wget_buf, sizeof(G.wget_buf) - 1, fp) == NULL)
         bb_perror_msg_and_die("error getting response");
+    clear_alarm();
     buf_ptr = strchrnul(G.wget_buf, '\n');
 …
     h->allocated = url = xstrdup(src_url);
+    if (strncmp(url, "http://", 7) == 0) {
+        h->port = bb_lookup_port("http", "tcp", 80);
+        h->host = url + 7;
+        h->is_ftp = 0;
+    } else if (strncmp(url, "ftp://", 6) == 0) {
+        h->port = bb_lookup_port("ftp", "tcp", 21);
+        h->host = url + 6;
+        h->is_ftp = 1;
+    } else
+        bb_error_msg_and_die("not an http or ftp url: %s", sanitize_string(url));
+    h->protocol = P_FTP;
+    p = strstr(url, "://");
+    if (p) {
+        *p = '\0';
+        h->host = p + 3;
+        if (strcmp(url, P_FTP) == 0) {
+            h->port = bb_lookup_port(P_FTP, "tcp", 21);
+        } else
+#if ENABLE_FEATURE_WGET_OPENSSL || ENABLE_FEATURE_WGET_SSL_HELPER
+        if (strcmp(url, P_HTTPS) == 0) {
+            h->port = bb_lookup_port(P_HTTPS, "tcp", 443);
+            h->protocol = P_HTTPS;
+        } else
+#endif
+        if (strcmp(url, P_HTTP) == 0) {
+ http:
+            h->port = bb_lookup_port(P_HTTP, "tcp", 80);
+            h->protocol = P_HTTP;
+        } else {
+            *p = ':';
+            bb_error_msg_and_die("not an http or ftp url: %s", sanitize_string(url));
+        }
+    } else {
+        // GNU wget is user-friendly and falls back to http://
+        h->host = url;
+        goto http;
+    }
     // FYI:
 …
+    }
-    // We used to set h->user to NULL here, but this interferes
-    // with handling of code 302 ("object was moved")
     sp = strrchr(h->host, '@');
     if (sp != NULL) {
 …
         // Standard wget and curl do this too.
         *sp = '\0';
+        h->user = percent_decode_in_place(h->host, /*strict:*/ 0);
+        free(h->user);
+        h->user = xstrdup(percent_decode_in_place(h->host, /*strict:*/ 0));
         h->host = sp + 1;
+    }
+    sp = h->host;
+    /* else: h->user remains NULL, or as set by original request
+     * before redirect (if we are here after a redirect).
+     */
+}
 …
     /* convert the header name to lower case */
+    for (s = G.wget_buf; isalnum(*s) || *s == '-' || *s == '.'; ++s) {
+        /* tolower for "A-Z", no-op for "0-9a-z-." */
+    for (s = G.wget_buf; isalnum(*s) || *s == '-' || *s == '.' || *s == '_'; ++s) {
+        /*
+         * No-op for 20-3f and 60-7f. "0-9a-z-." are in these ranges.
+         * 40-5f range ("@A-Z[\]^_") maps to 60-7f.
+         * "A-Z" maps to "a-z".
+         * "@[\]" can't occur in header names.
+         * "^_" maps to "~,DEL" (which is wrong).
+         * "^" was never seen yet, "_" was seen from web.archive.org
+         * (x-archive-orig-x_commoncrawl_Signature: HEXSTRING).
+         */
         *s |= 0x20;
+    }
 …
+}
+#if ENABLE_FEATURE_WGET_OPENSSL
+static int spawn_https_helper_openssl(const char *host, unsigned port)
+{
+    char *allocated = NULL;
+    int sp[2];
+    int pid;
+    IF_FEATURE_WGET_SSL_HELPER(volatile int child_failed = 0;)
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) != 0)
+        /* Kernel can have AF_UNIX support disabled */
+        bb_perror_msg_and_die("socketpair");
+    if (!strchr(host, ':'))
+        host = allocated = xasprintf("%s:%u", host, port);
+    fflush_all();
+    pid = xvfork();
+    if (pid == 0) {
+        /* Child */
+        char *argv[6];
+        close(sp[0]);
+        xmove_fd(sp[1], 0);
+        xdup2(0, 1);
+        /*
+         * openssl s_client -quiet -connect www.kernel.org:443 2>/dev/null
+         * It prints some debug stuff on stderr, don't know how to suppress it.
+         * Work around by dev-nulling stderr. We lose all error messages :(
+         */
+        xmove_fd(2, 3);
+        xopen("/dev/null", O_RDWR);
+        argv[0] = (char*)"openssl";
+        argv[1] = (char*)"s_client";
+        argv[2] = (char*)"-quiet";
+        argv[3] = (char*)"-connect";
+        argv[4] = (char*)host;
+        argv[5] = NULL;
+        BB_EXECVP(argv[0], argv);
+        xmove_fd(3, 2);
+# if ENABLE_FEATURE_WGET_SSL_HELPER
+        child_failed = 1;
+        xfunc_die();
+# else
+        bb_perror_msg_and_die("can't execute '%s'", argv[0]);
+# endif
+        /* notreached */
+    }
+    /* Parent */
+    free(allocated);
+    close(sp[1]);
+# if ENABLE_FEATURE_WGET_SSL_HELPER
+    if (child_failed) {
+        close(sp[0]);
+        return -1;
+    }
+# endif
+    return sp[0];
+}
+#endif
+/* See networking/ssl_helper/README how to build one */
+#if ENABLE_FEATURE_WGET_SSL_HELPER
+static void spawn_https_helper_small(int network_fd)
+{
+    int sp[2];
+    int pid;
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) != 0)
+        /* Kernel can have AF_UNIX support disabled */
+        bb_perror_msg_and_die("socketpair");
+    pid = BB_MMU ? xfork() : xvfork();
+    if (pid == 0) {
+        /* Child */
+        char *argv[3];
+        close(sp[0]);
+        xmove_fd(sp[1], 0);
+        xdup2(0, 1);
+        xmove_fd(network_fd, 3);
+        /*
+         * A simple ssl/tls helper
+         */
+        argv[0] = (char*)"ssl_helper";
+        argv[1] = (char*)"-d3";
+        argv[2] = NULL;
+        BB_EXECVP(argv[0], argv);
+        bb_perror_msg_and_die("can't execute '%s'", argv[0]);
+        /* notreached */
+    }
+    /* Parent */
+    close(sp[1]);
+    xmove_fd(sp[0], network_fd);
+}
+#endif
 static void NOINLINE retrieve_file_data(FILE *dfp)
+{
 …
                 second_cnt = G.timeout_seconds;
 #endif
                 continue;
+                goto bump;
+            }
 …
                  */
+            }
+#endif
+ bump:
             /* Need to do it _every_ second for "stalled" indicator
              * to be shown properly.
              */
             progress_meter(PROGRESS_BUMP);
-#endif
         } /* while (reading data) */
 …
     use_proxy = (strcmp(G.proxy_flag, "off") != 0);
     if (use_proxy) {
+        proxy = getenv(target.is_ftp ? "ftp_proxy" : "http_proxy");
+        proxy = getenv(target.protocol == P_FTP ? "ftp_proxy" : "http_proxy");
+//FIXME: what if protocol is https? Ok to use http_proxy?
         use_proxy = (proxy && proxy[0]);
         if (use_proxy)
 …
     G.got_clen = 0;
     G.chunked = 0;
     if (use_proxy || !target.is_ftp) {
+    if (use_proxy || target.protocol != P_FTP) {
         /*
          *  HTTP session
 …
         int status;
+        /* Open socket to http server */
+        /* Open socket to http(s) server */
+#if ENABLE_FEATURE_WGET_OPENSSL
+        /* openssl (and maybe ssl_helper) support is configured */
+        if (target.protocol == P_HTTPS) {
+            /* openssl-based helper
+             * Inconvenient API since we can't give it an open fd
+             */
+            int fd = spawn_https_helper_openssl(server.host, server.port);
+# if ENABLE_FEATURE_WGET_SSL_HELPER
+            if (fd < 0) { /* no openssl? try ssl_helper */
+                sfp = open_socket(lsa);
+                spawn_https_helper_small(fileno(sfp));
+                goto socket_opened;
+            }
+# else
+            /* We don't check for exec("openssl") failure in this case */
+# endif
+            sfp = fdopen(fd, "r+");
+            if (!sfp)
+                bb_perror_msg_and_die(bb_msg_memory_exhausted);
+            goto socket_opened;
+        }
         sfp = open_socket(lsa);
+ socket_opened:
+#elif ENABLE_FEATURE_WGET_SSL_HELPER
+        /* Only ssl_helper support is configured */
+        sfp = open_socket(lsa);
+        if (target.protocol == P_HTTPS)
+            spawn_https_helper_small(fileno(sfp));
+#else
+        /* ssl (https) support is not configured */
+        sfp = open_socket(lsa);
+#endif
         /* Send HTTP request */
         if (use_proxy) {
             fprintf(sfp, "GET %stp://%s/%s HTTP/1.1\r\n",
                 target.is_ftp ? "f" : "ht", target.host,
+            SENDFMT(sfp, "GET %s://%s/%s HTTP/1.1\r\n",
+                target.protocol, target.host,
                 target.path);
         } else {
             if (option_mask32 & WGET_OPT_POST_DATA)
                 fprintf(sfp, "POST /%s HTTP/1.1\r\n", target.path);
             else
                 fprintf(sfp, "GET /%s HTTP/1.1\r\n", target.path);
+        }
         fprintf(sfp, "Host: %s\r\nUser-Agent: %s\r\n",
             target.host, G.user_agent);
+            SENDFMT(sfp, "%s /%s HTTP/1.1\r\n",
+                (option_mask32 & WGET_OPT_POST_DATA) ? "POST" : "GET",
+                target.path);
+        }
+        if (!USR_HEADER_HOST)
+            SENDFMT(sfp, "Host: %s\r\n", target.host);
+        if (!USR_HEADER_USER_AGENT)
+            SENDFMT(sfp, "User-Agent: %s\r\n", G.user_agent);
         /* Ask server to close the connection as soon as we are done
          * (IOW: we do not intend to send more requests)
          */
         fprintf(sfp, "Connection: close\r\n");
+        SENDFMT(sfp, "Connection: close\r\n");
 #if ENABLE_FEATURE_WGET_AUTHENTICATION
         if (target.user) {
             fprintf(sfp, "Proxy-Authorization: Basic %s\r\n"+6,
+        if (target.user && !USR_HEADER_AUTH) {
+            SENDFMT(sfp, "Proxy-Authorization: Basic %s\r\n"+6,
                 base64enc(target.user));
+        }
         if (use_proxy && server.user) {
             fprintf(sfp, "Proxy-Authorization: Basic %s\r\n",
+        if (use_proxy && server.user && !USR_HEADER_PROXY_AUTH) {
+            SENDFMT(sfp, "Proxy-Authorization: Basic %s\r\n",
                 base64enc(server.user));
+        }
 #endif
         if (G.beg_range != 0)
             fprintf(sfp, "Range: bytes=%"OFF_FMT"u-\r\n", G.beg_range);
+        if (G.beg_range != 0 && !USR_HEADER_RANGE)
+            SENDFMT(sfp, "Range: bytes=%"OFF_FMT"u-\r\n", G.beg_range);
 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
+        if (G.extra_headers)
+        if (G.extra_headers) {
+            log_io(G.extra_headers);
             fputs(G.extra_headers, sfp);
+        }
         if (option_mask32 & WGET_OPT_POST_DATA) {
             fprintf(sfp,
+            SENDFMT(sfp,
                 "Content-Type: application/x-www-form-urlencoded\r\n"
                 "Content-Length: %u\r\n"
 …
 #endif
+        {
             fprintf(sfp, "\r\n");
+            SENDFMT(sfp, "\r\n");
+        }
 …
                     parse_url(str, &target);
                     if (!use_proxy) {
+                        /* server.user remains untouched */
                         free(server.allocated);
                         server.allocated = NULL;
 …
         /* For HTTP, data is pumped over the same connection */
         dfp = sfp;
     } else {
         /*
 …
     free(server.allocated);
     free(target.allocated);
+    free(server.user);
+    free(target.user);
     free(fname_out_alloc);
     free(redirected_path);
 …
         "proxy\0"            Required_argument "Y"
         "user-agent\0"       Required_argument "U"
+#if ENABLE_FEATURE_WGET_TIMEOUT
+        "timeout\0"          Required_argument "T"
+#endif
+IF_FEATURE_WGET_TIMEOUT(
+        "timeout\0"          Required_argument "T")
         /* Ignored: */
+        // "tries\0"            Required_argument "t"
+IF_DESKTOP( "tries\0"            Required_argument "t")
+        "header\0"           Required_argument "\xff"
+        "post-data\0"        Required_argument "\xfe"
         /* Ignored (we always use PASV): */
+        "passive-ftp\0"      No_argument       "\xff"
+        "header\0"           Required_argument "\xfe"
+        "post-data\0"        Required_argument "\xfd"
+IF_DESKTOP( "passive-ftp\0"      No_argument       "\xf0")
         /* Ignored (we don't do ssl) */
+        "no-check-certificate\0" No_argument   "\xfc"
+IF_DESKTOP( "no-check-certificate\0" No_argument   "\xf0")
         /* Ignored (we don't support caching) */
+        "no-cache\0"         No_argument       "\xfb"
+IF_DESKTOP( "no-cache\0"         No_argument       "\xf0")
+IF_DESKTOP( "no-verbose\0"       No_argument       "\xf0")
+IF_DESKTOP( "no-clobber\0"       No_argument       "\xf0")
+IF_DESKTOP( "no-host-directories\0" No_argument    "\xf0")
+IF_DESKTOP( "no-parent\0"        No_argument       "\xf0")
+        ;
 #endif
 …
     INIT_G();
+    IF_FEATURE_WGET_TIMEOUT(G.timeout_seconds = 900;)
+#if ENABLE_FEATURE_WGET_TIMEOUT
+    G.timeout_seconds = 900;
+    signal(SIGALRM, alarm_handler);
+#endif
     G.proxy_flag = "on";   /* use proxies if env vars are set */
     G.user_agent = "Wget"; /* "User-Agent" header field */
 …
     applet_long_options = wget_longopts;
 #endif
+    opt_complementary = "-1" IF_FEATURE_WGET_TIMEOUT(":T+") IF_FEATURE_WGET_LONG_OPTIONS(":\xfe::");
+    getopt32(argv, "csqO:P:Y:U:T:" /*ignored:*/ "t:",
+        &G.fname_out, &G.dir_prefix,
+    opt_complementary = "-1" /* at least one URL */
+        IF_FEATURE_WGET_TIMEOUT(":T+") /* -T NUM */
+        IF_FEATURE_WGET_LONG_OPTIONS(":\xff::"); /* --header is a list */
+    getopt32(argv, "csqO:P:Y:U:T:"
+        /*ignored:*/ "t:"
+        /*ignored:*/ "n::"
+        /* wget has exactly four -n<letter> opts, all of which we can ignore:
+         * -nv --no-verbose: be moderately quiet (-q is full quiet)
+         * -nc --no-clobber: abort if exists, neither download to FILE.n nor overwrite FILE
+         * -nH --no-host-directories: wget -r http://host/ won't create host/
+         * -np --no-parent
+         * "n::" above says that we accept -n[ARG].
+         * Specifying "n:" would be a bug: "-n ARG" would eat ARG!
+         */
+        , &G.fname_out, &G.dir_prefix,
         &G.proxy_flag, &G.user_agent,
         IF_FEATURE_WGET_TIMEOUT(&G.timeout_seconds) IF_NOT_FEATURE_WGET_TIMEOUT(NULL),
+        NULL /* -t RETRIES */
+        NULL, /* -t RETRIES */
+        NULL  /* -n[ARG] */
         IF_FEATURE_WGET_LONG_OPTIONS(, &headers_llist)
         IF_FEATURE_WGET_LONG_OPTIONS(, &G.post_data)
 …
 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
     if (headers_llist) {
         int size = 1;
         char *cp;
+        int size = 0;
+        char *hdr;
         llist_t *ll = headers_llist;
         while (ll) {
 …
             ll = ll->link;
+        }
         G.extra_headers = cp = xmalloc(size);
+        G.extra_headers = hdr = xmalloc(size + 1);
         while (headers_llist) {
+            cp += sprintf(cp, "%s\r\n", (char*)llist_pop(&headers_llist));
+            int bit;
+            const char *words;
+            size = sprintf(hdr, "%s\r\n",
+                    (char*)llist_pop(&headers_llist));
+            /* a bit like index_in_substrings but don't match full key */
+            bit = 1;
+            words = wget_user_headers;
+            while (*words) {
+                if (strstr(hdr, words) == hdr) {
+                    G.user_headers |= bit;
+                    break;
+                }
+                bit <<= 1;
+                words += strlen(words) + 1;
+            }
+            hdr += size;
+        }
+    }
 …
         xclose(G.output_fd);
+#if ENABLE_FEATURE_CLEAN_UP && ENABLE_FEATURE_WGET_LONG_OPTIONS
+    free(G.extra_headers);
+#endif
+    FINI_G();
     return EXIT_SUCCESS;
+}

branches/3.3/mindi-busybox/networking/zcip.c

-              r3232
+              r3621
 //usage:     "\n    -q      Quit after obtaining address"
 //usage:     "\n    -r 169.254.x.x  Request this address first"
+//usage:     "\n    -l x.x.0.0  Use this range instead of 169.254"
 //usage:     "\n    -v      Verbose"
+//usage:     "\n"
+//usage:     "\n$LOGGING=none       Suppress logging"
+//usage:     "\n$LOGGING=syslog     Log to syslog"
 //usage:     "\n"
 //usage:     "\nWith no -q, runs continuously monitoring for ARP conflicts,"
 …
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include <netinet/ether.h>
 #include <net/if.h>
 …
 enum {
+/* 169.254.0.0 */
+    LINKLOCAL_ADDR = 0xa9fe0000,
+/* protocol timeout parameters, specified in seconds */
+    /* 0-1 seconds before sending 1st probe */
     PROBE_WAIT = 1,
+    /* 1-2 seconds between probes */
     PROBE_MIN = 1,
     PROBE_MAX = 2,
     PROBE_NUM = 3,
     MAX_CONFLICTS = 10,
     RATE_LIMIT_INTERVAL = 60,
     ANNOUNCE_WAIT = 2,
     ANNOUNCE_NUM = 2,
     ANNOUNCE_INTERVAL = 2,
     DEFEND_INTERVAL = 10
+    PROBE_NUM = 3,      /* total probes to send */
+    ANNOUNCE_INTERVAL = 2,  /* 2 seconds between announces */
+    ANNOUNCE_NUM = 3,   /* announces to send */
+    /* if probe/announce sees a conflict, multiply RANDOM(NUM_CONFLICT) by... */
+    CONFLICT_MULTIPLIER = 2,
+    /* if we monitor and see a conflict, how long is defend state? */
+    DEFEND_INTERVAL = 10,
 };
 …
 enum {
     PROBE = 0,
-    RATE_LIMIT_PROBE,
     ANNOUNCE,
     MONITOR,
 …
 struct globals {
+    struct sockaddr saddr;
+    struct ether_addr eth_addr;
+    struct sockaddr iface_sockaddr;
+    struct ether_addr our_ethaddr;
+    uint32_t localnet_ip;
 } FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define saddr    (G.saddr   )
+#define eth_addr (G.eth_addr)
+#define INIT_G() do { } while (0)
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
 …
  * the first and last 256 addresses are reserved.
  */
 static uint32_t pick(void)
+static uint32_t pick_nip(void)
+{
     unsigned tmp;
 …
         tmp = rand() & IN_CLASSB_HOST;
     } while (tmp > (IN_CLASSB_HOST - 0x0200));
+    return htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
+    return htonl((G.localnet_ip + 0x0100) + tmp);
+}
+static const char *nip_to_a(uint32_t nip)
+{
+    struct in_addr in;
+    in.s_addr = nip;
+    return inet_ntoa(in);
+}
 …
  * Broadcast an ARP packet.
  */
 static void arp(
+static void send_arp_request(
     /* int op, - always ARPOP_REQUEST */
     /* const struct ether_addr *source_eth, - always &eth_addr */
                     struct in_addr source_ip,
     const struct ether_addr *target_eth, struct in_addr target_ip)
+    /* const struct ether_addr *source_eth, - always &G.our_ethaddr */
+                    uint32_t source_nip,
+    const struct ether_addr *target_eth, uint32_t target_nip)
+{
     enum { op = ARPOP_REQUEST };
 #define source_eth (&eth_addr)
+#define source_eth (&G.our_ethaddr)
     struct arp_packet p;
 …
     p.arp.arp_op = htons(op);
     memcpy(&p.arp.arp_sha, source_eth, ETH_ALEN);
     memcpy(&p.arp.arp_spa, &source_ip, sizeof(p.arp.arp_spa));
+    memcpy(&p.arp.arp_spa, &source_nip, 4);
     memcpy(&p.arp.arp_tha, target_eth, ETH_ALEN);
     memcpy(&p.arp.arp_tpa, &target_ip, sizeof(p.arp.arp_tpa));
+    memcpy(&p.arp.arp_tpa, &target_nip, 4);
     // send it
     // Even though sock_fd is already bound to saddr, just send()
+    // Even though sock_fd is already bound to G.iface_sockaddr, just send()
     // won't work, because "socket is not connected"
     // (and connect() won't fix that, "operation not supported").
     // Thus we sendto() to saddr. I wonder which sockaddr
+    // Thus we sendto() to G.iface_sockaddr. I wonder which sockaddr
     // (from bind() or from sendto()?) kernel actually uses
     // to determine iface to emit the packet from...
     xsendto(sock_fd, &p, sizeof(p), &saddr, sizeof(saddr));
+    xsendto(sock_fd, &p, sizeof(p), &G.iface_sockaddr, sizeof(G.iface_sockaddr));
 #undef source_eth
+}
 …
  * argv[0]:intf argv[1]:script_name argv[2]:junk argv[3]:NULL
  */
 static int run(char *argv[3], const char *param, struct in_addr *ip)
+static int run(char *argv[3], const char *param, uint32_t nip)
+{
     int status;
     char *addr = addr; /* for gcc */
+    const char *addr = addr; /* for gcc */
     const char *fmt = "%s %s %s" + 3;
 …
     VDBG("%s run %s %s\n", argv[0], argv[1], argv[2]);
     if (ip) {
         addr = inet_ntoa(*ip);
+    if (nip != 0) {
+        addr = nip_to_a(nip);
         xsetenv("ip", addr);
         fmt -= 3;
+    }
     bb_info_msg(fmt, argv[2], argv[0], addr);
+    bb_error_msg(fmt, argv[2], argv[0], addr);
     status = spawn_and_wait(argv + 1);
 …
 static ALWAYS_INLINE unsigned random_delay_ms(unsigned secs)
+{
     return rand() % (secs * 1000);
+    return (unsigned)rand() % (secs * 1000);
+}
 …
 int zcip_main(int argc UNUSED_PARAM, char **argv)
+{
+    char *r_opt;
+    const char *l_opt = "169.254.0.0";
     int state;
     char *r_opt;
+    int nsent;
     unsigned opts;
     // ugly trick, but I want these zeroed in one go
+    // Ugly trick, but I want these zeroed in one go
     struct {
+        const struct in_addr null_ip;
+        const struct ether_addr null_addr;
+        struct in_addr ip;
+        const struct ether_addr null_ethaddr;
         struct ifreq ifr;
+        int timeout_ms; /* must be signed */
+        unsigned conflicts;
+        unsigned nprobes;
+        unsigned nclaims;
+        int ready;
+        uint32_t chosen_nip;
+        int conflicts;
+        int timeout_ms; // must be signed
         int verbose;
     } L;
+#define null_ip    (L.null_ip   )
+#define null_addr  (L.null_addr )
+#define ip         (L.ip        )
+#define ifr        (L.ifr       )
+#define timeout_ms (L.timeout_ms)
+#define conflicts  (L.conflicts )
+#define nprobes    (L.nprobes   )
+#define nclaims    (L.nclaims   )
+#define ready      (L.ready     )
+#define verbose    (L.verbose   )
+#define null_ethaddr (L.null_ethaddr)
+#define ifr          (L.ifr         )
+#define chosen_nip   (L.chosen_nip  )
+#define conflicts    (L.conflicts   )
+#define timeout_ms   (L.timeout_ms  )
+#define verbose      (L.verbose     )
     memset(&L, 0, sizeof(L));
 …
 #define FOREGROUND (opts & 1)
 #define QUIT       (opts & 2)
     // parse commandline: prog [options] ifname script
+    // Parse commandline: prog [options] ifname script
     // exactly 2 args; -v accumulates and implies -f
     opt_complementary = "=2:vv:vf";
     opts = getopt32(argv, "fqr:v", &r_opt, &verbose);
+    opts = getopt32(argv, "fqr:l:v", &r_opt, &l_opt, &verbose);
 #if !BB_MMU
     // on NOMMU reexec early (or else we will rerun things twice)
 …
         bb_daemonize_or_rexec(0 /*was: DAEMON_CHDIR_ROOT*/, argv);
 #endif
     // open an ARP socket
+    // Open an ARP socket
     // (need to do it before openlog to prevent openlog from taking
     // fd 3 (sock_fd==3))
 …
         logmode |= LOGMODE_SYSLOG;
+    }
+    bb_logenv_override();
+    { // -l n.n.n.n
+        struct in_addr net;
+        if (inet_aton(l_opt, &net) == 0
+         || (net.s_addr & htonl(IN_CLASSB_NET)) != net.s_addr
+        ) {
+            bb_error_msg_and_die("invalid network address");
+        }
+        G.localnet_ip = ntohl(net.s_addr);
+    }
     if (opts & 4) { // -r n.n.n.n
+        struct in_addr ip;
         if (inet_aton(r_opt, &ip) == 0
          || (ntohl(ip.s_addr) & IN_CLASSB_NET) != LINKLOCAL_ADDR
+         || (ntohl(ip.s_addr) & IN_CLASSB_NET) != G.localnet_ip
         ) {
             bb_error_msg_and_die("invalid link address");
+        }
+        chosen_nip = ip.s_addr;
+    }
     argv += optind - 1;
 …
     xsetenv("interface", argv_intf);
     // initialize the interface (modprobe, ifup, etc)
     if (run(argv, "init", NULL))
+    // Initialize the interface (modprobe, ifup, etc)
+    if (run(argv, "init", 0))
         return EXIT_FAILURE;
     // initialize saddr
     // saddr is: { u16 sa_family; u8 sa_data[14]; }
     //memset(&saddr, 0, sizeof(saddr));
+    // Initialize G.iface_sockaddr
+    // G.iface_sockaddr is: { u16 sa_family; u8 sa_data[14]; }
+    //memset(&G.iface_sockaddr, 0, sizeof(G.iface_sockaddr));
     //TODO: are we leaving sa_family == 0 (AF_UNSPEC)?!
     safe_strncpy(saddr.sa_data, argv_intf, sizeof(saddr.sa_data));
     // bind to the interface's ARP socket
     xbind(sock_fd, &saddr, sizeof(saddr));
     // get the interface's ethernet address
+    safe_strncpy(G.iface_sockaddr.sa_data, argv_intf, sizeof(G.iface_sockaddr.sa_data));
+    // Bind to the interface's ARP socket
+    xbind(sock_fd, &G.iface_sockaddr, sizeof(G.iface_sockaddr));
+    // Get the interface's ethernet address
     //memset(&ifr, 0, sizeof(ifr));
     strncpy_IFNAMSIZ(ifr.ifr_name, argv_intf);
     xioctl(sock_fd, SIOCGIFHWADDR, &ifr);
     memcpy(&eth_addr, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
     // start with some stable ip address, either a function of
+    memcpy(&G.our_ethaddr, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
+    // Start with some stable ip address, either a function of
     // the hardware address or else the last address we used.
     // we are taking low-order four bytes, as top-order ones
 …
+    {
         uint32_t t;
         move_from_unaligned32(t, ((char *)&eth_addr + 2));
+        move_from_unaligned32(t, ((char *)&G.our_ethaddr + 2));
         srand(t);
+    }
-    if (ip.s_addr == 0)
-        ip.s_addr = pick();
     // FIXME cases to handle:
     //  - zcip already running!
     //  - link already has local address... just defend/update
     // daemonize now; don't delay system startup
+    // Daemonize now; don't delay system startup
     if (!FOREGROUND) {
 #if BB_MMU
         bb_daemonize(0 /*was: DAEMON_CHDIR_ROOT*/);
 #endif
         bb_info_msg("start, interface %s", argv_intf);
+    }
     // run the dynamic address negotiation protocol,
+        bb_error_msg("start, interface %s", argv_intf);
+    }
+    // Run the dynamic address negotiation protocol,
     // restarting after address conflicts:
     //  - start with some address we want to try
     //  - short random delay
     //  - arp probes to see if another host uses it
+    //    00:04:e2:64:23:c2 > ff:ff:ff:ff:ff:ff arp who-has 169.254.194.171 tell 0.0.0.0
     //  - arp announcements that we're claiming it
+    //    00:04:e2:64:23:c2 > ff:ff:ff:ff:ff:ff arp who-has 169.254.194.171 (00:04:e2:64:23:c2) tell 169.254.194.171
     //  - use it
     //  - defend it, within limits
 …
     // - poll error (when does this happen?)
     // - read error (when does this happen?)
     // - sendto error (in arp()) (when does this happen?)
+    // - sendto error (in send_arp_request()) (when does this happen?)
     // - revents & POLLERR (link down). run "<script> deconfig" first
+    if (chosen_nip == 0) {
+ new_nip_and_PROBE:
+        chosen_nip = pick_nip();
+    }
+    nsent = 0;
     state = PROBE;
     while (1) {
         struct pollfd fds[1];
         unsigned deadline_us;
+        unsigned deadline_us = deadline_us;
         struct arp_packet p;
         int source_ip_conflict;
         int target_ip_conflict;
+        int ip_conflict;
+        int n;
         fds[0].fd = sock_fd;
 …
         fds[0].revents = 0;
         // poll, being ready to adjust current timeout
+        // Poll, being ready to adjust current timeout
         if (!timeout_ms) {
             timeout_ms = random_delay_ms(PROBE_WAIT);
 …
             // ones we'd care about.
+        }
+        // set deadline_us to the point in time when we timeout
+        deadline_us = MONOTONIC_US() + timeout_ms * 1000;
+        VDBG("...wait %d %s nprobes=%u, nclaims=%u\n",
+                timeout_ms, argv_intf, nprobes, nclaims);
+        switch (safe_poll(fds, 1, timeout_ms)) {
+        default:
+        if (timeout_ms >= 0) {
+            // Set deadline_us to the point in time when we timeout
+            deadline_us = MONOTONIC_US() + timeout_ms * 1000;
+        }
+        VDBG("...wait %d %s nsent=%u\n",
+                timeout_ms, argv_intf, nsent);
+        n = safe_poll(fds, 1, timeout_ms);
+        if (n < 0) {
             //bb_perror_msg("poll"); - done in safe_poll
             return EXIT_FAILURE;
+        // timeout
+        case 0:
+            VDBG("state = %d\n", state);
+        }
+        if (n == 0) { // timed out?
+            VDBG("state:%d\n", state);
             switch (state) {
             case PROBE:
                 // timeouts in the PROBE state mean no conflicting ARP packets
                 // have been received, so we can progress through the states
                 if (nprobes < PROBE_NUM) {
                     nprobes++;
+                // No conflicting ARP packets were seen:
+                // we can progress through the states
+                if (nsent < PROBE_NUM) {
+                    nsent++;
                     VDBG("probe/%u %s@%s\n",
+                            nprobes, argv_intf, inet_ntoa(ip));
+                    arp(/* ARPOP_REQUEST, */
+                            /* &eth_addr, */ null_ip,
+                            &null_addr, ip);
+                            nsent, argv_intf, nip_to_a(chosen_nip));
                     timeout_ms = PROBE_MIN * 1000;
                     timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
+                    send_arp_request(0, &null_ethaddr, chosen_nip);
+                    continue;
+                }
+                else {
+                    // Switch to announce state.
+                    state = ANNOUNCE;
+                    nclaims = 0;
+                // Switch to announce state
+                nsent = 0;
+                state = ANNOUNCE;
+                goto send_announce;
+            case ANNOUNCE:
+                // No conflicting ARP packets were seen:
+                // we can progress through the states
+                if (nsent < ANNOUNCE_NUM) {
+ send_announce:
+                    nsent++;
                     VDBG("announce/%u %s@%s\n",
+                            nclaims, argv_intf, inet_ntoa(ip));
+                    arp(/* ARPOP_REQUEST, */
+                            /* &eth_addr, */ ip,
+                            &eth_addr, ip);
+                            nsent, argv_intf, nip_to_a(chosen_nip));
                     timeout_ms = ANNOUNCE_INTERVAL * 1000;
+                    send_arp_request(chosen_nip, &G.our_ethaddr, chosen_nip);
+                    continue;
+                }
+                break;
+            case RATE_LIMIT_PROBE:
+                // timeouts in the RATE_LIMIT_PROBE state mean no conflicting ARP packets
+                // have been received, so we can move immediately to the announce state
+                state = ANNOUNCE;
+                nclaims = 0;
+                VDBG("announce/%u %s@%s\n",
+                        nclaims, argv_intf, inet_ntoa(ip));
+                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
+                // have been received, so we can progress through the states
+                if (nclaims < ANNOUNCE_NUM) {
+                    nclaims++;
+                    VDBG("announce/%u %s@%s\n",
+                            nclaims, argv_intf, inet_ntoa(ip));
+                    arp(/* ARPOP_REQUEST, */
+                            /* &eth_addr, */ ip,
+                            &eth_addr, ip);
+                    timeout_ms = ANNOUNCE_INTERVAL * 1000;
+                }
+                else {
+                    // Switch to monitor state.
+                    state = MONITOR;
+                    // link is ok to use earlier
+                    // FIXME update filters
+                    run(argv, "config", &ip);
+                    ready = 1;
+                    conflicts = 0;
+                    timeout_ms = -1; // Never timeout in the monitor state.
+                    // NOTE: all other exit paths
+                    // should deconfig ...
+                    if (QUIT)
+                        return EXIT_SUCCESS;
+                }
+                break;
+            case DEFEND:
+                // We won!  No ARP replies, so just go back to monitor.
+                // Switch to monitor state
+                // FIXME update filters
+                run(argv, "config", chosen_nip);
+                // NOTE: all other exit paths should deconfig...
+                if (QUIT)
+                    return EXIT_SUCCESS;
+                // fall through: switch to MONITOR
+            default:
+            // case DEFEND:
+            // case MONITOR: (shouldn't happen, MONITOR timeout is infinite)
+                // Defend period ended with no ARP replies - we won
+                timeout_ms = -1; // never timeout in monitor state
                 state = MONITOR;
-                timeout_ms = -1;
-                conflicts = 0;
-                break;
-            default:
-                // Invalid, should never happen.  Restart the whole protocol.
-                state = PROBE;
-                ip.s_addr = pick();
-                timeout_ms = 0;
-                nprobes = 0;
-                nclaims = 0;
-                break;
-            } // switch (state)
-            break; // case 0 (timeout)
-        // packets arriving, or link went down
-        case 1:
-            // We need to adjust the timeout in case we didn't receive
-            // a conflicting packet.
-            if (timeout_ms > 0) {
-                unsigned diff = deadline_us - MONOTONIC_US();
-                if ((int)(diff) < 0) {
-                    // Current time is greater than the expected timeout time.
-                    // Should never happen.
-                    VDBG("missed an expected timeout\n");
-                    timeout_ms = 0;
-                } else {
-                    VDBG("adjusting timeout\n");
-                    timeout_ms = (diff / 1000) | 1; /* never 0 */
+                }
+            }
-            if ((fds[0].revents & POLLIN) == 0) {
-                if (fds[0].revents & POLLERR) {
-                    // FIXME: links routinely go down;
-                    // this shouldn't necessarily exit.
-                    bb_error_msg("iface %s is down", argv_intf);
-                    if (ready) {
-                        run(argv, "deconfig", &ip);
+                    }
-                    return EXIT_FAILURE;
+                }
                 continue;
+            }
+            // read ARP packet
+            if (safe_read(sock_fd, &p, sizeof(p)) < 0) {
+                bb_perror_msg_and_die(bb_msg_read_error);
+        }
+        // Packet arrived, or link went down.
+        // We need to adjust the timeout in case we didn't receive
+        // a conflicting packet.
+        if (timeout_ms > 0) {
+            unsigned diff = deadline_us - MONOTONIC_US();
+            if ((int)(diff) < 0) {
+                // Current time is greater than the expected timeout time.
+                diff = 0;
+            }
+            if (p.eth.ether_type != htons(ETHERTYPE_ARP))
+                continue;
+            VDBG("adjusting timeout\n");
+            timeout_ms = (diff / 1000) | 1; // never 0
+        }
+        if ((fds[0].revents & POLLIN) == 0) {
+            if (fds[0].revents & POLLERR) {
+                // FIXME: links routinely go down;
+                // this shouldn't necessarily exit.
+                bb_error_msg("iface %s is down", argv_intf);
+                if (state >= MONITOR) {
+                    // Only if we are in MONITOR or DEFEND
+                    run(argv, "deconfig", chosen_nip);
+                }
+                return EXIT_FAILURE;
+            }
+            continue;
+        }
+        // Read ARP packet
+        if (safe_read(sock_fd, &p, sizeof(p)) < 0) {
+            bb_perror_msg_and_die(bb_msg_read_error);
+        }
+        if (p.eth.ether_type != htons(ETHERTYPE_ARP))
+            continue;
+        if (p.arp.arp_op != htons(ARPOP_REQUEST)
+         && p.arp.arp_op != htons(ARPOP_REPLY)
+        ) {
+            continue;
+        }
 #ifdef DEBUG
+            {
+                struct ether_addr *sha = (struct ether_addr *) p.arp.arp_sha;
+                struct ether_addr *tha = (struct ether_addr *) p.arp.arp_tha;
+                struct in_addr *spa = (struct in_addr *) p.arp.arp_spa;
+                struct in_addr *tpa = (struct in_addr *) p.arp.arp_tpa;
+                VDBG("%s recv arp type=%d, op=%d,\n",
+                    argv_intf, ntohs(p.eth.ether_type),
+                    ntohs(p.arp.arp_op));
+                VDBG("\tsource=%s %s\n",
+                    ether_ntoa(sha),
+                    inet_ntoa(*spa));
+                VDBG("\ttarget=%s %s\n",
+                    ether_ntoa(tha),
+                    inet_ntoa(*tpa));
+            }
+        {
+            struct ether_addr *sha = (struct ether_addr *) p.arp.arp_sha;
+            struct ether_addr *tha = (struct ether_addr *) p.arp.arp_tha;
+            struct in_addr *spa = (struct in_addr *) p.arp.arp_spa;
+            struct in_addr *tpa = (struct in_addr *) p.arp.arp_tpa;
+            VDBG("source=%s %s\n", ether_ntoa(sha), inet_ntoa(*spa));
+            VDBG("target=%s %s\n", ether_ntoa(tha), inet_ntoa(*tpa));
+        }
 #endif
+            if (p.arp.arp_op != htons(ARPOP_REQUEST)
+             && 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;
+        ip_conflict = 0;
+        if (memcmp(&p.arp.arp_sha, &G.our_ethaddr, ETH_ALEN) != 0) {
+            if (memcmp(p.arp.arp_spa, &chosen_nip, 4) == 0) {
+                // A probe or reply with source_ip == chosen ip
+                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
+             && memcmp(p.arp.arp_spa, &const_int_0, 4) == 0
+             && memcmp(p.arp.arp_tpa, &chosen_nip, 4) == 0
             ) {
+                target_ip_conflict = 1;
+                // A probe with source_ip == 0.0.0.0, target_ip == chosen ip:
+                // another host trying to claim this ip!
+                ip_conflict |= 2;
+            }
+            VDBG("state = %d, source ip conflict = %d, target ip conflict = %d\n",
+                state, source_ip_conflict, target_ip_conflict);
+            switch (state) {
+            case PROBE:
+            case ANNOUNCE:
+                // When probing or announcing, check for source IP conflicts
+                // and other hosts doing ARP probes (target IP conflicts).
+                if (source_ip_conflict || target_ip_conflict) {
+                    conflicts++;
+                    if (conflicts >= MAX_CONFLICTS) {
+                        VDBG("%s ratelimit\n", argv_intf);
+                        timeout_ms = RATE_LIMIT_INTERVAL * 1000;
+                        state = RATE_LIMIT_PROBE;
+                    }
+                    // restart the whole protocol
+                    ip.s_addr = pick();
+                    timeout_ms = 0;
+                    nprobes = 0;
+                    nclaims = 0;
+                }
+                break;
+            case MONITOR:
+                // If a conflict, we try to defend with a single ARP probe.
+                if (source_ip_conflict) {
+                    VDBG("monitor conflict -- defending\n");
+                    state = DEFEND;
+                    timeout_ms = DEFEND_INTERVAL * 1000;
+                    arp(/* ARPOP_REQUEST, */
+                        /* &eth_addr, */ ip,
+                        &eth_addr, ip);
+                }
+                break;
+            case DEFEND:
+                // Well, we tried.  Start over (on conflict).
+                if (source_ip_conflict) {
+                    state = PROBE;
+                    VDBG("defend conflict -- starting over\n");
+                    ready = 0;
+                    run(argv, "deconfig", &ip);
+                    // restart the whole protocol
+                    ip.s_addr = pick();
+                    timeout_ms = 0;
+                    nprobes = 0;
+                    nclaims = 0;
+                }
+                break;
+            default:
+                // Invalid, should never happen.  Restart the whole protocol.
+                VDBG("invalid state -- starting over\n");
+                state = PROBE;
+                ip.s_addr = pick();
+                timeout_ms = 0;
+                nprobes = 0;
+                nclaims = 0;
+                break;
+            } // switch state
+            break; // case 1 (packets arriving)
+        } // switch poll
+        }
+        VDBG("state:%d ip_conflict:%d\n", state, ip_conflict);
+        if (!ip_conflict)
+            continue;
+        // Either src or target IP conflict exists
+        if (state <= ANNOUNCE) {
+            // PROBE or ANNOUNCE
+            conflicts++;
+            timeout_ms = PROBE_MIN * 1000
+                + CONFLICT_MULTIPLIER * random_delay_ms(conflicts);
+            goto new_nip_and_PROBE;
+        }
+        // MONITOR or DEFEND: only src IP conflict is a problem
+        if (ip_conflict & 1) {
+            if (state == MONITOR) {
+                // Src IP conflict, defend with a single ARP probe
+                VDBG("monitor conflict - defending\n");
+                timeout_ms = DEFEND_INTERVAL * 1000;
+                state = DEFEND;
+                send_arp_request(chosen_nip, &G.our_ethaddr, chosen_nip);
+                continue;
+            }
+            // state == DEFEND
+            // Another src IP conflict, start over
+            VDBG("defend conflict - starting over\n");
+            run(argv, "deconfig", chosen_nip);
+            conflicts = 0;
+            timeout_ms = 0;
+            goto new_nip_and_PROBE;
+        }
+        // Note: if we only have a target IP conflict here (ip_conflict & 2),
+        // IOW: if we just saw this sort of ARP packet:
+        //  aa:bb:cc:dd:ee:ff > xx:xx:xx:xx:xx:xx arp who-has <chosen_nip> tell 0.0.0.0
+        // we expect _kernel_ to respond to that, because <chosen_nip>
+        // is (expected to be) configured on this iface.
     } // while (1)
 #undef argv_intf

Context Navigation

Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/networking

Legend:

Download in other formats: