Changeset 1765 in MondoRescue for branches/2.2.5/mindi-busybox/networking/zcip.c

Timestamp:

Nov 4, 2007, 3:16:40 AM (17 years ago)

Author:

Bruno Cornec

Message:

Update to busybox 1.7.2

File:

• branches/2.2.5/mindi-busybox/networking/zcip.c (modified) (24 diffs)

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

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /*
  * RFC3927 ZeroConf IPv4 Link-Local addressing
@@ -23 +24 @@
 // - link status monitoring (restart on link-up; stop on link-down)
 
-#include "busybox.h"
-#include <errno.h>
-#include <string.h>
 #include <syslog.h>
 #include <poll.h>
-#include <time.h>
-
 #include <sys/wait.h>
-
 #include <netinet/ether.h>
 #include <net/ethernet.h>
 #include <net/if.h>
 #include <net/if_arp.h>
-
 #include <linux/if_packet.h>
 #include <linux/sockios.h>
 
+#include "libbb.h"
+
+/* We don't need more than 32 bits of the counter */
+#define MONOTONIC_US() ((unsigned)monotonic_us())
 
 struct arp_packet {
@@ -72 +70 @@
 };
 
-/* Implicitly zero-initialized */
-static const struct in_addr null_ip;
-static const struct ether_addr null_addr;
-static int verbose;
-
-#define DBG(fmt,args...) \
+#define VDBG(fmt,args...) \
     do { } while (0)
-#define VDBG    DBG
 
 /**
@@ -87 +79 @@
 static void pick(struct in_addr *ip)
 {
-    unsigned    tmp;
-
-    /* use cheaper math than lrand48() mod N */
+    unsigned tmp;
+
     do {
-        tmp = (lrand48() >> 16) & IN_CLASSB_HOST;
+        tmp = rand() & IN_CLASSB_HOST;
     } while (tmp > (IN_CLASSB_HOST - 0x0200));
     ip->s_addr = htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
@@ -99 +90 @@
  * Broadcast an ARP packet.
  */
-static int arp(int fd, struct sockaddr *saddr, int op,
+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)
@@ -118 +109 @@
     p.arp.arp_op = htons(op);
     memcpy(&p.arp.arp_sha, source_addr, ETH_ALEN);
-    memcpy(&p.arp.arp_spa, &source_ip, sizeof (p.arp.arp_spa));
+    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_tpa, &target_ip, sizeof (p.arp.arp_tpa));
+    memcpy(&p.arp.arp_tpa, &target_ip, sizeof(p.arp.arp_tpa));
 
     // send it
