[thirdparty/systemd.git] / src / libsystemd-network / sd-ipv4acd.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
  Copyright © 2014 Axis Communications AB. All rights reserved.
***/

#include <netinet/if_ether.h>
#include <stdio.h>

#include "sd-ipv4acd.h"

#include "alloc-util.h"
#include "arp-util.h"
#include "errno-util.h"
#include "ether-addr-util.h"
#include "event-util.h"
#include "fd-util.h"
#include "in-addr-util.h"
#include "memory-util.h"
#include "network-common.h"
#include "random-util.h"
#include "socket-util.h"
#include "string-table.h"
#include "string-util.h"
#include "time-util.h"

/* Intervals from the RFC in seconds, need to be multiplied by the time unit */
#define PROBE_WAIT 1U
#define PROBE_MIN 1U
#define PROBE_MAX 2U
#define ANNOUNCE_WAIT 2U
#define TOTAL_TIME_UNITS 7U

/* Intervals from the RFC not adjusted to the time unit */
#define ANNOUNCE_INTERVAL_USEC (2U * USEC_PER_SEC)
#define RATE_LIMIT_INTERVAL_USEC (60U * USEC_PER_SEC)
#define DEFEND_INTERVAL_USEC (10U * USEC_PER_SEC)

/* Other constants from the RFC */
#define PROBE_NUM 3U
#define ANNOUNCE_NUM 2U
#define MAX_CONFLICTS 10U

/* Default timeout from the RFC */
#define DEFAULT_ACD_TIMEOUT_USEC (200 * USEC_PER_MSEC)

typedef enum IPv4ACDState {
        IPV4ACD_STATE_INIT,
        IPV4ACD_STATE_STARTED,
        IPV4ACD_STATE_WAITING_PROBE,
        IPV4ACD_STATE_PROBING,
        IPV4ACD_STATE_WAITING_ANNOUNCE,
        IPV4ACD_STATE_ANNOUNCING,
        IPV4ACD_STATE_RUNNING,
        _IPV4ACD_STATE_MAX,
        _IPV4ACD_STATE_INVALID = -EINVAL,
} IPv4ACDState;

struct sd_ipv4acd {
        unsigned n_ref;

        IPv4ACDState state;
        int ifindex;
        int fd;

        char *ifname;
        unsigned n_iteration;
        unsigned n_conflict;

        /* Indicates the duration of a "time unit", i.e. one second in the RFC but scaled to the
         * chosen total duration. Represents 1/7 of the total conflict detection timeout. */
        usec_t time_unit_usec;

        sd_event_source *receive_message_event_source;
        sd_event_source *timer_event_source;

        usec_t defend_window;
        struct in_addr address;

        /* External */
        struct ether_addr mac_addr;

        sd_event *event;
        int event_priority;
        sd_ipv4acd_callback_t callback;
        void *userdata;
        sd_ipv4acd_check_mac_callback_t check_mac_callback;
        void *check_mac_userdata;
};

#define log_ipv4acd_errno(acd, error, fmt, ...)         \
        log_interface_prefix_full_errno(                \
                "IPv4ACD: ",                            \
                sd_ipv4acd, acd,                        \
                error, fmt, ##__VA_ARGS__)
#define log_ipv4acd(acd, fmt, ...)                      \
        log_interface_prefix_full_errno_zerook(         \
                "IPv4ACD: ",                            \
                sd_ipv4acd, acd,                        \
                0, fmt, ##__VA_ARGS__)

static const char * const ipv4acd_state_table[_IPV4ACD_STATE_MAX] = {
        [IPV4ACD_STATE_INIT]             = "init",
        [IPV4ACD_STATE_STARTED]          = "started",
        [IPV4ACD_STATE_WAITING_PROBE]    = "waiting-probe",
        [IPV4ACD_STATE_PROBING]          = "probing",
        [IPV4ACD_STATE_WAITING_ANNOUNCE] = "waiting-announce",
        [IPV4ACD_STATE_ANNOUNCING]       = "announcing",
        [IPV4ACD_STATE_RUNNING]          = "running",
};

DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(ipv4acd_state, IPv4ACDState);

static void ipv4acd_set_state(sd_ipv4acd *acd, IPv4ACDState st, bool reset_counter) {
        assert(acd);
        assert(st < _IPV4ACD_STATE_MAX);

        if (st != acd->state)
                log_ipv4acd(acd, "%s -> %s", ipv4acd_state_to_string(acd->state), ipv4acd_state_to_string(st));

        if (st == acd->state && !reset_counter)
                acd->n_iteration++;
        else {
                acd->state = st;
                acd->n_iteration = 0;
        }
}

static void ipv4acd_reset(sd_ipv4acd *acd) {
        assert(acd);

        (void) event_source_disable(acd->timer_event_source);
        acd->receive_message_event_source = sd_event_source_disable_unref(acd->receive_message_event_source);

        acd->fd = safe_close(acd->fd);

        ipv4acd_set_state(acd, IPV4ACD_STATE_INIT, true);
}

static sd_ipv4acd *ipv4acd_free(sd_ipv4acd *acd) {
        assert(acd);

        ipv4acd_reset(acd);
        sd_event_source_unref(acd->timer_event_source);
        sd_ipv4acd_detach_event(acd);
        free(acd->ifname);
        return mfree(acd);
}

DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_ipv4acd, sd_ipv4acd, ipv4acd_free);

int sd_ipv4acd_new(sd_ipv4acd **ret) {
        _cleanup_(sd_ipv4acd_unrefp) sd_ipv4acd *acd = NULL;

        assert_return(ret, -EINVAL);

        acd = new(sd_ipv4acd, 1);
        if (!acd)
                return -ENOMEM;

        *acd = (sd_ipv4acd) {
                .n_ref = 1,
                .state = IPV4ACD_STATE_INIT,
                .time_unit_usec = DEFAULT_ACD_TIMEOUT_USEC / TOTAL_TIME_UNITS,
                .ifindex = -1,
                .fd = -EBADF,
        };

        *ret = TAKE_PTR(acd);

        return 0;
}

static void ipv4acd_client_notify(sd_ipv4acd *acd, int event) {
        assert(acd);

        if (!acd->callback)
                return;

        acd->callback(acd, event, acd->userdata);
}

int sd_ipv4acd_stop(sd_ipv4acd *acd) {
        IPv4ACDState old_state;

        if (!acd)
                return 0;

        old_state = acd->state;

        ipv4acd_reset(acd);

        if (old_state == IPV4ACD_STATE_INIT)
                return 0;

        log_ipv4acd(acd, "STOPPED");

        ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_STOP);

        return 0;
}

