Changeset 902 in MondoRescue for branches/stable/mindi-busybox/networking

Timestamp:

Oct 25, 2006, 12:41:23 AM (17 years ago)

Author:

Bruno Cornec

Message:

mindi-busybox now uses busybox 1.2.2 (Thanks Rob for that last update and good lucck for your future projects).

Location:

branches/stable/mindi-busybox/networking

Files:

• dnsd.c (modified) (7 diffs)
• httpd.c (modified) (2 diffs)
• ping6.c (modified) (1 diff)
• traceroute.c (modified) (1 diff)
• zcip.c (modified) (15 diffs)

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

@@ -29 +29 @@
 #define LOCK_FILE       "/var/run/dnsd.lock"
 #define LOG_FILE        "/var/log/dnsd.log"
+
+#define is_daemon()  (flags&16)
+#define is_verbose() (flags&32)
+//#define DEBUG 
+
 
 enum {
@@ -224 +229 @@
 {
     int i;
-    struct dns_entry *d=dnsentry;
-
-    do {
+    struct dns_entry *d = dnsentry;
+
+    if(d) do {
 #ifdef DEBUG
-        char *p,*q;
-        q = (char *)&(qs[1]);
-        p = &(d->name[1]);
-        fprintf(stderr, "\ntest: %d <%s> <%s> %d", strlen(p), p, q, strlen(q));
-#endif
-        if (type == REQ_A) { /* search by host name */
+        if(qs && d) {
+            char *p,*q;
+            q = (char *)&(qs[1]);
+            p = &(d->name[1]);
+            fprintf(stderr, "\n%s: %d/%d p:%s q:%s %d", 
+                __FUNCTION__, strlen(p), (int)(d->name[0]), 
+                p, q, strlen(q));
+        }
+#endif
+        if (type == REQ_A) {            /* search by host name */
             for(i = 1; i <= (int)(d->name[0]); i++)
                 if(tolower(qs[i]) != d->name[i])
-                    continue;
+                    break;
+            if(i > (int)(d->name[0])) {
 #ifdef DEBUG
-            fprintf(stderr, " OK");
-#endif
-            strcpy((char *)as, d->ip);
+                fprintf(stderr, " OK");
+#endif
+                strcpy((char *)as, d->ip);
 #ifdef DEBUG
-            fprintf(stderr, " %s ", as);
-#endif
-                    return 0;
-                }
-        else if (type == REQ_PTR) { /* search by IP-address */
+                fprintf(stderr, " as:%s\n", as);
+#endif
+                return 0;
+            }
+        } else 
+        if (type == REQ_PTR) {          /* search by IP-address */
             if (!strncmp((char*)&d->rip[1], (char*)&qs[1], strlen(d->rip)-1)) {
                 strcpy((char *)as, d->name);
@@ -282 +293 @@
 
     from = (void *)&head[1];    //  start of query string
-    next = answb = from + strlen((char *)&head[1]) + 1 + sizeof(struct dns_prop);   // where to append answer block
+    next = answb = from + strlen((char *)from) + 1 + sizeof(struct dns_prop);   // where to append answer block
 
     outr.rlen = 0;          // may change later
@@ -306 +317 @@
 
     // We have a standard query
-
-    log_message(LOG_FILE, (char *)head);
-    lookup_result = table_lookup(type, answstr, (uint8_t*)(&head[1]));
+    log_message(LOG_FILE, (char *)from);
+    lookup_result = table_lookup(type, answstr, (uint8_t*)from);
     if (lookup_result != 0) {
         outr.flags = 3 | 0x0400;    //name do not exist and auth
@@ -342 +352 @@
     next += outr.rlen;
 
-      empty_packet:
-
+empty_packet:
     flags = ntohs(head->flags);
     // clear rcode and RA, set responsebit and our new flags
@@ -365 +374 @@
 }
 
-#define is_daemon()  (flags&16)
-#define is_verbose() (flags&32)
-//#define DEBUG 1
 
 int dnsd_main(int argc, char **argv)
@@ -438 +444 @@
                      (void *)&fromlen);
             if(is_verbose())
-                fprintf(stderr, "\n--- Got UDP  ");
-            log_message(LOG_FILE, "\n--- Got UDP  ");
+                fprintf(stderr, "\n--- Got UDP size=%d ", r);
+            log_message(LOG_FILE, "\n--- Got UDP ");
 
             if (r < 12 || r > 512) {

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

@@ -864 +864 @@
   struct sockaddr_in lsocket;
   int fd;
+  int on = 1;
 
   /* create the socket right now */
@@ -874 +875 @@
   /* tell the OS it's OK to reuse a previous address even though */
   /* it may still be in a close down state.  Allows bind to succeed. */
-  int on = 1;
 #ifdef SO_REUSEPORT
   setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (void *)&on, sizeof(on)) ;

branches/stable/mindi-busybox/networking/ping6.c

@@ -211 +211 @@
     pkt->icmp6_code = 0;
     pkt->icmp6_cksum = 0;
-    pkt->icmp6_seq = ntransmitted++;
+    pkt->icmp6_seq = SWAP_BE16(ntransmitted++);
     pkt->icmp6_id = myid;
     CLR(pkt->icmp6_seq % MAX_DUP_CHK);

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

@@ -1004 +1004 @@
         port = (u_short)str2val(port_str, "port", 1, (1 << 16) - 1);
     if(nprobes_str)
-        nprobes = str2val(optarg, "nprobes", 1, -1);
+        nprobes = str2val(nprobes_str, "nprobes", 1, -1);
     if(source) {
         /*

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

@@ -15 +15 @@
  */
 
-// #define      DEBUG
+//#define DEBUG
 
 // TODO:
@@ -43 +43 @@
 struct arp_packet {
     struct ether_header hdr;
-    // FIXME this part is netinet/if_ether.h "struct ether_arp"
-    struct arphdr arp;
-    struct ether_addr source_addr;
-    struct in_addr source_ip;
-    struct ether_addr target_addr;
-    struct in_addr target_ip;
+    struct ether_arp arp;
 } ATTRIBUTE_PACKED;
 
@@ -68 +63 @@
 };
 
-static const struct in_addr null_ip = { 0 };
-static const struct ether_addr null_addr = { {0, 0, 0, 0, 0, 0} };
-
-static int verbose = 0;
+/* States during the configuration process. */
+enum {
+    PROBE = 0,
+    RATE_LIMIT_PROBE,
+    ANNOUNCE,
+    MONITOR,
+    DEFEND
+};
+
+/* Implicitly zero-initialized */
+static const struct in_addr null_ip;
+static const struct ether_addr null_addr;
+static int verbose;
 
 #define DBG(fmt,args...) \
@@ -100 +104 @@
 {
     struct arp_packet p;
+    memset(&p, 0, sizeof(p));
 
     // ether header
@@ -107 +112 @@
 
     // arp request
-    p.arp.ar_hrd = htons(ARPHRD_ETHER);
-    p.arp.ar_pro = htons(ETHERTYPE_IP);
-    p.arp.ar_hln = ETH_ALEN;
-    p.arp.ar_pln = 4;
-    p.arp.ar_op = htons(op);
-    memcpy(&p.source_addr, source_addr, ETH_ALEN);
-    memcpy(&p.source_ip, &source_ip, sizeof (p.source_ip));
-    memcpy(&p.target_addr, target_addr, ETH_ALEN);
-    memcpy(&p.target_ip, &target_ip, sizeof (p.target_ip));
+    p.arp.arp_hrd = htons(ARPHRD_ETHER);
+    p.arp.arp_pro = htons(ETHERTYPE_IP);
+    p.arp.arp_hln = ETH_ALEN;
+    p.arp.arp_pln = 4;
+    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_tha, target_addr, ETH_ALEN);
+    memcpy(&p.arp.arp_tpa, &target_ip, sizeof (p.arp.arp_tpa));
 
     // send it
@@ -196 +201 @@
     int ready = 0;
     suseconds_t timeout = 0;    // milliseconds
-    time_t defend = 0;
     unsigned conflicts = 0;
     unsigned nprobes = 0;
     unsigned nclaims = 0;
     int t;
+    int state = PROBE;
 
     // parse commandline: prog [options] ifname script
@@ -307 +312 @@
         fds[0].revents = 0;
 
+        int source_ip_conflict = 0;
+        int target_ip_conflict = 0;
+
         // poll, being ready to adjust current timeout
         if (!timeout) {
@@ -314 +322 @@
             // ones we'd care about.
         }
+        // set tv1 to the point in time when we timeout
         gettimeofday(&tv1, NULL);
         tv1.tv_usec += (timeout % 1000) * 1000;
@@ -326 +335 @@
         switch (poll(fds, 1, timeout)) {
 
-        // timeouts trigger protocol transitions
+        // timeout
         case 0:
-            // probes
-            if (nprobes < PROBE_NUM) {
-                nprobes++;
-                VDBG("probe/%d %s@%s\n",
-                        nprobes, intf, inet_ntoa(ip));
-                (void)arp(fd, &saddr, ARPOP_REQUEST,
-                        &addr, null_ip,
-                        &null_addr, ip);
+            VDBG("state = %d\n", state);
+            switch (state) {
+            case PROBE:
+                // timeouts in the PROBE state means 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",
+                            nprobes, intf, inet_ntoa(ip));
+                    (void)arp(fd, &saddr, ARPOP_REQUEST,
+                            &addr, null_ip,
+                            &null_addr, ip);
                     timeout = PROBE_MIN * 1000;
                     timeout += ms_rdelay(PROBE_MAX
                             - PROBE_MIN);
-                } else
-                    timeout = ANNOUNCE_WAIT * 1000;
-            }
-            // then announcements
-            else if (nclaims < ANNOUNCE_NUM) {
-                nclaims++;
+                }
+                else {
+                    // Switch to announce state.
+                    state = ANNOUNCE;
+                    nclaims = 0;
+                    VDBG("announce/%d %s@%s\n",
+                            nclaims, intf, inet_ntoa(ip));
+                    (void)arp(fd, &saddr, ARPOP_REQUEST,
+                            &addr, ip,
+                            &addr, ip);
+                    timeout = ANNOUNCE_INTERVAL * 1000;
+                }
+                break;
+            case RATE_LIMIT_PROBE:
+                // timeouts in the RATE_LIMIT_PROBE state means 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",
                         nclaims, intf, inet_ntoa(ip));
@@ -351 +375 @@
                         &addr, ip,
                         &addr, ip);
+                timeout = ANNOUNCE_INTERVAL * 1000;
+                break;
+            case ANNOUNCE:
+                // timeouts in the ANNOUNCE state means 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",
+                            nclaims, intf, inet_ntoa(ip));
+                    (void)arp(fd, &saddr, ARPOP_REQUEST,
+                            &addr, ip,
+                            &addr, ip);
                     timeout = ANNOUNCE_INTERVAL * 1000;
-                } else {
+                }
+                else {
+                    // Switch to monitor state.
+                    state = MONITOR;
                     // link is ok to use earlier
+                    // FIXME update filters
                     run(script, "config", intf, &ip);
                     ready = 1;
                     conflicts = 0;
-                    timeout = -1;
+                    timeout = -1; // Never timeout in the monitor state.
 
                     // NOTE:  all other exit paths
@@ -364 +403 @@
                     if (quit)
                         return EXIT_SUCCESS;
-                    // FIXME update filters
-                }
-            }
-            break;
-
+                }
+                break;
+            case DEFEND:
+                // We won!  No ARP replies, so just go back to monitor.
+                state = MONITOR;
+                timeout = -1;
+                conflicts = 0;
+                break;
+            default:
+                // Invalid, should never happen.  Restart the whole protocol.
+                state = PROBE;
+                pick(&ip);
+                timeout = 0;
+                nprobes = 0;
+                nclaims = 0;
+                break;
+            } // switch (state)
+            break; // case 0 (timeout)
         // packets arriving
         case 1:
-            // maybe adjust timeout
+            // We need to adjust the timeout in case we didn't receive
+            // a conflicting packet.
             if (timeout > 0) {
                 struct timeval tv2;
@@ -377 +430 @@
                 gettimeofday(&tv2, NULL);
                 if (timercmp(&tv1, &tv2, <)) {
+                    // Current time is greater than the expected timeout time.
+                    // Should never happen.
+                    VDBG("missed an expected timeout\n");
                     timeout = 0;
                 } else {
+                    VDBG("adjusting timeout\n");
                     timersub(&tv1, &tv2, &tv1);
                     timeout = 1000 * tv1.tv_sec
@@ -384 +441 @@
                 }
             }
+
             if ((fds[0].revents & POLLIN) == 0) {
                 if (fds[0].revents & POLLERR) {
@@ -397 +455 @@
                 continue;
             }
+
             // read ARP packet
             if (recv(fd, &p, sizeof (p), 0) < 0) {
@@ -405 +464 @@
                 continue;
 
-            VDBG("%s recv arp type=%d, op=%d,\n",
+#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",
                     intf, ntohs(p.hdr.ether_type),
-                    ntohs(p.arp.ar_op));
-            VDBG("\tsource=%s %s\n",
-                    ether_ntoa(&p.source_addr),
-                    inet_ntoa(p.source_ip));
-            VDBG("\ttarget=%s %s\n",
-                    ether_ntoa(&p.target_addr),
-                    inet_ntoa(p.target_ip));
-            if (p.arp.ar_op != htons(ARPOP_REQUEST)
-                    && p.arp.ar_op != htons(ARPOP_REPLY))
+                    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));
+            }
+#endif
+            if (p.arp.arp_op != htons(ARPOP_REQUEST)
+                    && p.arp.arp_op != htons(ARPOP_REPLY))
                 continue;
 