-    if (sendto(fd, &p, sizeof (p), 0, saddr, sizeof (*saddr)) < 0) {
-        perror("sendto");
+    xsendto(fd, &p, sizeof(p), saddr, sizeof(*saddr));
+
+    // Currently all callers ignore errors, that's why returns are
+    // commented out...
+    //return 0;
+}
+
+/**
+ * Run a script. argv[2] is already NULL.
+ */
+static int run(char *argv[3], const char *intf, struct in_addr *ip)
+{
+    int status;
+
+    VDBG("%s run %s %s\n", intf, argv[0], argv[1]);
+
+    if (ip) {
+        char *addr = inet_ntoa(*ip);
+        setenv("ip", addr, 1);
+        bb_info_msg("%s %s %s", argv[1], intf, addr);
+    }
+
+    status = wait4pid(spawn(argv));
+    if (status < 0) {
+        bb_perror_msg("%s %s", argv[1], intf);
         return -errno;
     }
-    return 0;
+    if (status != 0)
+        bb_error_msg("script %s %s failed, exitcode=%d", argv[0], argv[1], status);
+    return status;
 }
 
 /**
- * Run a script.
- */
-static int run(char *script, char *arg, char *intf, struct in_addr *ip)
+ * Return milliseconds of random delay, up to "secs" seconds.
+ */
+static unsigned ALWAYS_INLINE ms_rdelay(unsigned secs)
 {
-    int pid, status;
-    char *why;
-
-    if (script != NULL) {
-        VDBG("%s run %s %s\n", intf, script, arg);
-        if (ip != NULL) {
-            char *addr = inet_ntoa(*ip);
-            setenv("ip", addr, 1);
-            syslog(LOG_INFO, "%s %s %s", arg, intf, addr);
-        }
-
-        pid = vfork();
-        if (pid < 0) {          // error
-            why = "vfork";
-            goto bad;
-        } else if (pid == 0) {      // child
-            execl(script, script, arg, NULL);
-            perror("execl");
-            _exit(EXIT_FAILURE);
-        }
-
-        if (waitpid(pid, &status, 0) <= 0) {
-            why = "waitpid";
-            goto bad;
-        }
-        if (WEXITSTATUS(status) != 0) {
-            bb_error_msg("script %s failed, exit=%d\n",
-                    script, WEXITSTATUS(status));
-            return -errno;
+    return rand() % (secs * 1000);
+}
+
+/**
+ * main program
+ */
+int zcip_main(int argc, char **argv);
+int zcip_main(int argc, char **argv)
+{
+    int state = PROBE;
+    struct ether_addr eth_addr;
+    const char *why;
+    int fd;
+    char *r_opt;
+    unsigned opts;
+
+    /* 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;
+        unsigned nprobes;
+        unsigned nclaims;
+        int ready;
+        int verbose;
+    } L;
+#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 )
+#define nprobes    (L.nprobes   )
+#define nclaims    (L.nclaims   )
+#define ready      (L.ready     )
+#define verbose    (L.verbose   )
+
+    memset(&L, 0, sizeof(L));
+
+#define FOREGROUND (opts & 1)
+#define QUIT       (opts & 2)
+    // 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);
+    if (!FOREGROUND) {
+        /* Do it early, before all bb_xx_msg calls */
+        openlog(applet_name, 0, LOG_DAEMON);
+        logmode |= LOGMODE_SYSLOG;
+    }
+    if (opts & 4) { // -r n.n.n.n
+        if (inet_aton(r_opt, &ip) == 0
+         || (ntohl(ip.s_addr) & IN_CLASSB_NET) != LINKLOCAL_ADDR
+        ) {
+            bb_error_msg_and_die("invalid link address");
         }
     }
-    return 0;
-bad:
-    status = -errno;
-    syslog(LOG_ERR, "%s %s, %s error: %s",
-        arg, intf, why, strerror(errno));
-    return status;
-}
-
-
-/**
- * Return milliseconds of random delay, up to "secs" seconds.
- */
-static inline unsigned ms_rdelay(unsigned secs)
-{
-    return lrand48() % (secs * 1000);
-}
-
-/**
- * main program
- */
-
-int zcip_main(int argc, char *argv[])
-{
-    char *intf = NULL;
-    char *script = NULL;
-    int quit = 0;
-    int foreground = 0;
-
-    char *why;
-    struct sockaddr saddr;
-    struct ether_addr addr;
-    struct in_addr ip = { 0 };
-    int fd;
-    int ready = 0;
-    suseconds_t timeout = 0;    // milliseconds
-    unsigned conflicts = 0;
-    unsigned nprobes = 0;
-    unsigned nclaims = 0;
-    int t;
-    int state = PROBE;
-
-    // parse commandline: prog [options] ifname script
-    while ((t = getopt(argc, argv, "fqr:v")) != EOF) {
-        switch (t) {
-        case 'f':
-            foreground = 1;
-            continue;
-        case 'q':
-            quit = 1;
-            continue;
-        case 'r':
-            if (inet_aton(optarg, &ip) == 0
-                    || (ntohl(ip.s_addr) & IN_CLASSB_NET)
-                        != LINKLOCAL_ADDR) {
-                bb_error_msg_and_die("invalid link address");
-            }
-            continue;
-        case 'v':
-            verbose++;
-            foreground = 1;
-            continue;
-        default:
-            bb_error_msg_and_die("bad option");
-        }
-    }
-    if (optind < argc - 1) {
-        intf = argv[optind++];
-        setenv("interface", intf, 1);
-        script = argv[optind++];
-    }
-    if (optind != argc || !intf)
-        bb_show_usage();
-    openlog(bb_applet_name, 0, LOG_DAEMON);
+    // 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);
 
     // initialize the interface (modprobe, ifup, etc)
-    if (run(script, "init", intf, NULL) < 0)
+    script_av[1] = (char*)"init";
+    if (run(script_av, intf, NULL))
         return EXIT_FAILURE;
 
     // initialize saddr
-    memset(&saddr, 0, sizeof (saddr));
-    safe_strncpy(saddr.sa_data, intf, sizeof (saddr.sa_data));
+    //memset(&saddr, 0, sizeof(saddr));
+    safe_strncpy(saddr.sa_data, intf, sizeof(saddr.sa_data));
 
     // open an ARP socket
-    if ((fd = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP))) < 0) {
-        why = "open";
-fail:
-        foreground = 1;
-        goto bad;
-    }
+    fd = xsocket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
     // bind to the interface's ARP socket