static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata);

static int ipv4acd_set_next_wakeup(sd_ipv4acd *acd, usec_t usec, usec_t random_usec) {
        usec_t next_timeout, time_now;

        assert(acd);

        next_timeout = usec;

        if (random_usec > 0)
                next_timeout += (usec_t) random_u64() % random_usec;

        assert_se(sd_event_now(acd->event, CLOCK_BOOTTIME, &time_now) >= 0);

        return event_reset_time(acd->event, &acd->timer_event_source,
                                CLOCK_BOOTTIME,
                                time_now + next_timeout, 0,
                                ipv4acd_on_timeout, acd,
                                acd->event_priority, "ipv4acd-timer", true);
}

static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
        sd_ipv4acd *acd = ASSERT_PTR(userdata);
        int r = 0;

        switch (acd->state) {

        case IPV4ACD_STATE_STARTED:
                acd->defend_window = 0;

                log_ipv4acd(acd,
                            "Started on address " IPV4_ADDRESS_FMT_STR " with a max timeout of %s",
                            IPV4_ADDRESS_FMT_VAL(acd->address),
                            FORMAT_TIMESPAN(TOTAL_TIME_UNITS * acd->time_unit_usec, USEC_PER_MSEC));

                ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_PROBE, true);

                if (acd->n_conflict >= MAX_CONFLICTS) {
                        log_ipv4acd(acd, "Max conflicts reached, delaying by %s",
                                    FORMAT_TIMESPAN(RATE_LIMIT_INTERVAL_USEC, 0));
                        r = ipv4acd_set_next_wakeup(
                                        acd, RATE_LIMIT_INTERVAL_USEC, PROBE_WAIT * acd->time_unit_usec);
                } else
                        r = ipv4acd_set_next_wakeup(acd, 0, PROBE_WAIT * acd->time_unit_usec);
                if (r < 0)
                        goto fail;

                break;

        case IPV4ACD_STATE_WAITING_PROBE:
        case IPV4ACD_STATE_PROBING:
                /* Send a probe */
                r = arp_send_probe(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
                if (r < 0) {
                        log_ipv4acd_errno(acd, r, "Failed to send ARP probe: %m");
                        goto fail;
                }

                log_ipv4acd(acd, "Probing "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));

                if (acd->n_iteration < PROBE_NUM - 2) {
                        ipv4acd_set_state(acd, IPV4ACD_STATE_PROBING, false);

                        r = ipv4acd_set_next_wakeup(
                                        acd,
                                        PROBE_MIN * acd->time_unit_usec,
                                        (PROBE_MAX - PROBE_MIN) * acd->time_unit_usec);
                        if (r < 0)
                                goto fail;
                } else {
                        ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_ANNOUNCE, true);

                        r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_WAIT * acd->time_unit_usec, 0);
                        if (r < 0)
                                goto fail;
                }

                break;

        case IPV4ACD_STATE_ANNOUNCING:
                if (acd->n_iteration >= ANNOUNCE_NUM - 1) {
                        ipv4acd_set_state(acd, IPV4ACD_STATE_RUNNING, false);
                        break;
                }

                _fallthrough_;
        case IPV4ACD_STATE_WAITING_ANNOUNCE:
                /* Send announcement packet */
                r = arp_send_announcement(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
                if (r < 0) {
                        log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
                        goto fail;
                }

                log_ipv4acd(acd, "Announcing "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));

                ipv4acd_set_state(acd, IPV4ACD_STATE_ANNOUNCING, false);

                r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_INTERVAL_USEC, 0);
                if (r < 0)
                        goto fail;

                if (acd->n_iteration == 0) {
                        acd->n_conflict = 0;
                        ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_BIND);
                }

                break;

        default:
                assert_not_reached();
        }

        return 0;

fail:
        sd_ipv4acd_stop(acd);
        return 0;
}

static bool ipv4acd_arp_conflict(sd_ipv4acd *acd, const struct ether_arp *arp, bool announced) {
        assert(acd);
        assert(arp);

        /* RFC 5227 section 2.1.1.
         * "the host receives any ARP packet (Request *or* Reply) on the interface where the probe is
         * being performed, where the packet's 'sender IP address' is the address being probed for,
         * then the host MUST treat this address as being in use by some other host" */
        if (memcmp(arp->arp_spa, &acd->address, sizeof(struct in_addr)) == 0)
                return true;

        if (announced)
                /* the TPA matched instead of SPA, this is not a conflict */
                return false;

        /* "any ARP Probe where the packet's 'target IP address' is the address being probed for, and
         * the packet's 'sender hardware address' is not the hardware address of any of the host's
         * interfaces, then the host SHOULD similarly treat this as an address conflict" */
        if (arp->ea_hdr.ar_op != htobe16(ARPOP_REQUEST))
                return false; /* not ARP Request, ignoring. */
        if (memeqzero(arp->arp_spa, sizeof(struct in_addr)) == 0)
                return false; /* not ARP Probe, ignoring. */
        if (memcmp(arp->arp_tpa, &acd->address, sizeof(struct in_addr)) != 0)
                return false; /* target IP address does not match, BPF code is broken? */

        if (acd->check_mac_callback &&
            acd->check_mac_callback(acd, (const struct ether_addr*) arp->arp_sha, acd->check_mac_userdata) > 0)
                /* sender hardware is one of the host's interfaces, ignoring. */
                return false;

        return true; /* conflict! */
}

static void ipv4acd_on_conflict(sd_ipv4acd *acd) {
        assert(acd);

        acd->n_conflict++;

        log_ipv4acd(acd, "Conflict on "IPV4_ADDRESS_FMT_STR" (%u)", IPV4_ADDRESS_FMT_VAL(acd->address), acd->n_conflict);

        ipv4acd_reset(acd);
        ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_CONFLICT);
}

static int ipv4acd_on_packet(
                sd_event_source *s,
                int fd,
                uint32_t revents,
                void *userdata) {

        sd_ipv4acd *acd = ASSERT_PTR(userdata);
        struct ether_arp packet;
        ssize_t n;
        int r;

        assert(s);
        assert(fd >= 0);

        n = recv(fd, &packet, sizeof(struct ether_arp), 0);
        if (n < 0) {
                if (ERRNO_IS_TRANSIENT(errno) || ERRNO_IS_DISCONNECT(errno))
                        return 0;

                log_ipv4acd_errno(acd, errno, "Failed to read ARP packet: %m");
                goto fail;
        }
        if ((size_t) n != sizeof(struct ether_arp)) {
                log_ipv4acd(acd, "Ignoring too short ARP packet.");
                return 0;
        }

        switch (acd->state) {

        case IPV4ACD_STATE_ANNOUNCING:
        case IPV4ACD_STATE_RUNNING:

                if (ipv4acd_arp_conflict(acd, &packet, true)) {
                        usec_t ts;

                        assert_se(sd_event_now(acd->event, CLOCK_BOOTTIME, &ts) >= 0);

                        /* Defend address */
                        if (ts > acd->defend_window) {
                                acd->defend_window = ts + DEFEND_INTERVAL_USEC;
                                r = arp_send_announcement(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
                                if (r < 0) {
                                        log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
                                        goto fail;
                                }

                                log_ipv4acd(acd, "Defending "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));

                        } else
                                ipv4acd_on_conflict(acd);
                }
                break;

        case IPV4ACD_STATE_STARTED:
        case IPV4ACD_STATE_WAITING_PROBE:
        case IPV4ACD_STATE_PROBING:
        case IPV4ACD_STATE_WAITING_ANNOUNCE:
                if (ipv4acd_arp_conflict(acd, &packet, false))
                        ipv4acd_on_conflict(acd);
                break;

        default:
                assert_not_reached();
        }

        return 0;

fail:
        sd_ipv4acd_stop(acd);
        return 0;
}

int sd_ipv4acd_set_ifindex(sd_ipv4acd *acd, int ifindex) {
        assert_return(acd, -EINVAL);
        assert_return(ifindex > 0, -EINVAL);
        assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);

        acd->ifindex = ifindex;

        return 0;
}

int sd_ipv4acd_get_ifindex(sd_ipv4acd *acd) {
        if (!acd)
                return -EINVAL;

        return acd->ifindex;
}

int sd_ipv4acd_set_ifname(sd_ipv4acd *acd, const char *ifname) {
        assert_return(acd, -EINVAL);
        assert_return(ifname, -EINVAL);

        if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
                return -EINVAL;

        return free_and_strdup(&acd->ifname, ifname);
}

int sd_ipv4acd_set_timeout(sd_ipv4acd *acd, uint64_t usec) {
        assert_return(acd, -EINVAL);

        if (usec == 0)
                usec = DEFAULT_ACD_TIMEOUT_USEC;

        /* Clamp the total duration to a value between 1ms and 1 minute */
        acd->time_unit_usec = DIV_ROUND_UP(
                        CLAMP(usec, 1U * USEC_PER_MSEC, 1U * USEC_PER_MINUTE), TOTAL_TIME_UNITS);

        return 0;
}

int sd_ipv4acd_get_ifname(sd_ipv4acd *acd, const char **ret) {
        int r;

        assert_return(acd, -EINVAL);

        r = get_ifname(acd->ifindex, &acd->ifname);
        if (r < 0)
                return r;

        if (ret)
                *ret = acd->ifname;

        return 0;
}

int sd_ipv4acd_set_mac(sd_ipv4acd *acd, const struct ether_addr *addr) {
        int r;

        assert_return(acd, -EINVAL);
        assert_return(addr, -EINVAL);
        assert_return(!ether_addr_is_null(addr), -EINVAL);

        acd->mac_addr = *addr;

        if (!sd_ipv4acd_is_running(acd))
                return 0;

        assert(acd->fd >= 0);
        r = arp_update_filter(acd->fd, &acd->address, &acd->mac_addr);
        if (r < 0) {
                ipv4acd_reset(acd);
                return r;
        }

        return 0;
}

int sd_ipv4acd_detach_event(sd_ipv4acd *acd) {
        assert_return(acd, -EINVAL);

        acd->event = sd_event_unref(acd->event);

        return 0;
}

int sd_ipv4acd_attach_event(sd_ipv4acd *acd, sd_event *event, int64_t priority) {
        int r;

        assert_return(acd, -EINVAL);
        assert_return(!acd->event, -EBUSY);

        if (event)
                acd->event = sd_event_ref(event);
        else {
                r = sd_event_default(&acd->event);
                if (r < 0)
                        return r;
        }

        acd->event_priority = priority;

        return 0;
}

int sd_ipv4acd_set_callback(sd_ipv4acd *acd, sd_ipv4acd_callback_t cb, void *userdata) {
        assert_return(acd, -EINVAL);

        acd->callback = cb;
        acd->userdata = userdata;

        return 0;
}

int sd_ipv4acd_set_check_mac_callback(sd_ipv4acd *acd, sd_ipv4acd_check_mac_callback_t cb, void *userdata) {
        assert_return(acd, -EINVAL);

        acd->check_mac_callback = cb;
        acd->check_mac_userdata = userdata;
        return 0;
}

int sd_ipv4acd_set_address(sd_ipv4acd *acd, const struct in_addr *address) {
        int r;

        assert_return(acd, -EINVAL);
        assert_return(address, -EINVAL);
        assert_return(in4_addr_is_set(address), -EINVAL);

        if (in4_addr_equal(&acd->address, address))
                return 0;

        acd->address = *address;

        if (!sd_ipv4acd_is_running(acd))
                return 0;

        assert(acd->fd >= 0);
        r = arp_update_filter(acd->fd, &acd->address, &acd->mac_addr);
        if (r < 0)
                goto fail;

        r = ipv4acd_set_next_wakeup(acd, 0, 0);
        if (r < 0)
                goto fail;

        ipv4acd_set_state(acd, IPV4ACD_STATE_STARTED, true);
        return 0;

fail:
        ipv4acd_reset(acd);
        return r;
}

int sd_ipv4acd_get_address(sd_ipv4acd *acd, struct in_addr *address) {
        assert_return(acd, -EINVAL);
        assert_return(address, -EINVAL);

        *address = acd->address;

        return 0;
}

int sd_ipv4acd_is_running(sd_ipv4acd *acd) {
        if (!acd)
                return false;

        return acd->state != IPV4ACD_STATE_INIT;
}

int sd_ipv4acd_is_bound(sd_ipv4acd *acd) {
        assert_return(acd, false);

        return IN_SET(acd->state, IPV4ACD_STATE_ANNOUNCING, IPV4ACD_STATE_RUNNING);
}

int sd_ipv4acd_start(sd_ipv4acd *acd, bool reset_conflicts) {
        int r;

        assert_return(acd, -EINVAL);
        assert_return(acd->event, -EINVAL);
        assert_return(acd->ifindex > 0, -EINVAL);
        assert_return(in4_addr_is_set(&acd->address), -EINVAL);
        assert_return(!ether_addr_is_null(&acd->mac_addr), -EINVAL);
        assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);

        r = sd_event_get_state(acd->event);
        if (r < 0)
                return r;
        if (r == SD_EVENT_FINISHED)
                return -ESTALE;

        r = arp_network_bind_raw_socket(acd->ifindex, &acd->address, &acd->mac_addr);
        if (r < 0)
                return r;

        close_and_replace(acd->fd, r);

        if (reset_conflicts)
                acd->n_conflict = 0;

        r = sd_event_add_io(acd->event, &acd->receive_message_event_source, acd->fd, EPOLLIN, ipv4acd_on_packet, acd);
        if (r < 0)
                goto fail;

        r = sd_event_source_set_priority(acd->receive_message_event_source, acd->event_priority);
        if (r < 0)
                goto fail;

        (void) sd_event_source_set_description(acd->receive_message_event_source, "ipv4acd-receive-message");

        r = ipv4acd_set_next_wakeup(acd, 0, 0);
        if (r < 0)
                goto fail;

        ipv4acd_set_state(acd, IPV4ACD_STATE_STARTED, true);
        return 0;

