/**************************************************************************** * net/arp/arp_table.c * * SPDX-License-Identifier: BSD-3-Clause * * Copyright (C) 2007-2009, 2011, 2014, 2018 Gregory Nutt. All rights * reserved. * Author: Gregory Nutt * * Based originally on uIP which also has a BSD style license: * * Author: Adam Dunkels * Copyright (c) 2001-2003, Adam Dunkels. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #ifdef CONFIG_NET #include #include #include #include #include #include #include #include #include #include #include #include "netdev/netdev.h" #include "netlink/netlink.h" #include "arp/arp.h" #ifdef CONFIG_NET_ARP /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ #define ARP_MAXAGE_TICK SEC2TICK(10 * CONFIG_NET_ARP_MAXAGE) /**************************************************************************** * Private Types ****************************************************************************/ struct arp_table_info_s { in_addr_t ai_ipaddr; /* IP address for lookup */ FAR uint8_t *ai_ethaddr; /* Location to return the MAC address */ }; /**************************************************************************** * Private Data ****************************************************************************/ /* The table of known address mappings */ static struct arp_entry_s g_arptable[CONFIG_NET_ARPTAB_SIZE]; static const struct ether_addr g_zero_ethaddr = { { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }; /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** * Name: arp_match * * Description: * This is a callback that checks if the Ethernet network device has the * indicated IPv4 address assigned to it. * ****************************************************************************/ static int arp_match(FAR struct net_driver_s *dev, FAR void *arg) { FAR struct arp_table_info_s *info = arg; /* Make sure that this is an Ethernet device (or an IEEE 802.11 device * which is also Ethernet) */ if (dev->d_lltype != NET_LL_ETHERNET && dev->d_lltype != NET_LL_IEEE80211) { return 0; } /* Check if the network device has been assigned the IP address of the * lookup. */ if (!net_ipv4addr_cmp(dev->d_ipaddr, info->ai_ipaddr)) { return 0; } /* Yes.. Return the matching Ethernet MAC address if the caller of * arp_find() provided a non-NULL location. */ if (info->ai_ethaddr != NULL) { memcpy(info->ai_ethaddr, &dev->d_mac.ether, ETHER_ADDR_LEN); } /* Return success in any event */ return 1; } /**************************************************************************** * Name: arp_return_old_entry * * Description: * Compare and return the old ARP table entry. * ****************************************************************************/ static FAR struct arp_entry_s * arp_return_old_entry(FAR struct arp_entry_s *e1, FAR struct arp_entry_s *e2) { if (e1->at_ipaddr == 0) { return e1; } else if (e2->at_ipaddr == 0) { return e2; } else if ((int)(e1->at_time - e2->at_time) <= 0) { return e1; } else { return e2; } } /**************************************************************************** * Name: arp_lookup * * Description: * Find the ARP entry corresponding to this IP address in the ARP table. * * Input Parameters: * ipaddr - Refers to an IP address in network order * dev - Device structure * * Assumptions: * The network is locked to assure exclusive access to the ARP table. * The return value will become unstable when the network is unlocked. * ****************************************************************************/ static FAR struct arp_entry_s *arp_lookup(in_addr_t ipaddr, FAR struct net_driver_s *dev) { FAR struct arp_entry_s *tabptr; int i; /* Check if the IPv4 address is already in the ARP table. */ for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { tabptr = &g_arptable[i]; if (tabptr->at_dev == dev && net_ipv4addr_cmp(ipaddr, tabptr->at_ipaddr) && clock_systime_ticks() - tabptr->at_time <= ARP_MAXAGE_TICK) { return tabptr; } } /* Not found */ return NULL; } /**************************************************************************** * Name: arp_get_arpreq * * Description: * Translate (struct arp_entry_s) to (struct arpreq) for netlink notify. * * Input Parameters: * output - Location to return the ARP table copy * input - The arp entry in table * ****************************************************************************/ #ifdef CONFIG_NETLINK_ROUTE static void arp_get_arpreq(FAR struct arpreq *output, FAR struct arp_entry_s *input) { FAR struct sockaddr_in *outaddr; DEBUGASSERT(output != NULL && input != NULL); outaddr = (FAR struct sockaddr_in *)&output->arp_pa; outaddr->sin_family = AF_INET; outaddr->sin_port = 0; outaddr->sin_addr.s_addr = input->at_ipaddr; memcpy(output->arp_ha.sa_data, input->at_ethaddr.ether_addr_octet, sizeof(struct ether_addr)); strlcpy((FAR char *)output->arp_dev, input->at_dev->d_ifname, sizeof(output->arp_dev)); } #endif /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: arp_update * * Description: * Add the IP/HW address mapping to the ARP table -OR- change the IP * address of an existing association. * * Input Parameters: * dev - The device driver structure * ipaddr - The IP address as an inaddr_t * ethaddr - Refers to a HW address uint8_t[IFHWADDRLEN] * * Returned Value: * Zero (OK) if the ARP table entry was successfully modified. A negated * errno value is returned on any error. * * Assumptions * The network is locked to assure exclusive access to the ARP table * ****************************************************************************/ int arp_update(FAR struct net_driver_s *dev, in_addr_t ipaddr, FAR const uint8_t *ethaddr) { FAR struct arp_entry_s *tabptr = &g_arptable[0]; #ifdef CONFIG_NETLINK_ROUTE struct arpreq arp_notify; bool found = false; bool new_entry; #endif int i; /* Walk through the ARP mapping table and try to find an entry to * update. If none is found, the IP -> MAC address mapping is * inserted in the ARP table. */ for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { /* Check if the source IP address of the incoming packet matches * the IP address in this ARP table entry. */ if (g_arptable[i].at_dev == dev && g_arptable[i].at_ipaddr != 0 && net_ipv4addr_cmp(ipaddr, g_arptable[i].at_ipaddr)) { /* An old entry found, break. */ tabptr = &g_arptable[i]; #ifdef CONFIG_NETLINK_ROUTE found = true; #endif break; } else { /* Record the oldest entry. */ tabptr = arp_return_old_entry(tabptr, &g_arptable[i]); } } if (ethaddr == NULL) { ethaddr = g_zero_ethaddr.ether_addr_octet; } /* When overwite old entry, notify old entry RTM_DELNEIGH */ #ifdef CONFIG_NETLINK_ROUTE if (!found && tabptr->at_ipaddr != 0) { arp_get_arpreq(&arp_notify, tabptr); netlink_neigh_notify(&arp_notify, RTM_DELNEIGH, AF_INET); } /* Need to notify when entry is not found or changes in table */ new_entry = !found || memcmp(tabptr->at_ethaddr.ether_addr_octet, ethaddr, ETHER_ADDR_LEN) != 0; #endif /* Now, tabptr is the ARP table entry which we will fill with the new * information. */ tabptr->at_ipaddr = ipaddr; memcpy(tabptr->at_ethaddr.ether_addr_octet, ethaddr, ETHER_ADDR_LEN); tabptr->at_dev = dev; tabptr->at_time = clock_systime_ticks(); /* Notify the new entry */ #ifdef CONFIG_NETLINK_ROUTE if (new_entry) { arp_get_arpreq(&arp_notify, tabptr); netlink_neigh_notify(&arp_notify, RTM_NEWNEIGH, AF_INET); } #endif return OK; } /**************************************************************************** * Name: arp_hdr_update * * Description: * Add the IP/HW address mapping to the ARP table -OR- change the IP * address of an existing association. * * Input Parameters: * dev - The device driver structure * pipaddr - Refers to an IP address uint16_t[2] in network order * ethaddr - Refers to a HW address uint8_t[IFHWADDRLEN] * * Returned Value: * Zero (OK) if the ARP table entry was successfully modified. A negated * errno value is returned on any error. * * Assumptions * The network is locked to assure exclusive access to the ARP table * ****************************************************************************/ void arp_hdr_update(FAR struct net_driver_s *dev, FAR uint16_t *pipaddr, FAR const uint8_t *ethaddr) { in_addr_t ipaddr = net_ip4addr_conv32(pipaddr); /* Update the ARP table */ arp_update(dev, ipaddr, ethaddr); } /**************************************************************************** * Name: arp_find * * Description: * Find the ARP entry corresponding to this IP address which may or may * not be in the ARP table (it may, instead, be a local network device). * * Input Parameters: * ipaddr - Refers to an IP address in network order * ethaddr - Location to return the corresponding Ethernet MAN address. * This address may be NULL. In that case, this function may be * used simply to determine if the Ethernet MAC address is * available. * dev - Device structure * * Assumptions * The network is locked to assure exclusive access to the ARP table. * ****************************************************************************/ int arp_find(in_addr_t ipaddr, FAR uint8_t *ethaddr, FAR struct net_driver_s *dev) { FAR struct arp_entry_s *tabptr; struct arp_table_info_s info; /* Check if the IPv4 address is already in the ARP table. */ tabptr = arp_lookup(ipaddr, dev); if (tabptr != NULL) { /* Addresses that have failed to be searched will return a special * error code so that the upper layer can return faster. */ if (memcmp(&tabptr->at_ethaddr, &g_zero_ethaddr, sizeof(tabptr->at_ethaddr)) == 0) { return -ENETUNREACH; } /* Yes.. return the Ethernet MAC address if the caller has provided a * non-NULL address in 'ethaddr'. */ if (ethaddr != NULL) { memcpy(ethaddr, &tabptr->at_ethaddr, ETHER_ADDR_LEN); } /* Return success meaning that a valid Ethernet MAC address mapping * is available for the IP address. */ return OK; } /* No.. check if the IPv4 address is the address assigned to a local * Ethernet network device. If so, return a mapping of that IP address * to the Ethernet MAC address assigned to the network device. */ info.ai_ipaddr = ipaddr; info.ai_ethaddr = ethaddr; if (netdev_foreach(arp_match, &info) != 0) { return OK; } /* Not found */ return -ENOENT; } /**************************************************************************** * Name: arp_delete * * Description: * Remove an IP association from the ARP table * * Input Parameters: * ipaddr - Refers to an IP address in network order * dev - Device structure * * Assumptions * The network is locked to assure exclusive access to the ARP table. * ****************************************************************************/ int arp_delete(in_addr_t ipaddr, FAR struct net_driver_s *dev) { FAR struct arp_entry_s *tabptr; #ifdef CONFIG_NETLINK_ROUTE struct arpreq arp_notify; #endif /* Check if the IPv4 address is in the ARP table. */ tabptr = arp_lookup(ipaddr, dev); if (tabptr != NULL) { /* Notify to netlink */ #ifdef CONFIG_NETLINK_ROUTE arp_get_arpreq(&arp_notify, tabptr); netlink_neigh_notify(&arp_notify, RTM_DELNEIGH, AF_INET); #endif /* Yes.. Set the IP address to zero to "delete" it */ tabptr->at_ipaddr = 0; return OK; } return -ENOENT; } /**************************************************************************** * Name: arp_cleanup * * Description: * Clear the ARP table on the network device * * Input Parameters: * dev - The device driver structure * * Assumptions * The network is locked to assure exclusive access to the ARP table. * ****************************************************************************/ void arp_cleanup(FAR struct net_driver_s *dev) { int i; for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { if (dev == g_arptable[i].at_dev) { memset(&g_arptable[i], 0, sizeof(g_arptable[i])); } } } /**************************************************************************** * Name: arp_snapshot * * Description: * Take a snapshot of the current state of the ARP table. * * Input Parameters: * snapshot - Location to return the ARP table copy * nentries - The size of the user provided 'dest' in entries, each of * size sizeof(struct arp_entry_s) * * Returned Value: * On success, the number of entries actually copied is returned. Unused * entries are not returned. * * Assumptions * The network is locked to assure exclusive access to the ARP table * ****************************************************************************/ #ifdef CONFIG_NETLINK_ROUTE unsigned int arp_snapshot(FAR struct arpreq *snapshot, unsigned int nentries) { FAR struct arp_entry_s *tabptr; clock_t now; unsigned int ncopied; int i; /* Copy all non-empty, non-expired entries in the ARP table. */ for (i = 0, now = clock_systime_ticks(), ncopied = 0; nentries > ncopied && i < CONFIG_NET_ARPTAB_SIZE; i++) { tabptr = &g_arptable[i]; if (tabptr->at_ipaddr != 0 && now - tabptr->at_time <= ARP_MAXAGE_TICK) { arp_get_arpreq(&snapshot[ncopied], tabptr); ncopied++; } } /* Return the number of entries copied into the user buffer */ return ncopied; } #endif #endif /* CONFIG_NET_ARP */ #endif /* CONFIG_NET */