-    if (bind(fd, &saddr, sizeof (saddr)) < 0) {
-        why = "bind";
-        goto fail;
-    } else {
-        struct ifreq ifr;
-        unsigned short seed[3];
-
-        // get the interface's ethernet address
-        memset(&ifr, 0, sizeof (ifr));
-        strncpy(ifr.ifr_name, intf, sizeof (ifr.ifr_name));
-        if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
-            why = "get ethernet address";
-            goto fail;
-        }
-        memcpy(&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.
-        // NOTE: the sequence of addresses we try changes only
-        // depending on when we detect conflicts.
-        memcpy(seed, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
-        seed48(seed);
-        if (ip.s_addr == 0)
-            pick(&ip);
-    }
+    xbind(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);
+    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.
+    // NOTE: the sequence of addresses we try changes only
+    // depending on when we detect conflicts.
+    srand(*(unsigned*)&ifr.ifr_hwaddr.sa_data);
+    if (ip.s_addr == 0)
+        pick(&ip);
 
     // FIXME cases to handle:
@@ -287 +262 @@
 
     // daemonize now; don't delay system startup
-    if (!foreground) {
-        if (daemon(0, verbose) < 0) {
-            why = "daemon";
-            goto bad;
-        }
-        syslog(LOG_INFO, "start, interface %s", intf);
+    if (!FOREGROUND) {
+#if BB_MMU
+        bb_daemonize(DAEMON_CHDIR_ROOT);
+#endif
+        bb_info_msg("start, interface %s", intf);
     }
 
@@ -305 +279 @@
     while (1) {
         struct pollfd fds[1];
-        struct timeval tv1;
+        unsigned deadline_us;
         struct arp_packet p;
+
+        int source_ip_conflict = 0;
+        int target_ip_conflict = 0;
 
         fds[0].fd = fd;
@@ -312 +289 @@
         fds[0].revents = 0;
 
-        int source_ip_conflict = 0;
-        int target_ip_conflict = 0;
-
         // poll, being ready to adjust current timeout
-        if (!timeout) {
-            timeout = ms_rdelay(PROBE_WAIT);
+        if (!timeout_ms) {
+            timeout_ms = ms_rdelay(PROBE_WAIT);
             // FIXME setsockopt(fd, SO_ATTACH_FILTER, ...) to
             // make the kernel filter out all packets except
             // ones we'd care about.
         }
-        // set tv1 to the point in time when we timeout
-        gettimeofday(&tv1, NULL);
-        tv1.tv_usec += (timeout % 1000) * 1000;
-        while (tv1.tv_usec > 1000000) {
-            tv1.tv_usec -= 1000000;
-            tv1.tv_sec++;
-        }
-        tv1.tv_sec += timeout / 1000;
-    
-        VDBG("...wait %ld %s nprobes=%d, nclaims=%d\n",
-                timeout, intf, nprobes, nclaims);
-        switch (poll(fds, 1, timeout)) {
+        // 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, intf, nprobes, nclaims);
+        switch (poll(fds, 1, timeout_ms)) {
 
         // timeout
@@ -340 +308 @@
             switch (state) {
             case PROBE:
-                // timeouts in the PROBE state means no conflicting ARP packets
+                // 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++;
-                    VDBG("probe/%d %s@%s\n",
+                    VDBG("probe/%u %s@%s\n",
                             nprobes, intf, inet_ntoa(ip));
-                    (void)arp(fd, &saddr, ARPOP_REQUEST,
-                            &addr, null_ip,
+                    arp(fd, &saddr, ARPOP_REQUEST,
+                            &eth_addr, null_ip,
                             &null_addr, ip);
-                    timeout = PROBE_MIN * 1000;
-                    timeout += ms_rdelay(PROBE_MAX
-                            - PROBE_MIN);
+                    timeout_ms = PROBE_MIN * 1000;
+                    timeout_ms += ms_rdelay(PROBE_MAX - PROBE_MIN);
                 }
                 else {
@@ -357 +324 @@
                     state = ANNOUNCE;
                     nclaims = 0;
-                    VDBG("announce/%d %s@%s\n",
+                    VDBG("announce/%u %s@%s\n",
                             nclaims, intf, inet_ntoa(ip));
-                    (void)arp(fd, &saddr, ARPOP_REQUEST,
-                            &addr, ip,
-                            &addr, ip);
-                    timeout = ANNOUNCE_INTERVAL * 1000;
+                    arp(fd, &saddr, ARPOP_REQUEST,
+                            &eth_addr, ip,
+                            &eth_addr, ip);
+                    timeout_ms = ANNOUNCE_INTERVAL * 1000;
                 }
                 break;
             case RATE_LIMIT_PROBE:
-                // timeouts in the RATE_LIMIT_PROBE state means no conflicting ARP packets
+                // 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/%d %s@%s\n",
+                VDBG("announce/%u %s@%s\n",
                         nclaims, intf, inet_ntoa(ip));
-                (void)arp(fd, &saddr, ARPOP_REQUEST,
-                        &addr, ip,
-                        &addr, ip);
-                timeout = ANNOUNCE_INTERVAL * 1000;
+                arp(fd, &saddr, ARPOP_REQUEST,
+                        &eth_addr, ip,
+                        &eth_addr, ip);
+                timeout_ms = ANNOUNCE_INTERVAL * 1000;
                 break;
             case ANNOUNCE:
-                // timeouts in the ANNOUNCE state means no conflicting ARP packets
+                // 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/%d %s@%s\n",
+                    VDBG("announce/%u %s@%s\n",
                             nclaims, intf, inet_ntoa(ip));
-                    (void)arp(fd, &saddr, ARPOP_REQUEST,
-                            &addr, ip,
-                            &addr, ip);
-                    timeout = ANNOUNCE_INTERVAL * 1000;
+                    arp(fd, &saddr, ARPOP_REQUEST,
+                            &eth_addr, ip,
+                            &eth_addr, ip);
+                    timeout_ms = ANNOUNCE_INTERVAL * 1000;
                 }
                 else {
@@ -394 +361 @@
                     // link is ok to use earlier
                     // FIXME update filters
-                    run(script, "config", intf, &ip);
+                    script_av[1] = (char*)"config";
+                    run(script_av, intf, &ip);
                     ready = 1;
                     conflicts = 0;
-                    timeout = -1; // Never timeout in the monitor state.
-
-                    // NOTE:  all other exit paths
+                    timeout_ms = -1; // Never timeout in the monitor state.
+
+                    // NOTE: all other exit paths
                     // should deconfig ...
-                    if (quit)
+                    if (QUIT)
                         return EXIT_SUCCESS;
                 }
@@ -408 +376 @@
                 // We won!  No ARP replies, so just go back to monitor.
                 state = MONITOR;
-                timeout = -1;
+                timeout_ms = -1;
                 conflicts = 0;
                 break;
@@ -415 +383 @@
                 state = PROBE;
                 pick(&ip);
-                timeout = 0;
+                timeout_ms = 0;
                 nprobes = 0;
                 nclaims = 0;
@@ -425 +393 @@
             // We need to adjust the timeout in case we didn't receive
             // a conflicting packet.
-            if (timeout > 0) {
-                struct timeval tv2;
-
-                gettimeofday(&tv2, NULL);
-                if (timercmp(&tv1, &tv2, <)) {
+            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 = 0;
+                    timeout_ms = 0;
                 } else {
                     VDBG("adjusting timeout\n");
-                    timersub(&tv1, &tv2, &tv1);
-                    timeout = 1000 * tv1.tv_sec
-                            + tv1.tv_usec / 1000;
+                    timeout_ms = diff / 1000;
+                    if (!timeout_ms) timeout_ms = 1;
                 }
             }
@@ -446 +411 @@
                     // FIXME: links routinely go down;
                     // this shouldn't necessarily exit.
-                    bb_error_msg("%s: poll error\n", intf);
+                    bb_error_msg("%s: poll error", intf);
                     if (ready) {
-                        run(script, "deconfig",
-                                intf, &ip);
+                        script_av[1] = (char*)"deconfig";
+                        run(script_av, intf, &ip);
                     }
                     return EXIT_FAILURE;
@@ -457 +422 @@
 
             // read ARP packet
-            if (recv(fd, &p, sizeof (p), 0) < 0) {
+            if (recv(fd, &p, sizeof(p), 0) < 0) {
                 why = "recv";
                 goto bad;
@@ -486 +451 @@
 
             if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0 &&
-                memcmp(&addr, &p.arp.arp_sha, ETH_ALEN) != 0) {
+                memcmp(&eth_addr, &p.arp.arp_sha, 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(&addr, &p.arp.arp_tha, ETH_ALEN) != 0) {
+                memcmp(&eth_addr, &p.arp.arp_tha, ETH_ALEN) != 0) {
                 target_ip_conflict = 1;
             }
 
-            VDBG("state = %d, source ip conflict = %d, target ip conflict = %d\n", 
+            VDBG("state = %d, source ip conflict = %d, target ip conflict = %d\n",
                 state, source_ip_conflict, target_ip_conflict);
             switch (state) {
@@ -506 +471 @@
                     if (conflicts >= MAX_CONFLICTS) {
                         VDBG("%s ratelimit\n", intf);
-                        timeout = RATE_LIMIT_INTERVAL * 1000;
+                        timeout_ms = RATE_LIMIT_INTERVAL * 1000;
                         state = RATE_LIMIT_PROBE;
                     }
@@ -512 +477 @@
                     // restart the whole protocol
                     pick(&ip);
-                    timeout = 0;
+                    timeout_ms = 0;
                     nprobes = 0;
                     nclaims = 0;
@@ -522 +487 @@
                     VDBG("monitor conflict -- defending\n");
                     state = DEFEND;
-                    timeout = DEFEND_INTERVAL * 1000;
-                    (void)arp(fd, &saddr,
+                    timeout_ms = DEFEND_INTERVAL * 1000;
+                    arp(fd, &saddr,
                             ARPOP_REQUEST,
-                            &addr, ip,
-                            &addr, ip);
+                            &eth_addr, ip,
+                            &eth_addr, ip);
                 }
                 break;
@@ -535 +500 @@
                     VDBG("defend conflict -- starting over\n");
                     ready = 0;
-                    run(script, "deconfig", intf, &ip);
+                    script_av[1] = (char*)"deconfig";
+                    run(script_av, intf, &ip);
 
                     // restart the whole protocol
                     pick(&ip);
-                    timeout = 0;
+                    timeout_ms = 0;
                     nprobes = 0;
                     nclaims = 0;
@@ -549 +515 @@
                 state = PROBE;
                 pick(&ip);
-                timeout = 0;
+                timeout_ms = 0;
                 nprobes = 0;
                 nclaims = 0;
@@ -561 +527 @@
         } // switch poll
     }
-bad:
-    if (foreground)
-        perror(why);
-    else
-        syslog(LOG_ERR, "%s %s, %s error: %s",
-            bb_applet_name, intf, why, strerror(errno));
+ bad:
+    bb_perror_msg("%s, %s", intf, why);
     return EXIT_FAILURE;
 }