// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2015 - 2018 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-acd-manager.h"
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "platform/nm-platform.h"
#include "nm-utils.h"
#include "NetworkManagerUtils.h"
#include "n-acd/src/n-acd.h"
/*****************************************************************************/
typedef enum {
STATE_INIT,
STATE_PROBING,
STATE_PROBE_DONE,
STATE_ANNOUNCING,
} State;
typedef struct {
in_addr_t address;
gboolean duplicate;
NAcdProbe *probe;
} AddressInfo;
struct _NMAcdManager {
int ifindex;
guint8 hwaddr[ETH_ALEN];
State state;
GHashTable *addresses;
guint completed;
NAcd *acd;
GSource *event_source;
NMAcdCallbacks callbacks;
gpointer user_data;
};
/*****************************************************************************/
#define _NMLOG_DOMAIN LOGD_IP4
#define _NMLOG_PREFIX_NAME "acd"
#define _NMLOG(level, ...) \
G_STMT_START { \
char _sbuf[64]; \
\
nm_log ((level), _NMLOG_DOMAIN, \
self && self->ifindex > 0 ? nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex) : NULL, \
NULL, \
"%s%s: " _NM_UTILS_MACRO_FIRST (__VA_ARGS__), \
_NMLOG_PREFIX_NAME, \
self ? nm_sprintf_buf (_sbuf, "[%p,%d]", self, self->ifindex) : "" \
_NM_UTILS_MACRO_REST (__VA_ARGS__)); \
} G_STMT_END
/*****************************************************************************/
static const char *
_acd_event_to_string (unsigned int event)
{
switch (event) {
case N_ACD_EVENT_READY:
return "ready";
case N_ACD_EVENT_USED:
return "used";
case N_ACD_EVENT_DEFENDED:
return "defended";
case N_ACD_EVENT_CONFLICT:
return "conflict";
case N_ACD_EVENT_DOWN:
return "down";
}
return NULL;
}
#define ACD_EVENT_TO_STRING_BUF_SIZE 50
static const char *
_acd_event_to_string_buf (unsigned event, char buffer[static ACD_EVENT_TO_STRING_BUF_SIZE])
{
const char *s;
s = _acd_event_to_string (event);
if (s)
return s;
g_snprintf (buffer, ACD_EVENT_TO_STRING_BUF_SIZE, "(%u)", event);
return buffer;
}
static const char *
acd_error_to_string (int error)
{
if (error < 0)
return nm_strerror_native (-error);
switch (error) {
case _N_ACD_E_SUCCESS:
return "success";
case N_ACD_E_PREEMPTED:
return "preempted";
case N_ACD_E_INVALID_ARGUMENT:
return "invalid argument";
}
g_return_val_if_reached (NULL);
}
static int
acd_error_to_nmerr (int error, gboolean always_fail)
{
if (error < 0)
return -nm_errno_native (error);
if (always_fail) {
if (NM_IN_SET (error, N_ACD_E_PREEMPTED,
N_ACD_E_INVALID_ARGUMENT))
return -NME_UNSPEC;
g_return_val_if_reached (-NME_UNSPEC);
}
/* so, @error is either zero (indicating success) or one
* of the special status codes like N_ACD_E_*. In both cases,
* return the positive value here. */
if (NM_IN_SET (error, _N_ACD_E_SUCCESS,
N_ACD_E_PREEMPTED,
N_ACD_E_INVALID_ARGUMENT))
return error;
g_return_val_if_reached (error);
}
/*****************************************************************************/
/**
* nm_acd_manager_add_address:
* @self: a #NMAcdManager
* @address: an IP address
*
* Add @address to the list of IP addresses to probe.
* Returns: %TRUE on success, %FALSE if the address was already in the list
*/
gboolean
nm_acd_manager_add_address (NMAcdManager *self, in_addr_t address)
{
AddressInfo *info;
g_return_val_if_fail (self, FALSE);
g_return_val_if_fail (self->state == STATE_INIT, FALSE);
if (g_hash_table_lookup (self->addresses, GUINT_TO_POINTER (address)))
return FALSE;
info = g_slice_new0 (AddressInfo);
info->address = address;
g_hash_table_insert (self->addresses, GUINT_TO_POINTER (address), info);
return TRUE;
}
static gboolean
acd_event (int fd,
GIOCondition condition,
gpointer data)
{
NMAcdManager *self = data;
NAcdEvent *event;
AddressInfo *info;
gboolean emit_probe_terminated = FALSE;
char address_str[INET_ADDRSTRLEN];
int r;
if (n_acd_dispatch (self->acd))
return G_SOURCE_CONTINUE;
while ( !n_acd_pop_event (self->acd, &event)
&& event) {
char to_string_buffer[ACD_EVENT_TO_STRING_BUF_SIZE];
gs_free char *hwaddr_str = NULL;
gboolean check_probing_done = FALSE;
switch (event->event) {
case N_ACD_EVENT_READY:
n_acd_probe_get_userdata (event->ready.probe, (void **) &info);
info->duplicate = FALSE;
if (self->state == STATE_ANNOUNCING) {
/* fake probe ended, start announcing */
r = n_acd_probe_announce (info->probe, N_ACD_DEFEND_ONCE);
if (r) {
_LOGW ("couldn't announce address %s on interface '%s': %s",
_nm_utils_inet4_ntop (info->address, address_str),
nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex),
acd_error_to_string (r));
} else {
_LOGD ("announcing address %s",
_nm_utils_inet4_ntop (info->address, address_str));
}
}
check_probing_done = TRUE;
break;
case N_ACD_EVENT_USED:
n_acd_probe_get_userdata (event->used.probe, (void **) &info);
info->duplicate = TRUE;
check_probing_done = TRUE;
break;
case N_ACD_EVENT_DEFENDED:
n_acd_probe_get_userdata (event->defended.probe, (void **) &info);
_LOGD ("defended address %s from host %s",
_nm_utils_inet4_ntop (info->address, address_str),
(hwaddr_str = nm_utils_hwaddr_ntoa (event->defended.sender,
event->defended.n_sender)));
break;
case N_ACD_EVENT_CONFLICT:
n_acd_probe_get_userdata (event->conflict.probe, (void **) &info);
_LOGW ("conflict for address %s detected with host %s on interface '%s'",
_nm_utils_inet4_ntop (info->address, address_str),
(hwaddr_str = nm_utils_hwaddr_ntoa (event->defended.sender,
event->defended.n_sender)),
nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex));
break;
default:
_LOGD ("unhandled event '%s'", _acd_event_to_string_buf (event->event, to_string_buffer));
break;
}
if ( check_probing_done
&& self->state == STATE_PROBING
&& ++self->completed == g_hash_table_size (self->addresses)) {
self->state = STATE_PROBE_DONE;
emit_probe_terminated = TRUE;
}
}
if (emit_probe_terminated) {
if (self->callbacks.probe_terminated_callback) {
self->callbacks.probe_terminated_callback (self,
self->user_data);
}
}
return G_SOURCE_CONTINUE;
}
static gboolean
acd_probe_add (NMAcdManager *self,
AddressInfo *info,
guint64 timeout)
{
NAcdProbeConfig *probe_config;
int r;
char sbuf[NM_UTILS_INET_ADDRSTRLEN];
r = n_acd_probe_config_new (&probe_config);
if (r) {
_LOGW ("could not create probe config for %s on interface '%s': %s",
_nm_utils_inet4_ntop (info->address, sbuf),
nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex),
acd_error_to_string (r));
return FALSE;
}
n_acd_probe_config_set_ip (probe_config, (struct in_addr) { info->address });
n_acd_probe_config_set_timeout (probe_config, timeout);
r = n_acd_probe (self->acd, &info->probe, probe_config);
if (r) {
_LOGW ("could not start probe for %s on interface '%s': %s",
_nm_utils_inet4_ntop (info->address, sbuf),
nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex),
acd_error_to_string (r));
n_acd_probe_config_free (probe_config);
return FALSE;
}
n_acd_probe_set_userdata (info->probe, info);
n_acd_probe_config_free (probe_config);
return TRUE;
}
static int
acd_init (NMAcdManager *self)
{
NAcdConfig *config;
int r;
if (self->acd)
return 0;
r = n_acd_config_new (&config);
if (r)
return r;
n_acd_config_set_ifindex (config, self->ifindex);
n_acd_config_set_transport (config, N_ACD_TRANSPORT_ETHERNET);
n_acd_config_set_mac (config, self->hwaddr, ETH_ALEN);
r = n_acd_new (&self->acd, config);
n_acd_config_free (config);
return r;
}
/**
* nm_acd_manager_start_probe:
* @self: a #NMAcdManager
* @timeout: maximum probe duration in milliseconds
* @error: location to store error, or %NULL
*
* Start probing IP addresses for duplicates; when the probe terminates a
* PROBE_TERMINATED signal is emitted.
*
* Returns: 0 on success or a negative NetworkManager error code (NME_*).
*/
int
nm_acd_manager_start_probe (NMAcdManager *self, guint timeout)
{
GHashTableIter iter;
AddressInfo *info;
gboolean success = FALSE;
int fd, r;
g_return_val_if_fail (self, FALSE);
g_return_val_if_fail (self->state == STATE_INIT, FALSE);
r = acd_init (self);
if (r) {
_LOGW ("couldn't init ACD for probing on interface '%s': %s",
nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex),
acd_error_to_string (r));
return acd_error_to_nmerr (r, TRUE);
}
self->completed = 0;
g_hash_table_iter_init (&iter, self->addresses);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info))
success |= acd_probe_add (self, info, timeout);
if (success)
self->state = STATE_PROBING;
nm_assert (!self->event_source);
n_acd_get_fd (self->acd, &fd);
self->event_source = nm_g_unix_fd_source_new (fd,
G_IO_IN,
G_PRIORITY_DEFAULT,
acd_event,
self,
NULL);
g_source_attach (self->event_source, NULL);
return success ? 0 : -NME_UNSPEC;
}
/**
* nm_acd_manager_check_address:
* @self: a #NMAcdManager
* @address: an IP address
*
* Check if an IP address is duplicate. @address must have been added with
* nm_acd_manager_add_address().
*
* Returns: %TRUE if the address is not duplicate, %FALSE otherwise
*/
gboolean
nm_acd_manager_check_address (NMAcdManager *self, in_addr_t address)
{
AddressInfo *info;
g_return_val_if_fail (self, FALSE);
g_return_val_if_fail (NM_IN_SET (self->state, STATE_INIT, STATE_PROBE_DONE), FALSE);
info = g_hash_table_lookup (self->addresses, GUINT_TO_POINTER (address));
g_return_val_if_fail (info, FALSE);
return !info->duplicate;
}
/**
* nm_acd_manager_announce_addresses:
* @self: a #NMAcdManager
*
* Start announcing addresses.
*
* Returns: a negative NetworkManager error number or zero on success.
*/
int
nm_acd_manager_announce_addresses (NMAcdManager *self)
{
GHashTableIter iter;
AddressInfo *info;
int r;
int fd;
gboolean success = TRUE;
r = acd_init (self);
if (r) {
_LOGW ("couldn't init ACD for announcing addresses on interface '%s': %s",
nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex),
acd_error_to_string (r));
return acd_error_to_nmerr (r, TRUE);
}
if (self->state == STATE_INIT) {
/* n-acd can't announce without probing, therefore let's
* start a fake probe with zero timeout and then perform
* the announcement. */
g_hash_table_iter_init (&iter, self->addresses);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info)) {
if (!acd_probe_add (self, info, 0))
success = FALSE;
}
self->state = STATE_ANNOUNCING;
} else if (self->state == STATE_ANNOUNCING) {
char sbuf[NM_UTILS_INET_ADDRSTRLEN];
g_hash_table_iter_init (&iter, self->addresses);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info)) {
if (info->duplicate)
continue;
r = n_acd_probe_announce (info->probe, N_ACD_DEFEND_ONCE);
if (r) {
_LOGW ("couldn't announce address %s on interface '%s': %s",
_nm_utils_inet4_ntop (info->address, sbuf),
nm_platform_link_get_name (NM_PLATFORM_GET, self->ifindex),
acd_error_to_string (r));
success = FALSE;
} else
_LOGD ("announcing address %s", _nm_utils_inet4_ntop (info->address, sbuf));
}
}
if (!self->event_source) {
n_acd_get_fd (self->acd, &fd);
self->event_source = nm_g_unix_fd_source_new (fd,
G_IO_IN,
G_PRIORITY_DEFAULT,
acd_event,
self,
NULL);
g_source_attach (self->event_source, NULL);
}
return success ? 0 : -NME_UNSPEC;
}
static void
destroy_address_info (gpointer data)
{
AddressInfo *info = (AddressInfo *) data;
n_acd_probe_free (info->probe);
g_slice_free (AddressInfo, info);
}
/*****************************************************************************/
NMAcdManager *
nm_acd_manager_new (int ifindex,
const guint8 *hwaddr,
guint hwaddr_len,
const NMAcdCallbacks *callbacks,
gpointer user_data)
{
NMAcdManager *self;
g_return_val_if_fail (ifindex > 0, NULL);
g_return_val_if_fail (hwaddr, NULL);
g_return_val_if_fail (hwaddr_len == ETH_ALEN, NULL);
self = g_slice_new0 (NMAcdManager);
if (callbacks)
self->callbacks = *callbacks;
self->user_data = user_data;
self->addresses = g_hash_table_new_full (nm_direct_hash, NULL,
NULL, destroy_address_info);
self->state = STATE_INIT;
self->ifindex = ifindex;
memcpy (self->hwaddr, hwaddr, ETH_ALEN);
return self;
}
void
nm_acd_manager_free (NMAcdManager *self)
{
g_return_if_fail (self);
if (self->callbacks.user_data_destroy)
self->callbacks.user_data_destroy (self->user_data);
nm_clear_pointer (&self->addresses, g_hash_table_destroy);
nm_clear_g_source_inst (&self->event_source);
nm_clear_pointer (&self->acd, n_acd_unref);
g_slice_free (NMAcdManager, self);
}