subsys/net/ip/ipv4_acd.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2017 Matthias Boesl
  * Copyright (c) 2018 Intel Corporation
  * Copyright (c) 2024 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 /** @file
  * @brief IPv4 address conflict detection
  */

 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(net_ipv4_acd, CONFIG_NET_IPV4_ACD_LOG_LEVEL);

 #include <zephyr/net/ethernet.h>
 #include <zephyr/net/net_if.h>
 #include <zephyr/net/net_l2.h>
 #include <zephyr/net/net_mgmt.h>
 #include <zephyr/net/net_pkt.h>
 #include <zephyr/random/random.h>
 #include <zephyr/sys/slist.h>

 #include "ipv4.h"
 #include "net_private.h"
 #include "../l2/ethernet/arp.h"

 static K_MUTEX_DEFINE(lock);

 /* Address conflict detection timer. */
 static struct k_work_delayable ipv4_acd_timer;

 /* List of IPv4 addresses under an active conflict detection. */
 static sys_slist_t active_acd_timers;

 #define BUF_ALLOC_TIMEOUT K_MSEC(100)

 /* Initial random delay*/
 #define IPV4_ACD_PROBE_WAIT 1

 /* Number of probe packets */
 #define IPV4_ACD_PROBE_NUM 3

 /* Minimum delay till repeated probe */
 #define IPV4_ACD_PROBE_MIN 1

 /* Maximum delay till repeated probe */
 #define IPV4_ACD_PROBE_MAX 2

 /* Delay before announcing */
 #define IPV4_ACD_ANNOUNCE_WAIT 2

 /* Number of announcement packets */
 #define IPV4_ACD_ANNOUNCE_NUM 2

 /* Time between announcement packets */
 #define IPV4_ACD_ANNOUNCE_INTERVAL 2

 /* Max conflicts before rate limiting */
 #define IPV4_ACD_MAX_CONFLICTS 10

 /* Delay between successive attempts */
 #define IPV4_ACD_RATE_LIMIT_INTERVAL 60

 /* Minimum interval between defensive ARPs */
 #define IPV4_ACD_DEFEND_INTERVAL 10

 enum ipv4_acd_state {
 	IPV4_ACD_PROBE,    /* Probing state */
 	IPV4_ACD_ANNOUNCE, /* Announce state */
 };

 static struct net_pkt *ipv4_acd_prepare_arp(struct net_if *iface,
 					    struct in_addr *sender_ip,
 					    struct in_addr *target_ip)
 {
 	struct net_pkt *pkt;

 	/* We provide AF_UNSPEC to the allocator: this packet does not
 	 * need space for any IPv4 header.
 	 */
 	pkt = net_pkt_alloc_with_buffer(iface, sizeof(struct net_arp_hdr),
 					AF_UNSPEC, 0, BUF_ALLOC_TIMEOUT);
 	if (!pkt) {
 		return NULL;
 	}

 	net_pkt_set_family(pkt, AF_INET);
 	net_pkt_set_ipv4_acd(pkt, true);

 	return net_arp_prepare(pkt, target_ip, sender_ip);
 }

 static void ipv4_acd_send_probe(struct net_if_addr *ifaddr)
 {
 	struct net_if *iface = net_if_get_by_index(ifaddr->ifindex);
 	struct in_addr unspecified = { 0 };
 	struct net_pkt *pkt;

 	pkt = ipv4_acd_prepare_arp(iface, &unspecified, &ifaddr->address.in_addr);
 	if (!pkt) {
 		NET_DBG("Failed to prepare probe %p", iface);
 		return;
 	}

 	if (net_if_send_data(iface, pkt) == NET_DROP) {
 		net_pkt_unref(pkt);
 	}
 }

 static void ipv4_acd_send_announcement(struct net_if_addr *ifaddr)
 {
 	struct net_if *iface = net_if_get_by_index(ifaddr->ifindex);
 	struct net_pkt *pkt;

 	pkt = ipv4_acd_prepare_arp(iface, &ifaddr->address.in_addr,
 				   &ifaddr->address.in_addr);
 	if (!pkt) {
 		NET_DBG("Failed to prepare announcement %p", iface);
 		return;
 	}

 	if (net_if_send_data(iface, pkt) == NET_DROP) {
 		net_pkt_unref(pkt);
 	}
 }

 static void acd_timer_reschedule(void)
 {
 	k_timepoint_t expiry = sys_timepoint_calc(K_FOREVER);
 	k_timeout_t timeout;
 	sys_snode_t *node;

 	SYS_SLIST_FOR_EACH_NODE(&active_acd_timers, node) {
 		struct net_if_addr *ifaddr =
 			CONTAINER_OF(node, struct net_if_addr, acd_node);

 		if (sys_timepoint_cmp(ifaddr->acd_timeout, expiry) < 0) {
 			expiry = ifaddr->acd_timeout;
 		}
 	}

 	timeout = sys_timepoint_timeout(expiry);
 	if (K_TIMEOUT_EQ(timeout, K_FOREVER)) {
 		k_work_cancel_delayable(&ipv4_acd_timer);
 		return;
 	}

 	k_work_reschedule(&ipv4_acd_timer, timeout);
 }

 static void ipv4_acd_manage_timeout(struct net_if_addr *ifaddr)
 {
 	switch (ifaddr->acd_state) {
 	case IPV4_ACD_PROBE:
 		if (ifaddr->acd_count < IPV4_ACD_PROBE_NUM) {
 			uint32_t delay;

 			NET_DBG("Sending probe for %s",
 				net_sprint_ipv4_addr(&ifaddr->address.in_addr));

 			ipv4_acd_send_probe(ifaddr);

 			ifaddr->acd_count++;
 			if (ifaddr->acd_count < IPV4_ACD_PROBE_NUM) {
 				delay = sys_rand32_get();
 				delay %= MSEC_PER_SEC * (IPV4_ACD_PROBE_MAX - IPV4_ACD_PROBE_MIN);
 				delay += MSEC_PER_SEC * IPV4_ACD_PROBE_MIN;
 			} else {
 				delay = MSEC_PER_SEC * IPV4_ACD_ANNOUNCE_WAIT;

 			}

 			ifaddr->acd_timeout = sys_timepoint_calc(K_MSEC(delay));

 			break;
 		}

 		net_if_ipv4_acd_succeeded(net_if_get_by_index(ifaddr->ifindex),
 					  ifaddr);

 		ifaddr->acd_state = IPV4_ACD_ANNOUNCE;
 		ifaddr->acd_count = 0;
 		__fallthrough;
 	case IPV4_ACD_ANNOUNCE:
 		if (ifaddr->acd_count < IPV4_ACD_ANNOUNCE_NUM) {
 			NET_DBG("Sending announcement for %s",
 				net_sprint_ipv4_addr(&ifaddr->address.in_addr));

 			ipv4_acd_send_announcement(ifaddr);

 			ifaddr->acd_count++;
 			ifaddr->acd_timeout = sys_timepoint_calc(
 					K_SECONDS(IPV4_ACD_ANNOUNCE_INTERVAL));

 			break;
 		}

 		NET_DBG("IPv4 conflict detection done for %s",
 			net_sprint_ipv4_addr(&ifaddr->address.in_addr));

 		/* Timeout will be used to determine whether DEFEND_INTERVAL
 		 * has expired in case of conflicts.
 		 */
 		ifaddr->acd_timeout = sys_timepoint_calc(K_NO_WAIT);

 		sys_slist_find_and_remove(&active_acd_timers, &ifaddr->acd_node);
 		break;
 	default:
 		break;
 	}
 }

 static void ipv4_acd_timeout(struct k_work *work)
 {
 	sys_snode_t *current, *next;

 	ARG_UNUSED(work);

 	k_mutex_lock(&lock, K_FOREVER);

 	SYS_SLIST_FOR_EACH_NODE_SAFE(&active_acd_timers, current, next) {
 		struct net_if_addr *ifaddr =
 			CONTAINER_OF(current, struct net_if_addr, acd_node);

 		if (sys_timepoint_expired(ifaddr->acd_timeout)) {
 			ipv4_acd_manage_timeout(ifaddr);
 		}
 	}

 	acd_timer_reschedule();

 	k_mutex_unlock(&lock);
 }

 static void acd_start_timer(struct net_if *iface, struct net_if_addr *ifaddr)
 {
 	uint32_t delay;

 	sys_slist_find_and_remove(&active_acd_timers, &ifaddr->acd_node);
 	sys_slist_append(&active_acd_timers, &ifaddr->acd_node);

 	if (iface->config.ip.ipv4->conflict_cnt >= IPV4_ACD_MAX_CONFLICTS) {
 		NET_DBG("Rate limiting");
 		delay = MSEC_PER_SEC * IPV4_ACD_RATE_LIMIT_INTERVAL;
 	} else {
 		/* Initial probe should be delayed by a random time interval
 		 * between 0 and PROBE_WAIT.
 		 */
 		delay = sys_rand32_get() % (MSEC_PER_SEC * IPV4_ACD_PROBE_WAIT);
 	}

 	ifaddr->acd_timeout = sys_timepoint_calc(K_MSEC(delay));

 	acd_timer_reschedule();
 }

 enum net_verdict net_ipv4_acd_input(struct net_if *iface, struct net_pkt *pkt)
 {
 	sys_snode_t *current, *next;
 	struct net_arp_hdr *arp_hdr;
 	struct net_if_ipv4 *ipv4;

 	if (net_pkt_get_len(pkt) < sizeof(struct net_arp_hdr)) {
 		NET_DBG("Invalid ARP header (len %zu, min %zu bytes)",
 			net_pkt_get_len(pkt), sizeof(struct net_arp_hdr));
 		return NET_DROP;
 	}

 	arp_hdr = NET_ARP_HDR(pkt);

 	k_mutex_lock(&lock, K_FOREVER);

 	SYS_SLIST_FOR_EACH_NODE_SAFE(&active_acd_timers, current, next) {
 		struct net_if_addr *ifaddr =
 			CONTAINER_OF(current, struct net_if_addr, acd_node);
 		struct net_if *addr_iface = net_if_get_by_index(ifaddr->ifindex);
 		struct net_linkaddr *ll_addr;

 		if (iface != addr_iface) {
 			continue;
 		}

 		if (ifaddr->acd_state != IPV4_ACD_PROBE) {
 			continue;
 		}

 		ll_addr = net_if_get_link_addr(addr_iface);

 		/* RFC 5227, ch. 2.1.1 Probe Details:
 		 * - ARP Request/Reply with Sender IP address match OR,
 		 * - ARP Probe where Target IP address match with different sender HW address,
 		 * indicate a conflict.
 		 * ARP Probe has an all-zero sender IP address
 		 */
 		if (net_ipv4_addr_cmp_raw(arp_hdr->src_ipaddr,
 					  (uint8_t *)&ifaddr->address.in_addr) ||
 		    (net_ipv4_addr_cmp_raw(arp_hdr->dst_ipaddr,
 					  (uint8_t *)&ifaddr->address.in_addr) &&
 				 (memcmp(&arp_hdr->src_hwaddr, ll_addr->addr, ll_addr->len) != 0) &&
 				 (net_ipv4_addr_cmp_raw(arp_hdr->src_ipaddr,
 						(uint8_t *)&(struct in_addr)INADDR_ANY_INIT)))) {
 			NET_DBG("Conflict detected from %s for %s",
 				net_sprint_ll_addr((uint8_t *)&arp_hdr->src_hwaddr,
 						   arp_hdr->hwlen),
 				net_sprint_ipv4_addr(&ifaddr->address.in_addr));

 			iface->config.ip.ipv4->conflict_cnt++;

 			net_if_ipv4_acd_failed(addr_iface, ifaddr);

 			k_mutex_unlock(&lock);

 			return NET_DROP;
 		}
 	}

 	k_mutex_unlock(&lock);

 	ipv4 = iface->config.ip.ipv4;
 	if (ipv4 == NULL) {
 		goto out;
 	}

 	/* Passive conflict detection - try to defend already confirmed
 	 * addresses.
 	 */
 	ARRAY_FOR_EACH(ipv4->unicast, i) {
 		struct net_if_addr *ifaddr = &ipv4->unicast[i].ipv4;
 		struct net_linkaddr *ll_addr = net_if_get_link_addr(iface);

 		if (!ifaddr->is_used) {
 			continue;
 		}

 		if (net_ipv4_addr_cmp_raw(arp_hdr->src_ipaddr,
 					  (uint8_t *)&ifaddr->address.in_addr) &&
 		    memcmp(&arp_hdr->src_hwaddr, ll_addr->addr, ll_addr->len) != 0) {
 			NET_DBG("Conflict detected from %s for %s",
 				net_sprint_ll_addr((uint8_t *)&arp_hdr->src_hwaddr,
 						   arp_hdr->hwlen),
 				net_sprint_ipv4_addr(&ifaddr->address.in_addr));

 			ipv4->conflict_cnt++;

 			/* In case timer has expired, we're past DEFEND_INTERVAL
 			 * and can try to defend again
 			 */
 			if (sys_timepoint_expired(ifaddr->acd_timeout)) {
 				NET_DBG("Defending address %s",
 					net_sprint_ipv4_addr(&ifaddr->address.in_addr));
 				ipv4_acd_send_announcement(ifaddr);
 				ifaddr->acd_timeout = sys_timepoint_calc(
 					K_SECONDS(IPV4_ACD_DEFEND_INTERVAL));
 			} else {
 				NET_DBG("Reporting conflict on %s",
 					net_sprint_ipv4_addr(&ifaddr->address.in_addr));
 				/* Otherwise report the conflict and let the
 				 * application decide.
 				 */
 				net_mgmt_event_notify_with_info(
 					NET_EVENT_IPV4_ACD_CONFLICT, iface,
 					&ifaddr->address.in_addr,
 					sizeof(struct in_addr));
 			}

 			break;
 		}
 	}

 out:
 	return NET_CONTINUE;
 }

 void net_ipv4_acd_init(void)
 {
 	k_work_init_delayable(&ipv4_acd_timer, ipv4_acd_timeout);
 }

 int net_ipv4_acd_start(struct net_if *iface, struct net_if_addr *ifaddr)
 {
 	/* Address conflict detection is based on ARP, so can only be done on
 	 * supporting interfaces.
 	 */
 	if (!(net_if_l2(iface) == &NET_L2_GET_NAME(ETHERNET) ||
 	      net_eth_is_vlan_interface(iface))) {
 		net_if_ipv4_acd_succeeded(iface, ifaddr);
 		return 0;
 	}

 	k_mutex_lock(&lock, K_FOREVER);

 	ifaddr->ifindex = net_if_get_by_iface(iface);
 	ifaddr->acd_state = IPV4_ACD_PROBE;
 	ifaddr->acd_count = 0;

 	acd_start_timer(iface, ifaddr);

 	k_mutex_unlock(&lock);

 	return 0;
 }

 void net_ipv4_acd_cancel(struct net_if *iface, struct net_if_addr *ifaddr)
 {
 	/* Address conflict detection is based on ARP, so can only be done on
 	 * supporting interfaces.
 	 */
 	if (!(net_if_l2(iface) == &NET_L2_GET_NAME(ETHERNET) ||
 	      net_eth_is_vlan_interface(iface))) {
 		return;
 	}

 	k_mutex_lock(&lock, K_FOREVER);

 	sys_slist_find_and_remove(&active_acd_timers, &ifaddr->acd_node);
 	acd_timer_reschedule();

 	k_mutex_unlock(&lock);
 }
	/*
	* Copyright (c) 2017 Matthias Boesl
	* Copyright (c) 2018 Intel Corporation
	* Copyright (c) 2024 Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	/** @file
	* @brief IPv4 address conflict detection
	*/

	#include <zephyr/logging/log.h>
	LOG_MODULE_REGISTER(net_ipv4_acd, CONFIG_NET_IPV4_ACD_LOG_LEVEL);

	#include <zephyr/net/ethernet.h>
	#include <zephyr/net/net_if.h>
	#include <zephyr/net/net_l2.h>
	#include <zephyr/net/net_mgmt.h>
	#include <zephyr/net/net_pkt.h>
	#include <zephyr/random/random.h>
	#include <zephyr/sys/slist.h>

	#include "ipv4.h"
	#include "net_private.h"
	#include "../l2/ethernet/arp.h"

	static K_MUTEX_DEFINE(lock);

	/* Address conflict detection timer. */
	static struct k_work_delayable ipv4_acd_timer;

	/* List of IPv4 addresses under an active conflict detection. */
	static sys_slist_t active_acd_timers;

	#define BUF_ALLOC_TIMEOUT K_MSEC(100)

	/* Initial random delay*/
	#define IPV4_ACD_PROBE_WAIT 1

	/* Number of probe packets */
	#define IPV4_ACD_PROBE_NUM 3

	/* Minimum delay till repeated probe */
	#define IPV4_ACD_PROBE_MIN 1

	/* Maximum delay till repeated probe */
	#define IPV4_ACD_PROBE_MAX 2

	/* Delay before announcing */
	#define IPV4_ACD_ANNOUNCE_WAIT 2

	/* Number of announcement packets */
	#define IPV4_ACD_ANNOUNCE_NUM 2

	/* Time between announcement packets */
	#define IPV4_ACD_ANNOUNCE_INTERVAL 2

	/* Max conflicts before rate limiting */
	#define IPV4_ACD_MAX_CONFLICTS 10

	/* Delay between successive attempts */
	#define IPV4_ACD_RATE_LIMIT_INTERVAL 60

	/* Minimum interval between defensive ARPs */
	#define IPV4_ACD_DEFEND_INTERVAL 10

	enum ipv4_acd_state {
	IPV4_ACD_PROBE, /* Probing state */
	IPV4_ACD_ANNOUNCE, /* Announce state */
	};

	static struct net_pkt ipv4_acd_prepare_arp(struct net_if iface,
	struct in_addr *sender_ip,
	struct in_addr *target_ip)
	{
	struct net_pkt *pkt;

	/* We provide AF_UNSPEC to the allocator: this packet does not
	* need space for any IPv4 header.
	*/
	pkt = net_pkt_alloc_with_buffer(iface, sizeof(struct net_arp_hdr),
	AF_UNSPEC, 0, BUF_ALLOC_TIMEOUT);
	if (!pkt) {
	return NULL;
	}

	net_pkt_set_family(pkt, AF_INET);
	net_pkt_set_ipv4_acd(pkt, true);

	return net_arp_prepare(pkt, target_ip, sender_ip);
	}

	static void ipv4_acd_send_probe(struct net_if_addr *ifaddr)
	{
	struct net_if *iface = net_if_get_by_index(ifaddr->ifindex);
	struct in_addr unspecified = { 0 };
	struct net_pkt *pkt;

	pkt = ipv4_acd_prepare_arp(iface, &unspecified, &ifaddr->address.in_addr);
	if (!pkt) {
	NET_DBG("Failed to prepare probe %p", iface);
	return;
	}

	if (net_if_send_data(iface, pkt) == NET_DROP) {
	net_pkt_unref(pkt);
	}
	}

	static void ipv4_acd_send_announcement(struct net_if_addr *ifaddr)
	{
	struct net_if *iface = net_if_get_by_index(ifaddr->ifindex);
	struct net_pkt *pkt;

	pkt = ipv4_acd_prepare_arp(iface, &ifaddr->address.in_addr,
	&ifaddr->address.in_addr);
	if (!pkt) {
	NET_DBG("Failed to prepare announcement %p", iface);
	return;
	}

	if (net_if_send_data(iface, pkt) == NET_DROP) {
	net_pkt_unref(pkt);
	}
	}

	static void acd_timer_reschedule(void)
	{
	k_timepoint_t expiry = sys_timepoint_calc(K_FOREVER);
	k_timeout_t timeout;
	sys_snode_t *node;

	SYS_SLIST_FOR_EACH_NODE(&active_acd_timers, node) {
	struct net_if_addr *ifaddr =
	CONTAINER_OF(node, struct net_if_addr, acd_node);

	if (sys_timepoint_cmp(ifaddr->acd_timeout, expiry) < 0) {
	expiry = ifaddr->acd_timeout;
	}
	}

	timeout = sys_timepoint_timeout(expiry);
	if (K_TIMEOUT_EQ(timeout, K_FOREVER)) {
	k_work_cancel_delayable(&ipv4_acd_timer);
	return;
	}

	k_work_reschedule(&ipv4_acd_timer, timeout);
	}

	static void ipv4_acd_manage_timeout(struct net_if_addr *ifaddr)
	{
	switch (ifaddr->acd_state) {
	case IPV4_ACD_PROBE:
	if (ifaddr->acd_count < IPV4_ACD_PROBE_NUM) {
	uint32_t delay;

	NET_DBG("Sending probe for %s",
	net_sprint_ipv4_addr(&ifaddr->address.in_addr));

	ipv4_acd_send_probe(ifaddr);

	ifaddr->acd_count++;
	if (ifaddr->acd_count < IPV4_ACD_PROBE_NUM) {
	delay = sys_rand32_get();
	delay %= MSEC_PER_SEC * (IPV4_ACD_PROBE_MAX - IPV4_ACD_PROBE_MIN);
	delay += MSEC_PER_SEC * IPV4_ACD_PROBE_MIN;
	} else {
	delay = MSEC_PER_SEC * IPV4_ACD_ANNOUNCE_WAIT;

	}

	ifaddr->acd_timeout = sys_timepoint_calc(K_MSEC(delay));

	break;
	}

	net_if_ipv4_acd_succeeded(net_if_get_by_index(ifaddr->ifindex),
	ifaddr);

	ifaddr->acd_state = IPV4_ACD_ANNOUNCE;
	ifaddr->acd_count = 0;
	__fallthrough;
	case IPV4_ACD_ANNOUNCE:
	if (ifaddr->acd_count < IPV4_ACD_ANNOUNCE_NUM) {
	NET_DBG("Sending announcement for %s",
	net_sprint_ipv4_addr(&ifaddr->address.in_addr));

	ipv4_acd_send_announcement(ifaddr);

	ifaddr->acd_count++;
	ifaddr->acd_timeout = sys_timepoint_calc(
	K_SECONDS(IPV4_ACD_ANNOUNCE_INTERVAL));

	break;
	}

	NET_DBG("IPv4 conflict detection done for %s",
	net_sprint_ipv4_addr(&ifaddr->address.in_addr));

	/* Timeout will be used to determine whether DEFEND_INTERVAL
	* has expired in case of conflicts.
	*/
	ifaddr->acd_timeout = sys_timepoint_calc(K_NO_WAIT);

	sys_slist_find_and_remove(&active_acd_timers, &ifaddr->acd_node);
	break;
	default:
	break;
	}
	}

	static void ipv4_acd_timeout(struct k_work *work)
	{
	sys_snode_t current, next;

	ARG_UNUSED(work);

	k_mutex_lock(&lock, K_FOREVER);

	SYS_SLIST_FOR_EACH_NODE_SAFE(&active_acd_timers, current, next) {
	struct net_if_addr *ifaddr =
	CONTAINER_OF(current, struct net_if_addr, acd_node);

	if (sys_timepoint_expired(ifaddr->acd_timeout)) {
	ipv4_acd_manage_timeout(ifaddr);
	}
	}

	acd_timer_reschedule();

	k_mutex_unlock(&lock);
	}

	static void acd_start_timer(struct net_if iface, struct net_if_addr ifaddr)
	{
	uint32_t delay;

	sys_slist_find_and_remove(&active_acd_timers, &ifaddr->acd_node);
	sys_slist_append(&active_acd_timers, &ifaddr->acd_node);

	if (iface->config.ip.ipv4->conflict_cnt >= IPV4_ACD_MAX_CONFLICTS) {
	NET_DBG("Rate limiting");
	delay = MSEC_PER_SEC * IPV4_ACD_RATE_LIMIT_INTERVAL;
	} else {
	/* Initial probe should be delayed by a random time interval
	* between 0 and PROBE_WAIT.
	*/
	delay = sys_rand32_get() % (MSEC_PER_SEC * IPV4_ACD_PROBE_WAIT);
	}

	ifaddr->acd_timeout = sys_timepoint_calc(K_MSEC(delay));

	acd_timer_reschedule();
	}

	enum net_verdict net_ipv4_acd_input(struct net_if iface, struct net_pkt pkt)
	{
	sys_snode_t current, next;
	struct net_arp_hdr *arp_hdr;
	struct net_if_ipv4 *ipv4;

	if (net_pkt_get_len(pkt) < sizeof(struct net_arp_hdr)) {
	NET_DBG("Invalid ARP header (len %zu, min %zu bytes)",
	net_pkt_get_len(pkt), sizeof(struct net_arp_hdr));
	return NET_DROP;
	}

	arp_hdr = NET_ARP_HDR(pkt);

	k_mutex_lock(&lock, K_FOREVER);

	SYS_SLIST_FOR_EACH_NODE_SAFE(&active_acd_timers, current, next) {
	struct net_if_addr *ifaddr =
	CONTAINER_OF(current, struct net_if_addr, acd_node);
	struct net_if *addr_iface = net_if_get_by_index(ifaddr->ifindex);
	struct net_linkaddr *ll_addr;

	if (iface != addr_iface) {
	continue;
	}

	if (ifaddr->acd_state != IPV4_ACD_PROBE) {
	continue;
	}

	ll_addr = net_if_get_link_addr(addr_iface);

	/* RFC 5227, ch. 2.1.1 Probe Details:
	* - ARP Request/Reply with Sender IP address match OR,
	* - ARP Probe where Target IP address match with different sender HW address,
	* indicate a conflict.
	* ARP Probe has an all-zero sender IP address
	*/
	if (net_ipv4_addr_cmp_raw(arp_hdr->src_ipaddr,
	(uint8_t *)&ifaddr->address.in_addr) \|\|
	(net_ipv4_addr_cmp_raw(arp_hdr->dst_ipaddr,
	(uint8_t *)&ifaddr->address.in_addr) &&
	(memcmp(&arp_hdr->src_hwaddr, ll_addr->addr, ll_addr->len) != 0) &&
	(net_ipv4_addr_cmp_raw(arp_hdr->src_ipaddr,
	(uint8_t *)&(struct in_addr)INADDR_ANY_INIT)))) {
	NET_DBG("Conflict detected from %s for %s",
	net_sprint_ll_addr((uint8_t *)&arp_hdr->src_hwaddr,
	arp_hdr->hwlen),
	net_sprint_ipv4_addr(&ifaddr->address.in_addr));

	iface->config.ip.ipv4->conflict_cnt++;

	net_if_ipv4_acd_failed(addr_iface, ifaddr);

	k_mutex_unlock(&lock);

	return NET_DROP;
	}
	}

	k_mutex_unlock(&lock);

	ipv4 = iface->config.ip.ipv4;
	if (ipv4 == NULL) {
	goto out;
	}

	/* Passive conflict detection - try to defend already confirmed
	* addresses.
	*/
	ARRAY_FOR_EACH(ipv4->unicast, i) {
	struct net_if_addr *ifaddr = &ipv4->unicast[i].ipv4;
	struct net_linkaddr *ll_addr = net_if_get_link_addr(iface);

	if (!ifaddr->is_used) {
	continue;
	}

	if (net_ipv4_addr_cmp_raw(arp_hdr->src_ipaddr,
	(uint8_t *)&ifaddr->address.in_addr) &&
	memcmp(&arp_hdr->src_hwaddr, ll_addr->addr, ll_addr->len) != 0) {
	NET_DBG("Conflict detected from %s for %s",
	net_sprint_ll_addr((uint8_t *)&arp_hdr->src_hwaddr,
	arp_hdr->hwlen),
	net_sprint_ipv4_addr(&ifaddr->address.in_addr));

	ipv4->conflict_cnt++;

	/* In case timer has expired, we're past DEFEND_INTERVAL
	* and can try to defend again
	*/
	if (sys_timepoint_expired(ifaddr->acd_timeout)) {
	NET_DBG("Defending address %s",
	net_sprint_ipv4_addr(&ifaddr->address.in_addr));
	ipv4_acd_send_announcement(ifaddr);
	ifaddr->acd_timeout = sys_timepoint_calc(
	K_SECONDS(IPV4_ACD_DEFEND_INTERVAL));
	} else {
	NET_DBG("Reporting conflict on %s",
	net_sprint_ipv4_addr(&ifaddr->address.in_addr));
	/* Otherwise report the conflict and let the
	* application decide.
	*/
	net_mgmt_event_notify_with_info(
	NET_EVENT_IPV4_ACD_CONFLICT, iface,
	&ifaddr->address.in_addr,
	sizeof(struct in_addr));
	}

	break;
	}
	}

	out:
	return NET_CONTINUE;
	}

	void net_ipv4_acd_init(void)
	{
	k_work_init_delayable(&ipv4_acd_timer, ipv4_acd_timeout);
	}

	int net_ipv4_acd_start(struct net_if iface, struct net_if_addr ifaddr)
	{
	/* Address conflict detection is based on ARP, so can only be done on
	* supporting interfaces.
	*/
	if (!(net_if_l2(iface) == &NET_L2_GET_NAME(ETHERNET) \|\|
	net_eth_is_vlan_interface(iface))) {
	net_if_ipv4_acd_succeeded(iface, ifaddr);
	return 0;
	}

	k_mutex_lock(&lock, K_FOREVER);

	ifaddr->ifindex = net_if_get_by_iface(iface);
	ifaddr->acd_state = IPV4_ACD_PROBE;
	ifaddr->acd_count = 0;

	acd_start_timer(iface, ifaddr);

	k_mutex_unlock(&lock);

	return 0;
	}

	void net_ipv4_acd_cancel(struct net_if iface, struct net_if_addr ifaddr)
	{
	/* Address conflict detection is based on ARP, so can only be done on
	* supporting interfaces.
	*/
	if (!(net_if_l2(iface) == &NET_L2_GET_NAME(ETHERNET) \|\|
	net_eth_is_vlan_interface(iface))) {
	return;
	}

	k_mutex_lock(&lock, K_FOREVER);

	sys_slist_find_and_remove(&active_acd_timers, &ifaddr->acd_node);
	acd_timer_reschedule();

	k_mutex_unlock(&lock);
	}