source: branches/3.2/mindi-busybox/networking/zcip.c @ 3232

Last change on this file since 3232 was 3232, checked in by bruno, 6 years ago
  • Update mindi-busybox to 1.21.1
File size: 15.5 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * RFC3927 ZeroConf IPv4 Link-Local addressing
4 * (see <http://www.zeroconf.org/>)
5 *
6 * Copyright (C) 2003 by Arthur van Hoff (avh@strangeberry.com)
7 * Copyright (C) 2004 by David Brownell
8 *
9 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
10 */
11
12/*
13 * ZCIP just manages the 169.254.*.* addresses.  That network is not
14 * routed at the IP level, though various proxies or bridges can
15 * certainly be used.  Its naming is built over multicast DNS.
16 */
17
18//#define DEBUG
19
20// TODO:
21// - more real-world usage/testing, especially daemon mode
22// - kernel packet filters to reduce scheduling noise
23// - avoid silent script failures, especially under load...
24// - link status monitoring (restart on link-up; stop on link-down)
25
26//usage:#define zcip_trivial_usage
27//usage:       "[OPTIONS] IFACE SCRIPT"
28//usage:#define zcip_full_usage "\n\n"
29//usage:       "Manage a ZeroConf IPv4 link-local address\n"
30//usage:     "\n    -f      Run in foreground"
31//usage:     "\n    -q      Quit after obtaining address"
32//usage:     "\n    -r 169.254.x.x  Request this address first"
33//usage:     "\n    -v      Verbose"
34//usage:     "\n"
35//usage:     "\nWith no -q, runs continuously monitoring for ARP conflicts,"
36//usage:     "\nexits only on I/O errors (link down etc)"
37
38#include "libbb.h"
39#include <netinet/ether.h>
40#include <net/if.h>
41#include <net/if_arp.h>
42#include <linux/sockios.h>
43
44#include <syslog.h>
45
46/* We don't need more than 32 bits of the counter */
47#define MONOTONIC_US() ((unsigned)monotonic_us())
48
49struct arp_packet {
50    struct ether_header eth;
51    struct ether_arp arp;
52} PACKED;
53
54enum {
55/* 169.254.0.0 */
56    LINKLOCAL_ADDR = 0xa9fe0000,
57
58/* protocol timeout parameters, specified in seconds */
59    PROBE_WAIT = 1,
60    PROBE_MIN = 1,
61    PROBE_MAX = 2,
62    PROBE_NUM = 3,
63    MAX_CONFLICTS = 10,
64    RATE_LIMIT_INTERVAL = 60,
65    ANNOUNCE_WAIT = 2,
66    ANNOUNCE_NUM = 2,
67    ANNOUNCE_INTERVAL = 2,
68    DEFEND_INTERVAL = 10
69};
70
71/* States during the configuration process. */
72enum {
73    PROBE = 0,
74    RATE_LIMIT_PROBE,
75    ANNOUNCE,
76    MONITOR,
77    DEFEND
78};
79
80#define VDBG(...) do { } while (0)
81
82
83enum {
84    sock_fd = 3
85};
86
87struct globals {
88    struct sockaddr saddr;
89    struct ether_addr eth_addr;
90} FIX_ALIASING;
91#define G (*(struct globals*)&bb_common_bufsiz1)
92#define saddr    (G.saddr   )
93#define eth_addr (G.eth_addr)
94#define INIT_G() do { } while (0)
95
96
97/**
98 * Pick a random link local IP address on 169.254/16, except that
99 * the first and last 256 addresses are reserved.
100 */
101static uint32_t pick(void)
102{
103    unsigned tmp;
104
105    do {
106        tmp = rand() & IN_CLASSB_HOST;
107    } while (tmp > (IN_CLASSB_HOST - 0x0200));
108    return htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
109}
110
111/**
112 * Broadcast an ARP packet.
113 */
114static void arp(
115    /* int op, - always ARPOP_REQUEST */
116    /* const struct ether_addr *source_eth, - always &eth_addr */
117                    struct in_addr source_ip,
118    const struct ether_addr *target_eth, struct in_addr target_ip)
119{
120    enum { op = ARPOP_REQUEST };
121#define source_eth (&eth_addr)
122
123    struct arp_packet p;
124    memset(&p, 0, sizeof(p));
125
126    // ether header
127    p.eth.ether_type = htons(ETHERTYPE_ARP);
128    memcpy(p.eth.ether_shost, source_eth, ETH_ALEN);
129    memset(p.eth.ether_dhost, 0xff, ETH_ALEN);
130
131    // arp request
132    p.arp.arp_hrd = htons(ARPHRD_ETHER);
133    p.arp.arp_pro = htons(ETHERTYPE_IP);
134    p.arp.arp_hln = ETH_ALEN;
135    p.arp.arp_pln = 4;
136    p.arp.arp_op = htons(op);
137    memcpy(&p.arp.arp_sha, source_eth, ETH_ALEN);
138    memcpy(&p.arp.arp_spa, &source_ip, sizeof(p.arp.arp_spa));
139    memcpy(&p.arp.arp_tha, target_eth, ETH_ALEN);
140    memcpy(&p.arp.arp_tpa, &target_ip, sizeof(p.arp.arp_tpa));
141
142    // send it
143    // Even though sock_fd is already bound to saddr, just send()
144    // won't work, because "socket is not connected"
145    // (and connect() won't fix that, "operation not supported").
146    // Thus we sendto() to saddr. I wonder which sockaddr
147    // (from bind() or from sendto()?) kernel actually uses
148    // to determine iface to emit the packet from...
149    xsendto(sock_fd, &p, sizeof(p), &saddr, sizeof(saddr));
150#undef source_eth
151}
152
153/**
154 * Run a script.
155 * argv[0]:intf argv[1]:script_name argv[2]:junk argv[3]:NULL
156 */
157static int run(char *argv[3], const char *param, struct in_addr *ip)
158{
159    int status;
160    char *addr = addr; /* for gcc */
161    const char *fmt = "%s %s %s" + 3;
162
163    argv[2] = (char*)param;
164
165    VDBG("%s run %s %s\n", argv[0], argv[1], argv[2]);
166
167    if (ip) {
168        addr = inet_ntoa(*ip);
169        xsetenv("ip", addr);
170        fmt -= 3;
171    }
172    bb_info_msg(fmt, argv[2], argv[0], addr);
173
174    status = spawn_and_wait(argv + 1);
175    if (status < 0) {
176        bb_perror_msg("%s %s %s" + 3, argv[2], argv[0]);
177        return -errno;
178    }
179    if (status != 0)
180        bb_error_msg("script %s %s failed, exitcode=%d", argv[1], argv[2], status & 0xff);
181    return status;
182}
183
184/**
185 * Return milliseconds of random delay, up to "secs" seconds.
186 */
187static ALWAYS_INLINE unsigned random_delay_ms(unsigned secs)
188{
189    return rand() % (secs * 1000);
190}
191
192/**
193 * main program
194 */
195int zcip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
196int zcip_main(int argc UNUSED_PARAM, char **argv)
197{
198    int state;
199    char *r_opt;
200    unsigned opts;
201
202    // ugly trick, but I want these zeroed in one go
203    struct {
204        const struct in_addr null_ip;
205        const struct ether_addr null_addr;
206        struct in_addr ip;
207        struct ifreq ifr;
208        int timeout_ms; /* must be signed */
209        unsigned conflicts;
210        unsigned nprobes;
211        unsigned nclaims;
212        int ready;
213        int verbose;
214    } L;
215#define null_ip    (L.null_ip   )
216#define null_addr  (L.null_addr )
217#define ip         (L.ip        )
218#define ifr        (L.ifr       )
219#define timeout_ms (L.timeout_ms)
220#define conflicts  (L.conflicts )
221#define nprobes    (L.nprobes   )
222#define nclaims    (L.nclaims   )
223#define ready      (L.ready     )
224#define verbose    (L.verbose   )
225
226    memset(&L, 0, sizeof(L));
227    INIT_G();
228
229#define FOREGROUND (opts & 1)
230#define QUIT       (opts & 2)
231    // parse commandline: prog [options] ifname script
232    // exactly 2 args; -v accumulates and implies -f
233    opt_complementary = "=2:vv:vf";
234    opts = getopt32(argv, "fqr:v", &r_opt, &verbose);
235#if !BB_MMU
236    // on NOMMU reexec early (or else we will rerun things twice)
237    if (!FOREGROUND)
238        bb_daemonize_or_rexec(0 /*was: DAEMON_CHDIR_ROOT*/, argv);
239#endif
240    // open an ARP socket
241    // (need to do it before openlog to prevent openlog from taking
242    // fd 3 (sock_fd==3))
243    xmove_fd(xsocket(AF_PACKET, SOCK_PACKET, htons(ETH_P_ARP)), sock_fd);
244    if (!FOREGROUND) {
245        // do it before all bb_xx_msg calls
246        openlog(applet_name, 0, LOG_DAEMON);
247        logmode |= LOGMODE_SYSLOG;
248    }
249    if (opts & 4) { // -r n.n.n.n
250        if (inet_aton(r_opt, &ip) == 0
251         || (ntohl(ip.s_addr) & IN_CLASSB_NET) != LINKLOCAL_ADDR
252        ) {
253            bb_error_msg_and_die("invalid link address");
254        }
255    }
256    argv += optind - 1;
257
258    /* Now: argv[0]:junk argv[1]:intf argv[2]:script argv[3]:NULL */
259    /* We need to make space for script argument: */
260    argv[0] = argv[1];
261    argv[1] = argv[2];
262    /* Now: argv[0]:intf argv[1]:script argv[2]:junk argv[3]:NULL */
263#define argv_intf (argv[0])
264
265    xsetenv("interface", argv_intf);
266
267    // initialize the interface (modprobe, ifup, etc)
268    if (run(argv, "init", NULL))
269        return EXIT_FAILURE;
270
271    // initialize saddr
272    // saddr is: { u16 sa_family; u8 sa_data[14]; }
273    //memset(&saddr, 0, sizeof(saddr));
274    //TODO: are we leaving sa_family == 0 (AF_UNSPEC)?!
275    safe_strncpy(saddr.sa_data, argv_intf, sizeof(saddr.sa_data));
276
277    // bind to the interface's ARP socket
278    xbind(sock_fd, &saddr, sizeof(saddr));
279
280    // get the interface's ethernet address
281    //memset(&ifr, 0, sizeof(ifr));
282    strncpy_IFNAMSIZ(ifr.ifr_name, argv_intf);
283    xioctl(sock_fd, SIOCGIFHWADDR, &ifr);
284    memcpy(&eth_addr, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
285
286    // start with some stable ip address, either a function of
287    // the hardware address or else the last address we used.
288    // we are taking low-order four bytes, as top-order ones
289    // aren't random enough.
290    // NOTE: the sequence of addresses we try changes only
291    // depending on when we detect conflicts.
292    {
293        uint32_t t;
294        move_from_unaligned32(t, ((char *)&eth_addr + 2));
295        srand(t);
296    }
297    if (ip.s_addr == 0)
298        ip.s_addr = pick();
299
300    // FIXME cases to handle:
301    //  - zcip already running!
302    //  - link already has local address... just defend/update
303
304    // daemonize now; don't delay system startup
305    if (!FOREGROUND) {
306#if BB_MMU
307        bb_daemonize(0 /*was: DAEMON_CHDIR_ROOT*/);
308#endif
309        bb_info_msg("start, interface %s", argv_intf);
310    }
311
312    // run the dynamic address negotiation protocol,
313    // restarting after address conflicts:
314    //  - start with some address we want to try
315    //  - short random delay
316    //  - arp probes to see if another host uses it
317    //  - arp announcements that we're claiming it
318    //  - use it
319    //  - defend it, within limits
320    // exit if:
321    // - address is successfully obtained and -q was given:
322    //   run "<script> config", then exit with exitcode 0
323    // - poll error (when does this happen?)
324    // - read error (when does this happen?)
325    // - sendto error (in arp()) (when does this happen?)
326    // - revents & POLLERR (link down). run "<script> deconfig" first
327    state = PROBE;
328    while (1) {
329        struct pollfd fds[1];
330        unsigned deadline_us;
331        struct arp_packet p;
332        int source_ip_conflict;
333        int target_ip_conflict;
334
335        fds[0].fd = sock_fd;
336        fds[0].events = POLLIN;
337        fds[0].revents = 0;
338
339        // poll, being ready to adjust current timeout
340        if (!timeout_ms) {
341            timeout_ms = random_delay_ms(PROBE_WAIT);
342            // FIXME setsockopt(sock_fd, SO_ATTACH_FILTER, ...) to
343            // make the kernel filter out all packets except
344            // ones we'd care about.
345        }
346        // set deadline_us to the point in time when we timeout
347        deadline_us = MONOTONIC_US() + timeout_ms * 1000;
348
349        VDBG("...wait %d %s nprobes=%u, nclaims=%u\n",
350                timeout_ms, argv_intf, nprobes, nclaims);
351
352        switch (safe_poll(fds, 1, timeout_ms)) {
353
354        default:
355            //bb_perror_msg("poll"); - done in safe_poll
356            return EXIT_FAILURE;
357
358        // timeout
359        case 0:
360            VDBG("state = %d\n", state);
361            switch (state) {
362            case PROBE:
363                // timeouts in the PROBE state mean no conflicting ARP packets
364                // have been received, so we can progress through the states
365                if (nprobes < PROBE_NUM) {
366                    nprobes++;
367                    VDBG("probe/%u %s@%s\n",
368                            nprobes, argv_intf, inet_ntoa(ip));
369                    arp(/* ARPOP_REQUEST, */
370                            /* &eth_addr, */ null_ip,
371                            &null_addr, ip);
372                    timeout_ms = PROBE_MIN * 1000;
373                    timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
374                }
375                else {
376                    // Switch to announce state.
377                    state = ANNOUNCE;
378                    nclaims = 0;
379                    VDBG("announce/%u %s@%s\n",
380                            nclaims, argv_intf, inet_ntoa(ip));
381                    arp(/* ARPOP_REQUEST, */
382                            /* &eth_addr, */ ip,
383                            &eth_addr, ip);
384                    timeout_ms = ANNOUNCE_INTERVAL * 1000;
385                }
386                break;
387            case RATE_LIMIT_PROBE:
388                // timeouts in the RATE_LIMIT_PROBE state mean no conflicting ARP packets
389                // have been received, so we can move immediately to the announce state
390                state = ANNOUNCE;
391                nclaims = 0;
392                VDBG("announce/%u %s@%s\n",
393                        nclaims, argv_intf, inet_ntoa(ip));
394                arp(/* ARPOP_REQUEST, */
395                        /* &eth_addr, */ ip,
396                        &eth_addr, ip);
397                timeout_ms = ANNOUNCE_INTERVAL * 1000;
398                break;
399            case ANNOUNCE:
400                // timeouts in the ANNOUNCE state mean no conflicting ARP packets
401                // have been received, so we can progress through the states
402                if (nclaims < ANNOUNCE_NUM) {
403                    nclaims++;
404                    VDBG("announce/%u %s@%s\n",
405                            nclaims, argv_intf, inet_ntoa(ip));
406                    arp(/* ARPOP_REQUEST, */
407                            /* &eth_addr, */ ip,
408                            &eth_addr, ip);
409                    timeout_ms = ANNOUNCE_INTERVAL * 1000;
410                }
411                else {
412                    // Switch to monitor state.
413                    state = MONITOR;
414                    // link is ok to use earlier
415                    // FIXME update filters
416                    run(argv, "config", &ip);
417                    ready = 1;
418                    conflicts = 0;
419                    timeout_ms = -1; // Never timeout in the monitor state.
420
421                    // NOTE: all other exit paths
422                    // should deconfig ...
423                    if (QUIT)
424                        return EXIT_SUCCESS;
425                }
426                break;
427            case DEFEND:
428                // We won!  No ARP replies, so just go back to monitor.
429                state = MONITOR;
430                timeout_ms = -1;
431                conflicts = 0;
432                break;
433            default:
434                // Invalid, should never happen.  Restart the whole protocol.
435                state = PROBE;
436                ip.s_addr = pick();
437                timeout_ms = 0;
438                nprobes = 0;
439                nclaims = 0;
440                break;
441            } // switch (state)
442            break; // case 0 (timeout)
443
444        // packets arriving, or link went down
445        case 1:
446            // We need to adjust the timeout in case we didn't receive
447            // a conflicting packet.
448            if (timeout_ms > 0) {
449                unsigned diff = deadline_us - MONOTONIC_US();
450                if ((int)(diff) < 0) {
451                    // Current time is greater than the expected timeout time.
452                    // Should never happen.
453                    VDBG("missed an expected timeout\n");
454                    timeout_ms = 0;
455                } else {
456                    VDBG("adjusting timeout\n");
457                    timeout_ms = (diff / 1000) | 1; /* never 0 */
458                }
459            }
460
461            if ((fds[0].revents & POLLIN) == 0) {
462                if (fds[0].revents & POLLERR) {
463                    // FIXME: links routinely go down;
464                    // this shouldn't necessarily exit.
465                    bb_error_msg("iface %s is down", argv_intf);
466                    if (ready) {
467                        run(argv, "deconfig", &ip);
468                    }
469                    return EXIT_FAILURE;
470                }
471                continue;
472            }
473
474            // read ARP packet
475            if (safe_read(sock_fd, &p, sizeof(p)) < 0) {
476                bb_perror_msg_and_die(bb_msg_read_error);
477            }
478            if (p.eth.ether_type != htons(ETHERTYPE_ARP))
479                continue;
480#ifdef DEBUG
481            {
482                struct ether_addr *sha = (struct ether_addr *) p.arp.arp_sha;
483                struct ether_addr *tha = (struct ether_addr *) p.arp.arp_tha;
484                struct in_addr *spa = (struct in_addr *) p.arp.arp_spa;
485                struct in_addr *tpa = (struct in_addr *) p.arp.arp_tpa;
486                VDBG("%s recv arp type=%d, op=%d,\n",
487                    argv_intf, ntohs(p.eth.ether_type),
488                    ntohs(p.arp.arp_op));
489                VDBG("\tsource=%s %s\n",
490                    ether_ntoa(sha),
491                    inet_ntoa(*spa));
492                VDBG("\ttarget=%s %s\n",
493                    ether_ntoa(tha),
494                    inet_ntoa(*tpa));
495            }
496#endif
497            if (p.arp.arp_op != htons(ARPOP_REQUEST)
498             && p.arp.arp_op != htons(ARPOP_REPLY))
499                continue;
500
501            source_ip_conflict = 0;
502            target_ip_conflict = 0;
503
504            if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0
505             && memcmp(&p.arp.arp_sha, &eth_addr, ETH_ALEN) != 0
506            ) {
507                source_ip_conflict = 1;
508            }
509            if (p.arp.arp_op == htons(ARPOP_REQUEST)
510             && memcmp(p.arp.arp_tpa, &ip.s_addr, sizeof(struct in_addr)) == 0
511             && memcmp(&p.arp.arp_tha, &eth_addr, ETH_ALEN) != 0
512            ) {
513                target_ip_conflict = 1;
514            }
515
516            VDBG("state = %d, source ip conflict = %d, target ip conflict = %d\n",
517                state, source_ip_conflict, target_ip_conflict);
518            switch (state) {
519            case PROBE:
520            case ANNOUNCE:
521                // When probing or announcing, check for source IP conflicts
522                // and other hosts doing ARP probes (target IP conflicts).
523                if (source_ip_conflict || target_ip_conflict) {
524                    conflicts++;
525                    if (conflicts >= MAX_CONFLICTS) {
526                        VDBG("%s ratelimit\n", argv_intf);
527                        timeout_ms = RATE_LIMIT_INTERVAL * 1000;
528                        state = RATE_LIMIT_PROBE;
529                    }
530
531                    // restart the whole protocol
532                    ip.s_addr = pick();
533                    timeout_ms = 0;
534                    nprobes = 0;
535                    nclaims = 0;
536                }
537                break;
538            case MONITOR:
539                // If a conflict, we try to defend with a single ARP probe.
540                if (source_ip_conflict) {
541                    VDBG("monitor conflict -- defending\n");
542                    state = DEFEND;
543                    timeout_ms = DEFEND_INTERVAL * 1000;
544                    arp(/* ARPOP_REQUEST, */
545                        /* &eth_addr, */ ip,
546                        &eth_addr, ip);
547                }
548                break;
549            case DEFEND:
550                // Well, we tried.  Start over (on conflict).
551                if (source_ip_conflict) {
552                    state = PROBE;
553                    VDBG("defend conflict -- starting over\n");
554                    ready = 0;
555                    run(argv, "deconfig", &ip);
556
557                    // restart the whole protocol
558                    ip.s_addr = pick();
559                    timeout_ms = 0;
560                    nprobes = 0;
561                    nclaims = 0;
562                }
563                break;
564            default:
565                // Invalid, should never happen.  Restart the whole protocol.
566                VDBG("invalid state -- starting over\n");
567                state = PROBE;
568                ip.s_addr = pick();
569                timeout_ms = 0;
570                nprobes = 0;
571                nclaims = 0;
572                break;
573            } // switch state
574            break; // case 1 (packets arriving)
575        } // switch poll
576    } // while (1)
577#undef argv_intf
578}
Note: See TracBrowser for help on using the repository browser.