ipv4acd: rename "ll" parameter to "acd" everywhere
Appears to be a (confusing) left-over from copy/paste when this still was ipv4ll code.
This commit is contained in:
Lennart Poettering
+152
-152
@@ -86,140 +86,140 @@ struct sd_ipv4acd {
|
||||
void* userdata;
|
||||
};
|
||||
|
||||
#define log_ipv4acd_errno(ll, error, fmt, ...) log_internal(LOG_DEBUG, error, __FILE__, __LINE__, __func__, "IPV4ACD: " fmt, ##__VA_ARGS__)
|
||||
#define log_ipv4acd(ll, fmt, ...) log_ipv4acd_errno(ll, 0, fmt, ##__VA_ARGS__)
|
||||
#define log_ipv4acd_errno(acd, error, fmt, ...) log_internal(LOG_DEBUG, error, __FILE__, __LINE__, __func__, "IPV4ACD: " fmt, ##__VA_ARGS__)
|
||||
#define log_ipv4acd(acd, fmt, ...) log_ipv4acd_errno(acd, 0, fmt, ##__VA_ARGS__)
|
||||
|
||||
static void ipv4acd_set_state(sd_ipv4acd *ll, IPv4ACDState st, bool reset_counter) {
|
||||
assert(ll);
|
||||
static void ipv4acd_set_state(sd_ipv4acd *acd, IPv4ACDState st, bool reset_counter) {
|
||||
assert(acd);
|
||||
assert(st < _IPV4ACD_STATE_MAX);
|
||||
|
||||
if (st == ll->state && !reset_counter)
|
||||
ll->n_iteration++;
|
||||
if (st == acd->state && !reset_counter)
|
||||
acd->n_iteration++;
|
||||
else {
|
||||
ll->state = st;
|
||||
ll->n_iteration = 0;
|
||||
acd->state = st;
|
||||
acd->n_iteration = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void ipv4acd_reset(sd_ipv4acd *ll) {
|
||||
assert(ll);
|
||||
static void ipv4acd_reset(sd_ipv4acd *acd) {
|
||||
assert(acd);
|
||||
|
||||
ll->timer_event_source = sd_event_source_unref(ll->timer_event_source);
|
||||
ll->receive_message_event_source = sd_event_source_unref(ll->receive_message_event_source);
|
||||
acd->timer_event_source = sd_event_source_unref(acd->timer_event_source);
|
||||
acd->receive_message_event_source = sd_event_source_unref(acd->receive_message_event_source);
|
||||
|
||||
ll->fd = safe_close(ll->fd);
|
||||
acd->fd = safe_close(acd->fd);
|
||||
|
||||
ipv4acd_set_state(ll, IPV4ACD_STATE_INIT, true);
|
||||
ipv4acd_set_state(acd, IPV4ACD_STATE_INIT, true);
|
||||
}
|
||||
|
||||
sd_ipv4acd *sd_ipv4acd_ref(sd_ipv4acd *ll) {
|
||||
if (!ll)
|
||||
sd_ipv4acd *sd_ipv4acd_ref(sd_ipv4acd *acd) {
|
||||
if (!acd)
|
||||
return NULL;
|
||||
|
||||
assert_se(ll->n_ref >= 1);
|
||||
ll->n_ref++;
|
||||
assert_se(acd->n_ref >= 1);
|
||||
acd->n_ref++;
|
||||
|
||||
return ll;
|
||||
return acd;
|
||||
}
|
||||
|
||||
sd_ipv4acd *sd_ipv4acd_unref(sd_ipv4acd *ll) {
|
||||
if (!ll)
|
||||
sd_ipv4acd *sd_ipv4acd_unref(sd_ipv4acd *acd) {
|
||||
if (!acd)
|
||||
return NULL;
|
||||
|
||||
assert_se(ll->n_ref >= 1);
|
||||
ll->n_ref--;
|
||||
assert_se(acd->n_ref >= 1);
|
||||
acd->n_ref--;
|
||||
|
||||
if (ll->n_ref > 0)
|
||||
if (acd->n_ref > 0)
|
||||
return NULL;
|
||||
|
||||
ipv4acd_reset(ll);
|
||||
sd_ipv4acd_detach_event(ll);
|
||||
ipv4acd_reset(acd);
|
||||
sd_ipv4acd_detach_event(acd);
|
||||
|
||||
free(ll);
|
||||
free(acd);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_new(sd_ipv4acd **ret) {
|
||||
_cleanup_(sd_ipv4acd_unrefp) sd_ipv4acd *ll = NULL;
|
||||
_cleanup_(sd_ipv4acd_unrefp) sd_ipv4acd *acd = NULL;
|
||||
|
||||
assert_return(ret, -EINVAL);
|
||||
|
||||
ll = new0(sd_ipv4acd, 1);
|
||||
if (!ll)
|
||||
acd = new0(sd_ipv4acd, 1);
|
||||
if (!acd)
|
||||
return -ENOMEM;
|
||||
|
||||
ll->n_ref = 1;
|
||||
ll->state = IPV4ACD_STATE_INIT;
|
||||
ll->ifindex = -1;
|
||||
ll->fd = -1;
|
||||
acd->n_ref = 1;
|
||||
acd->state = IPV4ACD_STATE_INIT;
|
||||
acd->ifindex = -1;
|
||||
acd->fd = -1;
|
||||
|
||||
*ret = ll;
|
||||
ll = NULL;
|
||||
*ret = acd;
|
||||
acd = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ipv4acd_client_notify(sd_ipv4acd *ll, int event) {
|
||||
assert(ll);
|
||||
static void ipv4acd_client_notify(sd_ipv4acd *acd, int event) {
|
||||
assert(acd);
|
||||
|
||||
if (!ll->callback)
|
||||
if (!acd->callback)
|
||||
return;
|
||||
|
||||
ll->callback(ll, event, ll->userdata);
|
||||
acd->callback(acd, event, acd->userdata);
|
||||
}
|
||||
|
||||
int sd_ipv4acd_stop(sd_ipv4acd *ll) {
|
||||
assert_return(ll, -EINVAL);
|
||||
int sd_ipv4acd_stop(sd_ipv4acd *acd) {
|
||||
assert_return(acd, -EINVAL);
|
||||
|
||||
ipv4acd_reset(ll);
|
||||
ipv4acd_reset(acd);
|
||||
|
||||
log_ipv4acd(ll, "STOPPED");
|
||||
log_ipv4acd(acd, "STOPPED");
|
||||
|
||||
ipv4acd_client_notify(ll, SD_IPV4ACD_EVENT_STOP);
|
||||
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 *ll, usec_t usec, usec_t random_usec) {
|
||||
static int ipv4acd_set_next_wakeup(sd_ipv4acd *acd, usec_t usec, usec_t random_usec) {
|
||||
_cleanup_(sd_event_source_unrefp) sd_event_source *timer = NULL;
|
||||
usec_t next_timeout, time_now;
|
||||
int r;
|
||||
|
||||
assert(ll);
|
||||
assert(acd);
|
||||
|
||||
next_timeout = usec;
|
||||
|
||||
if (random_usec > 0)
|
||||
next_timeout += (usec_t) random_u64() % random_usec;
|
||||
|
||||
assert_se(sd_event_now(ll->event, clock_boottime_or_monotonic(), &time_now) >= 0);
|
||||
assert_se(sd_event_now(acd->event, clock_boottime_or_monotonic(), &time_now) >= 0);
|
||||
|
||||
r = sd_event_add_time(ll->event, &timer, clock_boottime_or_monotonic(), time_now + next_timeout, 0, ipv4acd_on_timeout, ll);
|
||||
r = sd_event_add_time(acd->event, &timer, clock_boottime_or_monotonic(), time_now + next_timeout, 0, ipv4acd_on_timeout, acd);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_event_source_set_priority(timer, ll->event_priority);
|
||||
r = sd_event_source_set_priority(timer, acd->event_priority);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
(void) sd_event_source_set_description(timer, "ipv4acd-timer");
|
||||
|
||||
sd_event_source_unref(ll->timer_event_source);
|
||||
ll->timer_event_source = timer;
|
||||
sd_event_source_unref(acd->timer_event_source);
|
||||
acd->timer_event_source = timer;
|
||||
timer = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool ipv4acd_arp_conflict(sd_ipv4acd *ll, struct ether_arp *arp) {
|
||||
assert(ll);
|
||||
static bool ipv4acd_arp_conflict(sd_ipv4acd *acd, struct ether_arp *arp) {
|
||||
assert(acd);
|
||||
assert(arp);
|
||||
|
||||
/* see the BPF */
|
||||
if (memcmp(arp->arp_spa, &ll->address, sizeof(ll->address)) == 0)
|
||||
if (memcmp(arp->arp_spa, &acd->address, sizeof(acd->address)) == 0)
|
||||
return true;
|
||||
|
||||
/* the TPA matched instead of the SPA, this is not a conflict */
|
||||
@@ -227,27 +227,27 @@ static bool ipv4acd_arp_conflict(sd_ipv4acd *ll, struct ether_arp *arp) {
|
||||
}
|
||||
|
||||
static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
|
||||
sd_ipv4acd *ll = userdata;
|
||||
sd_ipv4acd *acd = userdata;
|
||||
int r = 0;
|
||||
|
||||
assert(ll);
|
||||
assert(acd);
|
||||
|
||||
switch (ll->state) {
|
||||
switch (acd->state) {
|
||||
|
||||
case IPV4ACD_STATE_STARTED:
|
||||
ipv4acd_set_state(ll, IPV4ACD_STATE_WAITING_PROBE, true);
|
||||
ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_PROBE, true);
|
||||
|
||||
if (ll->n_conflict >= MAX_CONFLICTS) {
|
||||
if (acd->n_conflict >= MAX_CONFLICTS) {
|
||||
char ts[FORMAT_TIMESPAN_MAX];
|
||||
log_ipv4acd(ll, "Max conflicts reached, delaying by %s", format_timespan(ts, sizeof(ts), RATE_LIMIT_INTERVAL_USEC, 0));
|
||||
log_ipv4acd(acd, "Max conflicts reached, delaying by %s", format_timespan(ts, sizeof(ts), RATE_LIMIT_INTERVAL_USEC, 0));
|
||||
|
||||
r = ipv4acd_set_next_wakeup(ll, RATE_LIMIT_INTERVAL_USEC, PROBE_WAIT_USEC);
|
||||
r = ipv4acd_set_next_wakeup(acd, RATE_LIMIT_INTERVAL_USEC, PROBE_WAIT_USEC);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
ll->n_conflict = 0;
|
||||
acd->n_conflict = 0;
|
||||
} else {
|
||||
r = ipv4acd_set_next_wakeup(ll, 0, PROBE_WAIT_USEC);
|
||||
r = ipv4acd_set_next_wakeup(acd, 0, PROBE_WAIT_USEC);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
}
|
||||
@@ -257,28 +257,28 @@ static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata)
|
||||
case IPV4ACD_STATE_WAITING_PROBE:
|
||||
case IPV4ACD_STATE_PROBING:
|
||||
/* Send a probe */
|
||||
r = arp_send_probe(ll->fd, ll->ifindex, ll->address, &ll->mac_addr);
|
||||
r = arp_send_probe(acd->fd, acd->ifindex, acd->address, &acd->mac_addr);
|
||||
if (r < 0) {
|
||||
log_ipv4acd_errno(ll, r, "Failed to send ARP probe: %m");
|
||||
log_ipv4acd_errno(acd, r, "Failed to send ARP probe: %m");
|
||||
goto fail;
|
||||
} else {
|
||||
_cleanup_free_ char *address = NULL;
|
||||
union in_addr_union addr = { .in.s_addr = ll->address };
|
||||
union in_addr_union addr = { .in.s_addr = acd->address };
|
||||
|
||||
(void) in_addr_to_string(AF_INET, &addr, &address);
|
||||
log_ipv4acd(ll, "Probing %s", strna(address));
|
||||
log_ipv4acd(acd, "Probing %s", strna(address));
|
||||
}
|
||||
|
||||
if (ll->n_iteration < PROBE_NUM - 2) {
|
||||
ipv4acd_set_state(ll, IPV4ACD_STATE_PROBING, false);
|
||||
if (acd->n_iteration < PROBE_NUM - 2) {
|
||||
ipv4acd_set_state(acd, IPV4ACD_STATE_PROBING, false);
|
||||
|
||||
r = ipv4acd_set_next_wakeup(ll, PROBE_MIN_USEC, (PROBE_MAX_USEC-PROBE_MIN_USEC));
|
||||
r = ipv4acd_set_next_wakeup(acd, PROBE_MIN_USEC, (PROBE_MAX_USEC-PROBE_MIN_USEC));
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
} else {
|
||||
ipv4acd_set_state(ll, IPV4ACD_STATE_WAITING_ANNOUNCE, true);
|
||||
ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_ANNOUNCE, true);
|
||||
|
||||
r = ipv4acd_set_next_wakeup(ll, ANNOUNCE_WAIT_USEC, 0);
|
||||
r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_WAIT_USEC, 0);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
}
|
||||
@@ -286,8 +286,8 @@ static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata)
|
||||
break;
|
||||
|
||||
case IPV4ACD_STATE_ANNOUNCING:
|
||||
if (ll->n_iteration >= ANNOUNCE_NUM - 1) {
|
||||
ipv4acd_set_state(ll, IPV4ACD_STATE_RUNNING, false);
|
||||
if (acd->n_iteration >= ANNOUNCE_NUM - 1) {
|
||||
ipv4acd_set_state(acd, IPV4ACD_STATE_RUNNING, false);
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -295,22 +295,22 @@ static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata)
|
||||
|
||||
case IPV4ACD_STATE_WAITING_ANNOUNCE:
|
||||
/* Send announcement packet */
|
||||
r = arp_send_announcement(ll->fd, ll->ifindex, ll->address, &ll->mac_addr);
|
||||
r = arp_send_announcement(acd->fd, acd->ifindex, acd->address, &acd->mac_addr);
|
||||
if (r < 0) {
|
||||
log_ipv4acd_errno(ll, r, "Failed to send ARP announcement: %m");
|
||||
log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
|
||||
goto fail;
|
||||
} else
|
||||
log_ipv4acd(ll, "ANNOUNCE");
|
||||
log_ipv4acd(acd, "ANNOUNCE");
|
||||
|
||||
ipv4acd_set_state(ll, IPV4ACD_STATE_ANNOUNCING, false);
|
||||
ipv4acd_set_state(acd, IPV4ACD_STATE_ANNOUNCING, false);
|
||||
|
||||
r = ipv4acd_set_next_wakeup(ll, ANNOUNCE_INTERVAL_USEC, 0);
|
||||
r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_INTERVAL_USEC, 0);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
if (ll->n_iteration == 0) {
|
||||
ll->n_conflict = 0;
|
||||
ipv4acd_client_notify(ll, SD_IPV4ACD_EVENT_BIND);
|
||||
if (acd->n_iteration == 0) {
|
||||
acd->n_conflict = 0;
|
||||
ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_BIND);
|
||||
}
|
||||
|
||||
break;
|
||||
@@ -322,23 +322,23 @@ static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata)
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
sd_ipv4acd_stop(ll);
|
||||
sd_ipv4acd_stop(acd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ipv4acd_on_conflict(sd_ipv4acd *ll) {
|
||||
static void ipv4acd_on_conflict(sd_ipv4acd *acd) {
|
||||
_cleanup_free_ char *address = NULL;
|
||||
union in_addr_union addr = { .in.s_addr = ll->address };
|
||||
union in_addr_union addr = { .in.s_addr = acd->address };
|
||||
|
||||
assert(ll);
|
||||
assert(acd);
|
||||
|
||||
ll->n_conflict++;
|
||||
acd->n_conflict++;
|
||||
|
||||
(void) in_addr_to_string(AF_INET, &addr, &address);
|
||||
log_ipv4acd(ll, "Conflict on %s (%u)", strna(address), ll->n_conflict);
|
||||
log_ipv4acd(acd, "Conflict on %s (%u)", strna(address), acd->n_conflict);
|
||||
|
||||
ipv4acd_reset(ll);
|
||||
ipv4acd_client_notify(ll, SD_IPV4ACD_EVENT_CONFLICT);
|
||||
ipv4acd_reset(acd);
|
||||
ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_CONFLICT);
|
||||
}
|
||||
|
||||
static int ipv4acd_on_packet(
|
||||
@@ -347,13 +347,13 @@ static int ipv4acd_on_packet(
|
||||
uint32_t revents,
|
||||
void *userdata) {
|
||||
|
||||
sd_ipv4acd *ll = userdata;
|
||||
sd_ipv4acd *acd = userdata;
|
||||
struct ether_arp packet;
|
||||
ssize_t n;
|
||||
int r;
|
||||
|
||||
assert(s);
|
||||
assert(ll);
|
||||
assert(acd);
|
||||
assert(fd >= 0);
|
||||
|
||||
n = recv(fd, &packet, sizeof(struct ether_arp), 0);
|
||||
@@ -361,36 +361,36 @@ static int ipv4acd_on_packet(
|
||||
if (errno == EAGAIN || errno == EINTR)
|
||||
return 0;
|
||||
|
||||
log_ipv4acd_errno(ll, errno, "Failed to read ARP packet: %m");
|
||||
log_ipv4acd_errno(acd, errno, "Failed to read ARP packet: %m");
|
||||
goto fail;
|
||||
}
|
||||
if ((size_t) n != sizeof(struct ether_arp)) {
|
||||
log_ipv4acd(ll, "Ignoring too short ARP packet.");
|
||||
log_ipv4acd(acd, "Ignoring too short ARP packet.");
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (ll->state) {
|
||||
switch (acd->state) {
|
||||
|
||||
case IPV4ACD_STATE_ANNOUNCING:
|
||||
case IPV4ACD_STATE_RUNNING:
|
||||
|
||||
if (ipv4acd_arp_conflict(ll, &packet)) {
|
||||
if (ipv4acd_arp_conflict(acd, &packet)) {
|
||||
usec_t ts;
|
||||
|
||||
assert_se(sd_event_now(ll->event, clock_boottime_or_monotonic(), &ts) >= 0);
|
||||
assert_se(sd_event_now(acd->event, clock_boottime_or_monotonic(), &ts) >= 0);
|
||||
|
||||
/* Defend address */
|
||||
if (ts > ll->defend_window) {
|
||||
ll->defend_window = ts + DEFEND_INTERVAL_USEC;
|
||||
r = arp_send_announcement(ll->fd, ll->ifindex, ll->address, &ll->mac_addr);
|
||||
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(ll, r, "Failed to send ARP announcement: %m");
|
||||
log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
|
||||
goto fail;
|
||||
} else
|
||||
log_ipv4acd(ll, "DEFEND");
|
||||
log_ipv4acd(acd, "DEFEND");
|
||||
|
||||
} else
|
||||
ipv4acd_on_conflict(ll);
|
||||
ipv4acd_on_conflict(acd);
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -398,7 +398,7 @@ static int ipv4acd_on_packet(
|
||||
case IPV4ACD_STATE_PROBING:
|
||||
case IPV4ACD_STATE_WAITING_ANNOUNCE:
|
||||
/* BPF ensures this packet indicates a conflict */
|
||||
ipv4acd_on_conflict(ll);
|
||||
ipv4acd_on_conflict(acd);
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -408,119 +408,119 @@ static int ipv4acd_on_packet(
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
sd_ipv4acd_stop(ll);
|
||||
sd_ipv4acd_stop(acd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_set_ifindex(sd_ipv4acd *ll, int ifindex) {
|
||||
assert_return(ll, -EINVAL);
|
||||
int sd_ipv4acd_set_ifindex(sd_ipv4acd *acd, int ifindex) {
|
||||
assert_return(acd, -EINVAL);
|
||||
assert_return(ifindex > 0, -EINVAL);
|
||||
assert_return(ll->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
|
||||
ll->ifindex = ifindex;
|
||||
acd->ifindex = ifindex;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_set_mac(sd_ipv4acd *ll, const struct ether_addr *addr) {
|
||||
assert_return(ll, -EINVAL);
|
||||
int sd_ipv4acd_set_mac(sd_ipv4acd *acd, const struct ether_addr *addr) {
|
||||
assert_return(acd, -EINVAL);
|
||||
assert_return(addr, -EINVAL);
|
||||
assert_return(ll->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
|
||||
ll->mac_addr = *addr;
|
||||
acd->mac_addr = *addr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_detach_event(sd_ipv4acd *ll) {
|
||||
assert_return(ll, -EINVAL);
|
||||
int sd_ipv4acd_detach_event(sd_ipv4acd *acd) {
|
||||
assert_return(acd, -EINVAL);
|
||||
|
||||
ll->event = sd_event_unref(ll->event);
|
||||
acd->event = sd_event_unref(acd->event);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_attach_event(sd_ipv4acd *ll, sd_event *event, int64_t priority) {
|
||||
int sd_ipv4acd_attach_event(sd_ipv4acd *acd, sd_event *event, int64_t priority) {
|
||||
int r;
|
||||
|
||||
assert_return(ll, -EINVAL);
|
||||
assert_return(!ll->event, -EBUSY);
|
||||
assert_return(acd, -EINVAL);
|
||||
assert_return(!acd->event, -EBUSY);
|
||||
|
||||
if (event)
|
||||
ll->event = sd_event_ref(event);
|
||||
acd->event = sd_event_ref(event);
|
||||
else {
|
||||
r = sd_event_default(&ll->event);
|
||||
r = sd_event_default(&acd->event);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
|
||||
ll->event_priority = priority;
|
||||
acd->event_priority = priority;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_set_callback(sd_ipv4acd *ll, sd_ipv4acd_callback_t cb, void *userdata) {
|
||||
assert_return(ll, -EINVAL);
|
||||
int sd_ipv4acd_set_callback(sd_ipv4acd *acd, sd_ipv4acd_callback_t cb, void *userdata) {
|
||||
assert_return(acd, -EINVAL);
|
||||
|
||||
ll->callback = cb;
|
||||
ll->userdata = userdata;
|
||||
acd->callback = cb;
|
||||
acd->userdata = userdata;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_set_address(sd_ipv4acd *ll, const struct in_addr *address) {
|
||||
assert_return(ll, -EINVAL);
|
||||
int sd_ipv4acd_set_address(sd_ipv4acd *acd, const struct in_addr *address) {
|
||||
assert_return(acd, -EINVAL);
|
||||
assert_return(address, -EINVAL);
|
||||
assert_return(ll->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
|
||||
ll->address = address->s_addr;
|
||||
acd->address = address->s_addr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_is_running(sd_ipv4acd *ll) {
|
||||
assert_return(ll, false);
|
||||
int sd_ipv4acd_is_running(sd_ipv4acd *acd) {
|
||||
assert_return(acd, false);
|
||||
|
||||
return ll->state != IPV4ACD_STATE_INIT;
|
||||
return acd->state != IPV4ACD_STATE_INIT;
|
||||
}
|
||||
|
||||
int sd_ipv4acd_start(sd_ipv4acd *ll) {
|
||||
int sd_ipv4acd_start(sd_ipv4acd *acd) {
|
||||
int r;
|
||||
|
||||
assert_return(ll, -EINVAL);
|
||||
assert_return(ll->event, -EINVAL);
|
||||
assert_return(ll->ifindex > 0, -EINVAL);
|
||||
assert_return(ll->address != 0, -EINVAL);
|
||||
assert_return(!ether_addr_is_null(&ll->mac_addr), -EINVAL);
|
||||
assert_return(ll->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
assert_return(acd, -EINVAL);
|
||||
assert_return(acd->event, -EINVAL);
|
||||
assert_return(acd->ifindex > 0, -EINVAL);
|
||||
assert_return(acd->address != 0, -EINVAL);
|
||||
assert_return(!ether_addr_is_null(&acd->mac_addr), -EINVAL);
|
||||
assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
|
||||
|
||||
r = arp_network_bind_raw_socket(ll->ifindex, ll->address, &ll->mac_addr);
|
||||
r = arp_network_bind_raw_socket(acd->ifindex, acd->address, &acd->mac_addr);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
safe_close(ll->fd);
|
||||
ll->fd = r;
|
||||
ll->defend_window = 0;
|
||||
ll->n_conflict = 0;
|
||||
safe_close(acd->fd);
|
||||
acd->fd = r;
|
||||
acd->defend_window = 0;
|
||||
acd->n_conflict = 0;
|
||||
|
||||
r = sd_event_add_io(ll->event, &ll->receive_message_event_source, ll->fd, EPOLLIN, ipv4acd_on_packet, ll);
|
||||
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(ll->receive_message_event_source, ll->event_priority);
|
||||
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(ll->receive_message_event_source, "ipv4acd-receive-message");
|
||||
(void) sd_event_source_set_description(acd->receive_message_event_source, "ipv4acd-receive-message");
|
||||
|
||||
r = ipv4acd_set_next_wakeup(ll, 0, 0);
|
||||
r = ipv4acd_set_next_wakeup(acd, 0, 0);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
ipv4acd_set_state(ll, IPV4ACD_STATE_STARTED, true);
|
||||
ipv4acd_set_state(acd, IPV4ACD_STATE_STARTED, true);
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
ipv4acd_reset(ll);
|
||||
ipv4acd_reset(acd);
|
||||
return r;
|
||||
}
|
||||
|
||||
+13
-13
@@ -37,20 +37,20 @@ enum {
|
||||
};
|
||||
|
||||
typedef struct sd_ipv4acd sd_ipv4acd;
|
||||
typedef void (*sd_ipv4acd_callback_t)(sd_ipv4acd *ll, int event, void *userdata);
|
||||
typedef void (*sd_ipv4acd_callback_t)(sd_ipv4acd *acd, int event, void *userdata);
|
||||
|
||||
int sd_ipv4acd_detach_event(sd_ipv4acd *ll);
|
||||
int sd_ipv4acd_attach_event(sd_ipv4acd *ll, sd_event *event, int64_t priority);
|
||||
int sd_ipv4acd_get_address(sd_ipv4acd *ll, struct in_addr *address);
|
||||
int sd_ipv4acd_set_callback(sd_ipv4acd *ll, sd_ipv4acd_callback_t cb, void *userdata);
|
||||
int sd_ipv4acd_set_mac(sd_ipv4acd *ll, const struct ether_addr *addr);
|
||||
int sd_ipv4acd_set_ifindex(sd_ipv4acd *ll, int interface_index);
|
||||
int sd_ipv4acd_set_address(sd_ipv4acd *ll, const struct in_addr *address);
|
||||
int sd_ipv4acd_is_running(sd_ipv4acd *ll);
|
||||
int sd_ipv4acd_start(sd_ipv4acd *ll);
|
||||
int sd_ipv4acd_stop(sd_ipv4acd *ll);
|
||||
sd_ipv4acd *sd_ipv4acd_ref(sd_ipv4acd *ll);
|
||||
sd_ipv4acd *sd_ipv4acd_unref(sd_ipv4acd *ll);
|
||||
int sd_ipv4acd_detach_event(sd_ipv4acd *acd);
|
||||
int sd_ipv4acd_attach_event(sd_ipv4acd *acd, sd_event *event, int64_t priority);
|
||||
int sd_ipv4acd_get_address(sd_ipv4acd *acd, struct in_addr *address);
|
||||
int sd_ipv4acd_set_callback(sd_ipv4acd *acd, sd_ipv4acd_callback_t cb, void *userdata);
|
||||
int sd_ipv4acd_set_mac(sd_ipv4acd *acd, const struct ether_addr *addr);
|
||||
int sd_ipv4acd_set_ifindex(sd_ipv4acd *acd, int interface_index);
|
||||
int sd_ipv4acd_set_address(sd_ipv4acd *acd, const struct in_addr *address);
|
||||
int sd_ipv4acd_is_running(sd_ipv4acd *acd);
|
||||
int sd_ipv4acd_start(sd_ipv4acd *acd);
|
||||
int sd_ipv4acd_stop(sd_ipv4acd *acd);
|
||||
sd_ipv4acd *sd_ipv4acd_ref(sd_ipv4acd *acd);
|
||||
sd_ipv4acd *sd_ipv4acd_unref(sd_ipv4acd *acd);
|
||||
int sd_ipv4acd_new(sd_ipv4acd **ret);
|
||||
|
||||
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_ipv4acd, sd_ipv4acd_unref);
|
||||
|
||||
Reference in New Issue
Block a user