Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/networking/zcip.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/networking/zcip.c (modified) (35 diffs)

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

@@ -7 +7 @@
  * Copyright (C) 2004 by David Brownell
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -24 +24 @@
 // - link status monitoring (restart on link-up; stop on link-down)
 
-#include <syslog.h>
-#include <poll.h>
-#include <sys/wait.h>
 #include <netinet/ether.h>
 #include <net/ethernet.h>
@@ -35 +32 @@
 
 #include "libbb.h"
+#include <syslog.h>
 
 /* We don't need more than 32 bits of the counter */
@@ -40 +38 @@
 
 struct arp_packet {
-    struct ether_header hdr;
+    struct ether_header eth;
     struct ether_arp arp;
-} ATTRIBUTE_PACKED;
+} PACKED;
 
 enum {
@@ -70 +68 @@
 };
 
-#define VDBG(fmt,args...) \
-    do { } while (0)
+#define VDBG(...) do { } while (0)
+
+
+enum {
+    sock_fd = 3
+};
+
+struct globals {
+    struct sockaddr saddr;
+    struct ether_addr eth_addr;
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define saddr    (G.saddr   )
+#define eth_addr (G.eth_addr)
+
 
 /**
@@ -77 +88 @@
  * the first and last 256 addresses are reserved.
  */
-static void pick(struct in_addr *ip)
+static uint32_t pick(void)
 {
     unsigned tmp;
@@ -84 +95 @@
         tmp = rand() & IN_CLASSB_HOST;
     } while (tmp > (IN_CLASSB_HOST - 0x0200));
-    ip->s_addr = htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
+    return htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
 }
 
@@ -90 +101 @@
  * Broadcast an ARP packet.
  */
-static void arp(int fd, struct sockaddr *saddr, int op,
-    const struct ether_addr *source_addr, struct in_addr source_ip,
-    const struct ether_addr *target_addr, struct in_addr target_ip)
+static void arp(
+    /* 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)
 {
+    enum { op = ARPOP_REQUEST };
+#define source_eth (&eth_addr)
+
     struct arp_packet p;
     memset(&p, 0, sizeof(p));
 
     // ether header
-    p.hdr.ether_type = htons(ETHERTYPE_ARP);
-    memcpy(p.hdr.ether_shost, source_addr, ETH_ALEN);
-    memset(p.hdr.ether_dhost, 0xff, ETH_ALEN);
+    p.eth.ether_type = htons(ETHERTYPE_ARP);
+    memcpy(p.eth.ether_shost, source_eth, ETH_ALEN);
+    memset(p.eth.ether_dhost, 0xff, ETH_ALEN);
 
     // arp request
@@ -108 +124 @@
     p.arp.arp_pln = 4;
     p.arp.arp_op = htons(op);
-    memcpy(&p.arp.arp_sha, source_addr, ETH_ALEN);
+    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_tha, target_addr, ETH_ALEN);
+    memcpy(&p.arp.arp_tha, target_eth, ETH_ALEN);
     memcpy(&p.arp.arp_tpa, &target_ip, sizeof(p.arp.arp_tpa));
 
     // send it
-    xsendto(fd, &p, sizeof(p), saddr, sizeof(*saddr));
-
-    // Currently all callers ignore errors, that's why returns are
-    // commented out...
-    //return 0;
+    // Even though sock_fd is already bound to saddr, 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
+    // (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));
+#undef source_eth
 }
 
 /**
- * Run a script. argv[2] is already NULL.
- */
-static int run(char *argv[3], const char *intf, struct in_addr *ip)
+ * Run a script.
+ * 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)
 {
     int status;
-
-    VDBG("%s run %s %s\n", intf, argv[0], argv[1]);
+    char *addr = addr; /* for gcc */
+    const char *fmt = "%s %s %s" + 3;
+
+    argv[2] = (char*)param;
+
+    VDBG("%s run %s %s\n", argv[0], argv[1], argv[2]);
 
     if (ip) {
-        char *addr = inet_ntoa(*ip);
-        setenv("ip", addr, 1);
-        bb_info_msg("%s %s %s", argv[1], intf, addr);
+        addr = inet_ntoa(*ip);
+        xsetenv("ip", addr);
+        fmt -= 3;
     }
-
-    status = wait4pid(spawn(argv));
+    bb_info_msg(fmt, argv[2], argv[0], addr);
+
+    status = spawn_and_wait(argv + 1);
     if (status < 0) {
-        bb_perror_msg("%s %s", argv[1], intf);
+        bb_perror_msg("%s %s %s" + 3, argv[2], argv[0]);
         return -errno;
     }
     if (status != 0)
-        bb_error_msg("script %s %s failed, exitcode=%d", argv[0], argv[1], status);
+        bb_error_msg("script %s %s failed, exitcode=%d", argv[1], argv[2], status & 0xff);
     return status;
 }
@@ -149 +174 @@
  * Return milliseconds of random delay, up to "secs" seconds.
  */
-static unsigned ALWAYS_INLINE ms_rdelay(unsigned secs)
+static ALWAYS_INLINE unsigned random_delay_ms(unsigned secs)
 {
     return rand() % (secs * 1000);
@@ -157 +182 @@
  * main program
  */
-int zcip_main(int argc, char **argv);
-int zcip_main(int argc, char **argv)
+int zcip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int zcip_main(int argc UNUSED_PARAM, char **argv)
 {
-    int state = PROBE;
-    struct ether_addr eth_addr;
-    const char *why;
-    int fd;
+    int state;
     char *r_opt;
     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 sockaddr saddr;
         struct in_addr ip;
         struct ifreq ifr;
-        char *intf;
-        char *script_av[3];
         int timeout_ms; /* must be signed */
         unsigned conflicts;
@@ -185 +204 @@
 #define null_ip    (L.null_ip   )
 #define null_addr  (L.null_addr )
-#define saddr      (L.saddr     )
 #define ip         (L.ip        )
 #define ifr        (L.ifr       )
-#define intf       (L.intf      )
-#define script_av  (L.script_av )
 #define timeout_ms (L.timeout_ms)
 #define conflicts  (L.conflicts )
@@ -205 +221 @@
     opt_complementary = "=2:vv:vf";
     opts = getopt32(argv, "fqr:v", &r_opt, &verbose);
+#if !BB_MMU
+    // on NOMMU reexec early (or else we will rerun things twice)
+    if (!FOREGROUND)
+        bb_daemonize_or_rexec(0 /*was: DAEMON_CHDIR_ROOT*/, argv);
+#endif
+    // open an ARP socket
+    // (need to do it before openlog to prevent openlog from taking
+    // fd 3 (sock_fd==3))
+    xmove_fd(xsocket(AF_PACKET, SOCK_PACKET, htons(ETH_P_ARP)), sock_fd);
     if (!FOREGROUND) {
-        /* Do it early, before all bb_xx_msg calls */
+        // do it before all bb_xx_msg calls
         openlog(applet_name, 0, LOG_DAEMON);
         logmode |= LOGMODE_SYSLOG;
@@ -217 +242 @@
         }
     }
-    // On NOMMU reexec early (or else we will rerun things twice)
-#if !BB_MMU
-    if (!FOREGROUND)
-        bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
-#endif
-    argc -= optind;
-    argv += optind;
-
-    intf = argv[0];
-    script_av[0] = argv[1];
-    setenv("interface", intf, 1);
+    argv += optind - 1;
+
+    /* Now: argv[0]:junk argv[1]:intf argv[2]:script argv[3]:NULL */
+    /* We need to make space for script argument: */
+    argv[0] = argv[1];
+    argv[1] = argv[2];
+    /* Now: argv[0]:intf argv[1]:script argv[2]:junk argv[3]:NULL */
+#define argv_intf (argv[0])
+
+    xsetenv("interface", argv_intf);
 
     // initialize the interface (modprobe, ifup, etc)
-    script_av[1] = (char*)"init";
-    if (run(script_av, intf, NULL))
+    if (run(argv, "init", NULL))
         return EXIT_FAILURE;
 
     // initialize saddr
+    // saddr is: { u16 sa_family; u8 sa_data[14]; }
     //memset(&saddr, 0, sizeof(saddr));
-    safe_strncpy(saddr.sa_data, intf, sizeof(saddr.sa_data));
-
-    // open an ARP socket
-    fd = xsocket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
+    //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(fd, &saddr, sizeof(saddr));
+    xbind(sock_fd, &saddr, sizeof(saddr));
 
     // get the interface's ethernet address
     //memset(&ifr, 0, sizeof(ifr));
-    strncpy(ifr.ifr_name, intf, sizeof(ifr.ifr_name));
-    xioctl(fd, SIOCGIFHWADDR, &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
     // the hardware address or else the last address we used.
+    // we are taking low-order four bytes, as top-order ones
+    // aren't random enough.
     // NOTE: the sequence of addresses we try changes only
     // depending on when we detect conflicts.
-    srand(*(unsigned*)&ifr.ifr_hwaddr.sa_data);
+    {
+        uint32_t t;
+        move_from_unaligned32(t, ((char *)&eth_addr + 2));
+        srand(t);
+    }
     if (ip.s_addr == 0)
-        pick(&ip);
+        ip.s_addr = pick();
 
     // FIXME cases to handle:
@@ -264 +293 @@
     if (!FOREGROUND) {
 #if BB_MMU
-        bb_daemonize(DAEMON_CHDIR_ROOT);
+        bb_daemonize(0 /*was: DAEMON_CHDIR_ROOT*/);
 #endif
-        bb_info_msg("start, interface %s", intf);
+        bb_info_msg("start, interface %s", argv_intf);
     }
 
@@ -273 +302 @@
     //  - start with some address we want to try
     //  - short random delay
-    //  - arp probes to see if another host else uses it
+    //  - arp probes to see if another host uses it
     //  - arp announcements that we're claiming it
     //  - use it
     //  - defend it, within limits
+    // exit if:
+    // - address is successfully obtained and -q was given:
+    //   run "<script> config", then exit with exitcode 0
+    // - poll error (when does this happen?)
+    // - read error (when does this happen?)
+    // - sendto error (in arp()) (when does this happen?)
+    // - revents & POLLERR (link down). run "<script> deconfig" first
+    state = PROBE;
     while (1) {
         struct pollfd fds[1];
         unsigned deadline_us;
         struct arp_packet p;
-
-        int source_ip_conflict = 0;
-        int target_ip_conflict = 0;
-
-        fds[0].fd = fd;
+        int source_ip_conflict;
+        int target_ip_conflict;
+
+        fds[0].fd = sock_fd;
         fds[0].events = POLLIN;
         fds[0].revents = 0;
@@ -291 +327 @@
         // poll, being ready to adjust current timeout
         if (!timeout_ms) {
-            timeout_ms = ms_rdelay(PROBE_WAIT);
-            // FIXME setsockopt(fd, SO_ATTACH_FILTER, ...) to
+            timeout_ms = random_delay_ms(PROBE_WAIT);
+            // FIXME setsockopt(sock_fd, SO_ATTACH_FILTER, ...) to
             // make the kernel filter out all packets except
             // ones we'd care about.
@@ -300 +336 @@
 
         VDBG("...wait %d %s nprobes=%u, nclaims=%u\n",
-                timeout_ms, intf, nprobes, nclaims);
-        switch (poll(fds, 1, timeout_ms)) {
+                timeout_ms, argv_intf, nprobes, nclaims);
+
+        switch (safe_poll(fds, 1, timeout_ms)) {
+
+        default:
+            //bb_perror_msg("poll"); - done in safe_poll
+            return EXIT_FAILURE;
 
         // timeout
@@ -313 +354 @@
                     nprobes++;
                     VDBG("probe/%u %s@%s\n",
-                            nprobes, intf, inet_ntoa(ip));
-                    arp(fd, &saddr, ARPOP_REQUEST,
-                            &eth_addr, null_ip,
+                            nprobes, argv_intf, inet_ntoa(ip));
+                    arp(/* ARPOP_REQUEST, */
+                            /* &eth_addr, */ null_ip,
                             &null_addr, ip);
                     timeout_ms = PROBE_MIN * 1000;
-                    timeout_ms += ms_rdelay(PROBE_MAX - PROBE_MIN);
+                    timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
                 }
                 else {
@@ -325 +366 @@
                     nclaims = 0;
                     VDBG("announce/%u %s@%s\n",
-                            nclaims, intf, inet_ntoa(ip));
-                    arp(fd, &saddr, ARPOP_REQUEST,
-                            &eth_addr, ip,
+                            nclaims, argv_intf, inet_ntoa(ip));
+                    arp(/* ARPOP_REQUEST, */
+                            /* &eth_addr, */ ip,
                             &eth_addr, ip);
                     timeout_ms = ANNOUNCE_INTERVAL * 1000;
@@ -338 +379 @@
                 nclaims = 0;
                 VDBG("announce/%u %s@%s\n",
-                        nclaims, intf, inet_ntoa(ip));
-                arp(fd, &saddr, ARPOP_REQUEST,
-                        &eth_addr, ip,
+                        nclaims, argv_intf, inet_ntoa(ip));
+                arp(/* ARPOP_REQUEST, */
+                        /* &eth_addr, */ ip,
                         &eth_addr, ip);
                 timeout_ms = ANNOUNCE_INTERVAL * 1000;
@@ -350 +391 @@
                     nclaims++;
                     VDBG("announce/%u %s@%s\n",
-                            nclaims, intf, inet_ntoa(ip));
-                    arp(fd, &saddr, ARPOP_REQUEST,
-                            &eth_addr, ip,
+                            nclaims, argv_intf, inet_ntoa(ip));
+                    arp(/* ARPOP_REQUEST, */
+                            /* &eth_addr, */ ip,
                             &eth_addr, ip);
                     timeout_ms = ANNOUNCE_INTERVAL * 1000;
@@ -361 +402 @@
                     // link is ok to use earlier
                     // FIXME update filters
-                    script_av[1] = (char*)"config";
-                    run(script_av, intf, &ip);
+                    run(argv, "config", &ip);
                     ready = 1;
                     conflicts = 0;
@@ -382 +422 @@
                 // Invalid, should never happen.  Restart the whole protocol.
                 state = PROBE;
-                pick(&ip);
+                ip.s_addr = pick();
                 timeout_ms = 0;
                 nprobes = 0;
@@ -389 +429 @@
             } // switch (state)
             break; // case 0 (timeout)
-        // packets arriving
+
+        // packets arriving, or link went down
         case 1:
             // We need to adjust the timeout in case we didn't receive
@@ -402 +443 @@
                 } else {
                     VDBG("adjusting timeout\n");
-                    timeout_ms = diff / 1000;
-                    if (!timeout_ms) timeout_ms = 1;
+                    timeout_ms = (diff / 1000) | 1; /* never 0 */
                 }
             }
@@ -411 +451 @@
                     // FIXME: links routinely go down;
                     // this shouldn't necessarily exit.
-                    bb_error_msg("%s: poll error", intf);
+                    bb_error_msg("iface %s is down", argv_intf);
                     if (ready) {
-                        script_av[1] = (char*)"deconfig";
-                        run(script_av, intf, &ip);
+                        run(argv, "deconfig", &ip);
                     }
                     return EXIT_FAILURE;
@@ -422 +461 @@
 
             // read ARP packet
-            if (recv(fd, &p, sizeof(p), 0) < 0) {
-                why = "recv";
-                goto bad;
+            if (safe_read(sock_fd, &p, sizeof(p)) < 0) {
+                bb_perror_msg_and_die(bb_msg_read_error);
             }
-            if (p.hdr.ether_type != htons(ETHERTYPE_ARP))
+            if (p.eth.ether_type != htons(ETHERTYPE_ARP))
                 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;
+                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",
-                    intf, ntohs(p.hdr.ether_type),
+                    argv_intf, ntohs(p.eth.ether_type),
                     ntohs(p.arp.arp_op));
                 VDBG("\tsource=%s %s\n",
@@ -447 +484 @@
 #endif
             if (p.arp.arp_op != htons(ARPOP_REQUEST)
-                    && p.arp.arp_op != htons(ARPOP_REPLY))
+             && p.arp.arp_op != htons(ARPOP_REPLY))
                 continue;
 
-            if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0 &&
-                memcmp(&eth_addr, &p.arp.arp_sha, ETH_ALEN) != 0) {
+            source_ip_conflict = 0;
+            target_ip_conflict = 0;
+
+            if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0
+             && memcmp(&p.arp.arp_sha, &eth_addr, ETH_ALEN) != 0
+            ) {
                 source_ip_conflict = 1;
             }
-            if (memcmp(p.arp.arp_tpa, &ip.s_addr, sizeof(struct in_addr)) == 0 &&
-                p.arp.arp_op == htons(ARPOP_REQUEST) &&
-                memcmp(&eth_addr, &p.arp.arp_tha, ETH_ALEN) != 0) {
+            if (p.arp.arp_op == htons(ARPOP_REQUEST)
+             && memcmp(p.arp.arp_tpa, &ip.s_addr, sizeof(struct in_addr)) == 0
+             && memcmp(&p.arp.arp_tha, &eth_addr, ETH_ALEN) != 0
+            ) {
                 target_ip_conflict = 1;
             }
@@ -470 +512 @@
                     conflicts++;
                     if (conflicts >= MAX_CONFLICTS) {
-                        VDBG("%s ratelimit\n", intf);
+                        VDBG("%s ratelimit\n", argv_intf);
                         timeout_ms = RATE_LIMIT_INTERVAL * 1000;
                         state = RATE_LIMIT_PROBE;
@@ -476 +518 @@
 
                     // restart the whole protocol
-                    pick(&ip);
+                    ip.s_addr = pick();
                     timeout_ms = 0;
                     nprobes = 0;
@@ -488 +530 @@
                     state = DEFEND;
                     timeout_ms = DEFEND_INTERVAL * 1000;
-                    arp(fd, &saddr,
-                            ARPOP_REQUEST,
-                            &eth_addr, ip,
-                            &eth_addr, ip);
+                    arp(/* ARPOP_REQUEST, */
+                        /* &eth_addr, */ ip,
+                        &eth_addr, ip);
                 }
                 break;
@@ -500 +541 @@
                     VDBG("defend conflict -- starting over\n");
                     ready = 0;
-                    script_av[1] = (char*)"deconfig";
-                    run(script_av, intf, &ip);
+                    run(argv, "deconfig", &ip);
 
                     // restart the whole protocol
-                    pick(&ip);
+                    ip.s_addr = pick();
                     timeout_ms = 0;
                     nprobes = 0;
@@ -514 +554 @@
                 VDBG("invalid state -- starting over\n");
                 state = PROBE;
-                pick(&ip);
+                ip.s_addr = pick();
                 timeout_ms = 0;
                 nprobes = 0;
@@ -520 +560 @@
                 break;
             } // switch state
-
             break; // case 1 (packets arriving)
-        default:
-            why = "poll";
-            goto bad;
         } // switch poll
-    }
- bad:
-    bb_perror_msg("%s, %s", intf, why);
-    return EXIT_FAILURE;
+    } // while (1)
+#undef argv_intf
 }