fail:
        ipv4acd_reset(acd);
        return r;
}
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
	2	/***
	3	Copyright © 2014 Axis Communications AB. All rights reserved.
	4	***/
	5
	6	#include <netinet/if_ether.h>
	7	#include <stdio.h>
	8
	9	#include "sd-ipv4acd.h"
	10
	11	#include "alloc-util.h"
	12	#include "arp-util.h"
	13	#include "errno-util.h"
	14	#include "ether-addr-util.h"
	15	#include "event-util.h"
	16	#include "fd-util.h"
	17	#include "in-addr-util.h"
	18	#include "memory-util.h"
	19	#include "network-common.h"
	20	#include "random-util.h"
	21	#include "socket-util.h"
	22	#include "string-table.h"
	23	#include "string-util.h"
	24	#include "time-util.h"
	25
	26	/* Intervals from the RFC in seconds, need to be multiplied by the time unit */
	27	#define PROBE_WAIT 1U
	28	#define PROBE_MIN 1U
	29	#define PROBE_MAX 2U
	30	#define ANNOUNCE_WAIT 2U
	31	#define TOTAL_TIME_UNITS 7U
	32
	33	/* Intervals from the RFC not adjusted to the time unit */
	34	#define ANNOUNCE_INTERVAL_USEC (2U * USEC_PER_SEC)
	35	#define RATE_LIMIT_INTERVAL_USEC (60U * USEC_PER_SEC)
	36	#define DEFEND_INTERVAL_USEC (10U * USEC_PER_SEC)
	37
	38	/* Other constants from the RFC */
	39	#define PROBE_NUM 3U
	40	#define ANNOUNCE_NUM 2U
	41	#define MAX_CONFLICTS 10U
	42
	43	/* Default timeout from the RFC */
	44	#define DEFAULT_ACD_TIMEOUT_USEC (200 * USEC_PER_MSEC)
	45
	46	typedef enum IPv4ACDState {
	47	IPV4ACD_STATE_INIT,
	48	IPV4ACD_STATE_STARTED,
	49	IPV4ACD_STATE_WAITING_PROBE,
	50	IPV4ACD_STATE_PROBING,
	51	IPV4ACD_STATE_WAITING_ANNOUNCE,
	52	IPV4ACD_STATE_ANNOUNCING,
	53	IPV4ACD_STATE_RUNNING,
	54	_IPV4ACD_STATE_MAX,
	55	_IPV4ACD_STATE_INVALID = -EINVAL,
	56	} IPv4ACDState;
	57
	58	struct sd_ipv4acd {
	59	unsigned n_ref;
	60
	61	IPv4ACDState state;
	62	int ifindex;
	63	int fd;
	64
	65	char *ifname;
	66	unsigned n_iteration;
	67	unsigned n_conflict;
	68
	69	/* Indicates the duration of a "time unit", i.e. one second in the RFC but scaled to the
	70	* chosen total duration. Represents 1/7 of the total conflict detection timeout. */
	71	usec_t time_unit_usec;
	72
	73	sd_event_source *receive_message_event_source;
	74	sd_event_source *timer_event_source;
	75
	76	usec_t defend_window;
	77	struct in_addr address;
	78
	79	/* External */
	80	struct ether_addr mac_addr;
	81
	82	sd_event *event;
	83	int event_priority;
	84	sd_ipv4acd_callback_t callback;
	85	void *userdata;
	86	sd_ipv4acd_check_mac_callback_t check_mac_callback;
	87	void *check_mac_userdata;
	88	};
	89
	90	#define log_ipv4acd_errno(acd, error, fmt, ...) \
	91	log_interface_prefix_full_errno( \
	92	"IPv4ACD: ", \
	93	sd_ipv4acd, acd, \
	94	error, fmt, ##__VA_ARGS__)
	95	#define log_ipv4acd(acd, fmt, ...) \
	96	log_interface_prefix_full_errno_zerook( \
	97	"IPv4ACD: ", \
	98	sd_ipv4acd, acd, \
	99	0, fmt, ##__VA_ARGS__)
	100
	101	static const char * const ipv4acd_state_table[_IPV4ACD_STATE_MAX] = {
	102	[IPV4ACD_STATE_INIT] = "init",
	103	[IPV4ACD_STATE_STARTED] = "started",
	104	[IPV4ACD_STATE_WAITING_PROBE] = "waiting-probe",
	105	[IPV4ACD_STATE_PROBING] = "probing",
	106	[IPV4ACD_STATE_WAITING_ANNOUNCE] = "waiting-announce",
	107	[IPV4ACD_STATE_ANNOUNCING] = "announcing",
	108	[IPV4ACD_STATE_RUNNING] = "running",
	109	};
	110
	111	DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(ipv4acd_state, IPv4ACDState);
	112
	113	static void ipv4acd_set_state(sd_ipv4acd *acd, IPv4ACDState st, bool reset_counter) {
	114	assert(acd);
	115	assert(st < _IPV4ACD_STATE_MAX);
	116
	117	if (st != acd->state)
	118	log_ipv4acd(acd, "%s -> %s", ipv4acd_state_to_string(acd->state), ipv4acd_state_to_string(st));
	119
	120	if (st == acd->state && !reset_counter)
	121	acd->n_iteration++;
	122	else {
	123	acd->state = st;
	124	acd->n_iteration = 0;
	125	}
	126	}
	127
	128	static void ipv4acd_reset(sd_ipv4acd *acd) {
	129	assert(acd);
	130
	131	(void) event_source_disable(acd->timer_event_source);
	132	acd->receive_message_event_source = sd_event_source_disable_unref(acd->receive_message_event_source);
	133
	134	acd->fd = safe_close(acd->fd);
	135
	136	ipv4acd_set_state(acd, IPV4ACD_STATE_INIT, true);
	137	}
	138
	139	static sd_ipv4acd ipv4acd_free(sd_ipv4acd acd) {
	140	assert(acd);
	141
	142	ipv4acd_reset(acd);
	143	sd_event_source_unref(acd->timer_event_source);
	144	sd_ipv4acd_detach_event(acd);
	145	free(acd->ifname);
	146	return mfree(acd);
	147	}
	148
	149	DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_ipv4acd, sd_ipv4acd, ipv4acd_free);
	150
	151	int sd_ipv4acd_new(sd_ipv4acd **ret) {
	152	_cleanup_(sd_ipv4acd_unrefp) sd_ipv4acd *acd = NULL;
	153
	154	assert_return(ret, -EINVAL);
	155
	156	acd = new(sd_ipv4acd, 1);
	157	if (!acd)
	158	return -ENOMEM;
	159
	160	*acd = (sd_ipv4acd) {
	161	.n_ref = 1,
	162	.state = IPV4ACD_STATE_INIT,
	163	.time_unit_usec = DEFAULT_ACD_TIMEOUT_USEC / TOTAL_TIME_UNITS,
	164	.ifindex = -1,
	165	.fd = -EBADF,
	166	};
	167
	168	*ret = TAKE_PTR(acd);
	169
	170	return 0;
	171	}
	172
	173	static void ipv4acd_client_notify(sd_ipv4acd *acd, int event) {
	174	assert(acd);
	175
	176	if (!acd->callback)
	177	return;
	178
	179	acd->callback(acd, event, acd->userdata);
	180	}
	181
	182	int sd_ipv4acd_stop(sd_ipv4acd *acd) {
	183	IPv4ACDState old_state;
	184
	185	if (!acd)
	186	return 0;
	187
	188	old_state = acd->state;
	189
	190	ipv4acd_reset(acd);
	191
	192	if (old_state == IPV4ACD_STATE_INIT)
	193	return 0;
	194
	195	log_ipv4acd(acd, "STOPPED");
	196
	197	ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_STOP);
	198
	199	return 0;
	200	}
	201
	202	static int ipv4acd_on_timeout(sd_event_source s, uint64_t usec, void userdata);
	203
	204	static int ipv4acd_set_next_wakeup(sd_ipv4acd *acd, usec_t usec, usec_t random_usec) {
	205	usec_t next_timeout, time_now;
	206
	207	assert(acd);
	208
	209	next_timeout = usec;
	210
	211	if (random_usec > 0)
	212	next_timeout += (usec_t) random_u64() % random_usec;
	213
	214	assert_se(sd_event_now(acd->event, CLOCK_BOOTTIME, &time_now) >= 0);
	215
	216	return event_reset_time(acd->event, &acd->timer_event_source,
	217	CLOCK_BOOTTIME,
	218	time_now + next_timeout, 0,
	219	ipv4acd_on_timeout, acd,
	220	acd->event_priority, "ipv4acd-timer", true);
	221	}
	222
	223	static int ipv4acd_on_timeout(sd_event_source s, uint64_t usec, void userdata) {
	224	sd_ipv4acd *acd = ASSERT_PTR(userdata);
	225	int r = 0;
	226
	227	switch (acd->state) {
	228
	229	case IPV4ACD_STATE_STARTED:
	230	acd->defend_window = 0;
	231
	232	log_ipv4acd(acd,
	233	"Started on address " IPV4_ADDRESS_FMT_STR " with a max timeout of %s",
	234	IPV4_ADDRESS_FMT_VAL(acd->address),
	235	FORMAT_TIMESPAN(TOTAL_TIME_UNITS * acd->time_unit_usec, USEC_PER_MSEC));
	236
	237	ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_PROBE, true);
	238
	239	if (acd->n_conflict >= MAX_CONFLICTS) {
	240	log_ipv4acd(acd, "Max conflicts reached, delaying by %s",
	241	FORMAT_TIMESPAN(RATE_LIMIT_INTERVAL_USEC, 0));
	242	r = ipv4acd_set_next_wakeup(
	243	acd, RATE_LIMIT_INTERVAL_USEC, PROBE_WAIT * acd->time_unit_usec);
	244	} else
	245	r = ipv4acd_set_next_wakeup(acd, 0, PROBE_WAIT * acd->time_unit_usec);
	246	if (r < 0)
	247	goto fail;
	248
	249	break;
	250
	251	case IPV4ACD_STATE_WAITING_PROBE:
	252	case IPV4ACD_STATE_PROBING:
	253	/* Send a probe */
	254	r = arp_send_probe(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
	255	if (r < 0) {
	256	log_ipv4acd_errno(acd, r, "Failed to send ARP probe: %m");
	257	goto fail;
	258	}
	259
	260	log_ipv4acd(acd, "Probing "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));
	261
	262	if (acd->n_iteration < PROBE_NUM - 2) {
	263	ipv4acd_set_state(acd, IPV4ACD_STATE_PROBING, false);
	264
	265	r = ipv4acd_set_next_wakeup(
	266	acd,
	267	PROBE_MIN * acd->time_unit_usec,
	268	(PROBE_MAX - PROBE_MIN) * acd->time_unit_usec);
	269	if (r < 0)
	270	goto fail;
	271	} else {
	272	ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_ANNOUNCE, true);
	273
	274	r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_WAIT * acd->time_unit_usec, 0);
	275	if (r < 0)
	276	goto fail;
	277	}
	278
	279	break;
	280
	281	case IPV4ACD_STATE_ANNOUNCING:
	282	if (acd->n_iteration >= ANNOUNCE_NUM - 1) {
	283	ipv4acd_set_state(acd, IPV4ACD_STATE_RUNNING, false);
	284	break;
	285	}
	286
	287	_fallthrough_;
	288	case IPV4ACD_STATE_WAITING_ANNOUNCE:
	289	/* Send announcement packet */
	290	r = arp_send_announcement(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
	291	if (r < 0) {
	292	log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
	293	goto fail;
	294	}
	295
	296	log_ipv4acd(acd, "Announcing "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));
	297
	298	ipv4acd_set_state(acd, IPV4ACD_STATE_ANNOUNCING, false);
	299
	300	r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_INTERVAL_USEC, 0);
	301	if (r < 0)
	302	goto fail;
	303
	304	if (acd->n_iteration == 0) {
	305	acd->n_conflict = 0;
	306	ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_BIND);
	307	}
	308
	309	break;
	310
	311	default:
	312	assert_not_reached();
	313	}
	314
	315	return 0;
	316
	317	fail:
	318	sd_ipv4acd_stop(acd);
	319	return 0;
	320	}
	321
	322	static bool ipv4acd_arp_conflict(sd_ipv4acd acd, const struct ether_arp arp, bool announced) {
	323	assert(acd);
	324	assert(arp);
	325
	326	/* RFC 5227 section 2.1.1.
	327	* "the host receives any ARP packet (Request or Reply) on the interface where the probe is
	328	* being performed, where the packet's 'sender IP address' is the address being probed for,
	329	* then the host MUST treat this address as being in use by some other host" */
	330	if (memcmp(arp->arp_spa, &acd->address, sizeof(struct in_addr)) == 0)
	331	return true;
	332
	333	if (announced)
	334	/* the TPA matched instead of SPA, this is not a conflict */
	335	return false;
	336
	337	/* "any ARP Probe where the packet's 'target IP address' is the address being probed for, and
	338	* the packet's 'sender hardware address' is not the hardware address of any of the host's
	339	* interfaces, then the host SHOULD similarly treat this as an address conflict" */
	340	if (arp->ea_hdr.ar_op != htobe16(ARPOP_REQUEST))
	341	return false; /* not ARP Request, ignoring. */
	342	if (memeqzero(arp->arp_spa, sizeof(struct in_addr)) == 0)
	343	return false; /* not ARP Probe, ignoring. */
	344	if (memcmp(arp->arp_tpa, &acd->address, sizeof(struct in_addr)) != 0)
	345	return false; /* target IP address does not match, BPF code is broken? */
	346
	347	if (acd->check_mac_callback &&
	348	acd->check_mac_callback(acd, (const struct ether_addr*) arp->arp_sha, acd->check_mac_userdata) > 0)
	349	/* sender hardware is one of the host's interfaces, ignoring. */
	350	return false;
	351
	352	return true; /* conflict! */
	353	}
	354
	355	static void ipv4acd_on_conflict(sd_ipv4acd *acd) {
	356	assert(acd);
	357
	358	acd->n_conflict++;
	359
	360	log_ipv4acd(acd, "Conflict on "IPV4_ADDRESS_FMT_STR" (%u)", IPV4_ADDRESS_FMT_VAL(acd->address), acd->n_conflict);
	361
	362	ipv4acd_reset(acd);
	363	ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_CONFLICT);
	364	}
	365
	366	static int ipv4acd_on_packet(
	367	sd_event_source *s,
	368	int fd,
	369	uint32_t revents,
	370	void *userdata) {
	371
	372	sd_ipv4acd *acd = ASSERT_PTR(userdata);
	373	struct ether_arp packet;
	374	ssize_t n;
	375	int r;
	376
	377	assert(s);
	378	assert(fd >= 0);
	379
	380	n = recv(fd, &packet, sizeof(struct ether_arp), 0);
	381	if (n < 0) {
	382	if (ERRNO_IS_TRANSIENT(errno) \|\| ERRNO_IS_DISCONNECT(errno))
	383	return 0;
	384
	385	log_ipv4acd_errno(acd, errno, "Failed to read ARP packet: %m");
	386	goto fail;
	387	}
	388	if ((size_t) n != sizeof(struct ether_arp)) {
	389	log_ipv4acd(acd, "Ignoring too short ARP packet.");
	390	return 0;
	391	}
	392
	393	switch (acd->state) {
	394
	395	case IPV4ACD_STATE_ANNOUNCING:
	396	case IPV4ACD_STATE_RUNNING:
	397
	398	if (ipv4acd_arp_conflict(acd, &packet, true)) {
	399	usec_t ts;
	400
	401	assert_se(sd_event_now(acd->event, CLOCK_BOOTTIME, &ts) >= 0);
	402
	403	/* Defend address */
	404	if (ts > acd->defend_window) {
	405	acd->defend_window = ts + DEFEND_INTERVAL_USEC;
	406	r = arp_send_announcement(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
	407	if (r < 0) {
	408	log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
	409	goto fail;
	410	}
	411
	412	log_ipv4acd(acd, "Defending "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));
	413
	414	} else
	415	ipv4acd_on_conflict(acd);
	416	}
	417	break;
	418
	419	case IPV4ACD_STATE_STARTED:
	420	case IPV4ACD_STATE_WAITING_PROBE:
	421	case IPV4ACD_STATE_PROBING:
	422	case IPV4ACD_STATE_WAITING_ANNOUNCE:
	423	if (ipv4acd_arp_conflict(acd, &packet, false))
	424	ipv4acd_on_conflict(acd);
	425	break;
	426
	427	default:
	428	assert_not_reached();
	429	}
	430
	431	return 0;
	432
	433	fail:
	434	sd_ipv4acd_stop(acd);
	435	return 0;
	436	}
	437
	438	int sd_ipv4acd_set_ifindex(sd_ipv4acd *acd, int ifindex) {
	439	assert_return(acd, -EINVAL);
	440	assert_return(ifindex > 0, -EINVAL);
	441	assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
	442
	443	acd->ifindex = ifindex;
	444
	445	return 0;
	446	}
	447
	448	int sd_ipv4acd_get_ifindex(sd_ipv4acd *acd) {
	449	if (!acd)
	450	return -EINVAL;
	451
	452	return acd->ifindex;
	453	}
	454
	455	int sd_ipv4acd_set_ifname(sd_ipv4acd acd, const char ifname) {
	456	assert_return(acd, -EINVAL);
	457	assert_return(ifname, -EINVAL);
	458
	459	if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
	460	return -EINVAL;
	461
	462	return free_and_strdup(&acd->ifname, ifname);
	463	}
	464
	465	int sd_ipv4acd_set_timeout(sd_ipv4acd *acd, uint64_t usec) {
	466	assert_return(acd, -EINVAL);
	467
	468	if (usec == 0)
	469	usec = DEFAULT_ACD_TIMEOUT_USEC;
	470
	471	/* Clamp the total duration to a value between 1ms and 1 minute */
	472	acd->time_unit_usec = DIV_ROUND_UP(
	473	CLAMP(usec, 1U * USEC_PER_MSEC, 1U * USEC_PER_MINUTE), TOTAL_TIME_UNITS);
	474
	475	return 0;
	476	}
	477
	478	int sd_ipv4acd_get_ifname(sd_ipv4acd acd, const char *ret) {
	479	int r;
	480
	481	assert_return(acd, -EINVAL);
	482
	483	r = get_ifname(acd->ifindex, &acd->ifname);
	484	if (r < 0)
	485	return r;
	486
	487	if (ret)
	488	*ret = acd->ifname;
	489
	490	return 0;
	491	}
	492
	493	int sd_ipv4acd_set_mac(sd_ipv4acd acd, const struct ether_addr addr) {
	494	int r;
	495
	496	assert_return(acd, -EINVAL);
	497	assert_return(addr, -EINVAL);
	498	assert_return(!ether_addr_is_null(addr), -EINVAL);
	499
	500	acd->mac_addr = *addr;
	501
	502	if (!sd_ipv4acd_is_running(acd))
	503	return 0;
	504
	505	assert(acd->fd >= 0);
	506	r = arp_update_filter(acd->fd, &acd->address, &acd->mac_addr);
	507	if (r < 0) {
	508	ipv4acd_reset(acd);
	509	return r;
	510	}
	511
	512	return 0;
	513	}
	514
	515	int sd_ipv4acd_detach_event(sd_ipv4acd *acd) {
	516	assert_return(acd, -EINVAL);
	517
	518	acd->event = sd_event_unref(acd->event);
	519
	520	return 0;
	521	}
	522
	523	int sd_ipv4acd_attach_event(sd_ipv4acd acd, sd_event event, int64_t priority) {
	524	int r;
	525
	526	assert_return(acd, -EINVAL);
	527	assert_return(!acd->event, -EBUSY);
	528
	529	if (event)
	530	acd->event = sd_event_ref(event);
	531	else {
	532	r = sd_event_default(&acd->event);
	533	if (r < 0)
	534	return r;
	535	}
	536
	537	acd->event_priority = priority;
	538
	539	return 0;
	540	}
	541
	542	int sd_ipv4acd_set_callback(sd_ipv4acd acd, sd_ipv4acd_callback_t cb, void userdata) {
	543	assert_return(acd, -EINVAL);
	544
	545	acd->callback = cb;
	546	acd->userdata = userdata;
	547
	548	return 0;
	549	}
	550
	551	int sd_ipv4acd_set_check_mac_callback(sd_ipv4acd acd, sd_ipv4acd_check_mac_callback_t cb, void userdata) {
	552	assert_return(acd, -EINVAL);
	553
	554	acd->check_mac_callback = cb;
	555	acd->check_mac_userdata = userdata;
	556	return 0;
	557	}
	558
	559	int sd_ipv4acd_set_address(sd_ipv4acd acd, const struct in_addr address) {
	560	int r;
	561
	562	assert_return(acd, -EINVAL);
	563	assert_return(address, -EINVAL);
	564	assert_return(in4_addr_is_set(address), -EINVAL);
	565
	566	if (in4_addr_equal(&acd->address, address))
	567	return 0;
	568
	569	acd->address = *address;
	570
	571	if (!sd_ipv4acd_is_running(acd))
	572	return 0;
	573
	574	assert(acd->fd >= 0);
	575	r = arp_update_filter(acd->fd, &acd->address, &acd->mac_addr);
	576	if (r < 0)
	577	goto fail;
	578
	579	r = ipv4acd_set_next_wakeup(acd, 0, 0);
	580	if (r < 0)
	581	goto fail;
	582
	583	ipv4acd_set_state(acd, IPV4ACD_STATE_STARTED, true);
	584	return 0;
	585
	586	fail:
	587	ipv4acd_reset(acd);
	588	return r;
	589	}
	590
	591	int sd_ipv4acd_get_address(sd_ipv4acd acd, struct in_addr address) {
	592	assert_return(acd, -EINVAL);
	593	assert_return(address, -EINVAL);
	594
	595	*address = acd->address;
	596
	597	return 0;
	598	}
	599
	600	int sd_ipv4acd_is_running(sd_ipv4acd *acd) {
	601	if (!acd)
	602	return false;
	603
	604	return acd->state != IPV4ACD_STATE_INIT;
	605	}
	606
	607	int sd_ipv4acd_is_bound(sd_ipv4acd *acd) {
	608	assert_return(acd, false);
	609
	610	return IN_SET(acd->state, IPV4ACD_STATE_ANNOUNCING, IPV4ACD_STATE_RUNNING);
	611	}
	612
	613	int sd_ipv4acd_start(sd_ipv4acd *acd, bool reset_conflicts) {
	614	int r;
	615
	616	assert_return(acd, -EINVAL);
	617	assert_return(acd->event, -EINVAL);
	618	assert_return(acd->ifindex > 0, -EINVAL);
	619	assert_return(in4_addr_is_set(&acd->address), -EINVAL);
	620	assert_return(!ether_addr_is_null(&acd->mac_addr), -EINVAL);
	621	assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
	622
	623	r = sd_event_get_state(acd->event);
	624	if (r < 0)
	625	return r;
	626	if (r == SD_EVENT_FINISHED)
	627	return -ESTALE;
	628
	629	r = arp_network_bind_raw_socket(acd->ifindex, &acd->address, &acd->mac_addr);
	630	if (r < 0)
	631	return r;
	632
	633	close_and_replace(acd->fd, r);
	634
	635	if (reset_conflicts)
	636	acd->n_conflict = 0;
	637
	638	r = sd_event_add_io(acd->event, &acd->receive_message_event_source, acd->fd, EPOLLIN, ipv4acd_on_packet, acd);
	639	if (r < 0)
	640	goto fail;
	641
	642	r = sd_event_source_set_priority(acd->receive_message_event_source, acd->event_priority);
	643	if (r < 0)
	644	goto fail;
	645
	646	(void) sd_event_source_set_description(acd->receive_message_event_source, "ipv4acd-receive-message");
	647
	648	r = ipv4acd_set_next_wakeup(acd, 0, 0);
	649	if (r < 0)
	650	goto fail;
	651
	652	ipv4acd_set_state(acd, IPV4ACD_STATE_STARTED, true);
	653	return 0;
	654
	655	fail:
	656	ipv4acd_reset(acd);
	657	return r;
	658	}