-            // some cases are always conflicts
-            if ((p.source_ip.s_addr == ip.s_addr)
-                    && (memcmp(&addr, &p.source_addr,
-                            ETH_ALEN) != 0)) {
-collision:
-                VDBG("%s ARP conflict from %s\n", intf,
-                        ether_ntoa(&p.source_addr));
-                if (ready) {
-                    time_t now = time(0);
-
-                    if ((defend + DEFEND_INTERVAL)
-                            < now) {
-                        defend = now;
-                        (void)arp(fd, &saddr,
-                                ARPOP_REQUEST,
-                                &addr, ip,
-                                &addr, ip);
-                        VDBG("%s defend\n", intf);
-                        timeout = -1;
-                        continue;
+            if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0 &&
+                memcmp(&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) {
+                target_ip_conflict = 1;
+            }
+
+            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", intf);
+                        timeout = RATE_LIMIT_INTERVAL * 1000;
+                        state = RATE_LIMIT_PROBE;
                     }
-                    defend = now;
+
+                    // restart the whole protocol
+                    pick(&ip);
+                    timeout = 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 = DEFEND_INTERVAL * 1000;
+                    (void)arp(fd, &saddr,
+                            ARPOP_REQUEST,
+                            &addr, ip,
+                            &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(script, "deconfig", intf, &ip);
-                    // FIXME rm filters: setsockopt(fd,
-                    // SO_DETACH_FILTER, ...)
-                }
-                conflicts++;
-                if (conflicts >= MAX_CONFLICTS) {
-                    VDBG("%s ratelimit\n", intf);
-                    sleep(RATE_LIMIT_INTERVAL);
-                }
-                // restart the whole protocol
+
+                    // restart the whole protocol
+                    pick(&ip);
+                    timeout = 0;
+                    nprobes = 0;
+                    nclaims = 0;
+                }
+                break;
+            default:
+                // Invalid, should never happen.  Restart the whole protocol.
+                VDBG("invalid state -- starting over\n");
+                state = PROBE;
                 pick(&ip);
                 timeout = 0;
                 nprobes = 0;
                 nclaims = 0;
-            }
-            // two hosts probing one address is a collision too
-            else if (p.target_ip.s_addr == ip.s_addr
-                    && nclaims == 0
-                    && p.arp.ar_op == htons(ARPOP_REQUEST)
-                    && memcmp(&addr, &p.target_addr,
-                            ETH_ALEN) != 0) {
-                goto collision;
-            }
-            break;
-
+                break;
+            } // switch state
+
+            break; // case 1 (packets arriving)
         default:
             why = "poll";
             goto bad;
-        }
+        } // switch poll
     }
 bad: