int icmpv6_neighbor(const net_ipv6addr_t ipaddr)
{
FAR struct net_driver_s *dev;
struct icmpv6_notify_s notify;
struct timespec delay;
struct icmpv6_neighbor_s state;
FAR const uint16_t *lookup;
net_lock_t save;
int ret;
/* First check if destination is a local broadcast or a multicast address.
*
* - IPv6 multicast addresses are have the high-order octet of the
* addresses=0xff (ff00::/8.)
*/
if (net_ipv6addr_cmp(ipaddr, g_ipv6_allzeroaddr) ||
(ipaddr[0] & NTOHS(0xff00)) == NTOHS(0xff00))
{
/* We don't need to send the Neighbor Solicitation */
return OK;
}
/* Get the device that can route this request */
#ifdef CONFIG_NETDEV_MULTINIC
dev = netdev_findby_ipv6addr(g_ipv6_allzeroaddr, ipaddr);
#else
dev = netdev_findby_ipv6addr(ipaddr);
#endif
if (!dev)
{
ndbg("ERROR: Unreachable: %08lx\n", (unsigned long)ipaddr);
ret = -EHOSTUNREACH;
goto errout;
}
#ifdef CONFIG_NET_MULTILINK
/* If we are supporting multiple network devices and using different
* link level protocols then we can get here for other link protocols
* as well. Continue and send the Neighbor Solicitation request only
* if this device uses the Ethernet data link protocol.
*
* REVISIT: Other link layer protocols may require Neighbor Discovery
* as well (but not SLIP which is the only other option at the moment).
*/
if (dev->d_lltype != NET_LL_ETHERNET)
{
return OK;
}
#endif
/* Check if the destination address is on the local network. */
if (net_ipv6addr_maskcmp(ipaddr, dev->d_ipv6addr, dev->d_ipv6netmask))
{
/* Yes.. use the input address for the lookup */
lookup = ipaddr;
}
else
{
net_ipv6addr_t dripaddr;
/* Destination address is not on the local network */
#ifdef CONFIG_NET_ROUTE
/* We have a routing table.. find the correct router to use in
* this case (or, as a fall-back, use the device's default router
* address). We will use the router IP address instead of the
* destination address when determining the MAC address.
*/
netdev_ipv6_router(dev, ipaddr, dripaddr);
#else
/* Use the device's default router IP address instead of the
* destination address when determining the MAC address.
*/
net_ipv6addr_copy(dripaddr, dev->d_ipv6draddr);
#endif
/* Use the router address for the lookup */
lookup = dripaddr;
}
/* Allocate resources to receive a callback. This and the following
* initialization is performed with the network lock because we don't
* want anything to happen until we are ready.
*/
save = net_lock();
state.snd_cb = icmpv6_callback_alloc();
if (!state.snd_cb)
{
ndbg("ERROR: Failed to allocate a cllback\n");
ret = -ENOMEM;
goto errout_with_lock;
}
/* Initialize the state structure. This is done with interrupts
* disabled
*/
(void)sem_init(&state.snd_sem, 0, 0); /* Doesn't really fail */
state.snd_retries = 0; /* No retries yet */
net_ipv6addr_copy(state.snd_ipaddr, lookup); /* IP address to query */
#ifdef CONFIG_NETDEV_MULTINIC
/* Remember the routing device name */
strncpy((FAR char *)state.snd_ifname, (FAR const char *)dev->d_ifname,
IFNAMSIZ);
#endif
/* Now loop, testing if the address mapping is in the Neighbor Table and
* re-sending the Neighbor Solicitation if it is not.
*/
ret = -ETIMEDOUT; /* Assume a timeout failure */
while (state.snd_retries < CONFIG_ICMPv6_NEIGHBOR_MAXTRIES)
{
/* Check if the address mapping is present in the Neighbor Table. This
* is only really meaningful on the first time through the loop.
*
* NOTE: If the Neighbor Table is large than this could be a performance
* issue.
*/
if (neighbor_findentry(lookup) != NULL)
{
/* We have it! Break out with success */
ret = OK;
break;
}
/* Set up the Neighbor Advertisement wait BEFORE we send the Neighbor
* Solicitation.
*/
icmpv6_wait_setup(lookup, ¬ify);
/* Arm/re-arm the callback */
state.snd_sent = false;
state.snd_cb->flags = ICMPv6_POLL;
state.snd_cb->priv = (FAR void *)&state;
state.snd_cb->event = icmpv6_neighbor_interrupt;
/* Notify the device driver that new TX data is available. */
dev->d_txavail(dev);
/* Wait for the send to complete or an error to occur: NOTES: (1)
* net_lockedwait will also terminate if a signal is received, (2)
* interrupts may be disabled! They will be re-enabled while the
* task sleeps and automatically re-enabled when the task restarts.
*/
do
{
(void)net_lockedwait(&state.snd_sem);
}
while (!state.snd_sent);
/* Now wait for response to the Neighbor Advertisement to be received.
* The optimal delay would be the work case round trip time.
* NOTE: The network is locked.
*/
delay.tv_sec = CONFIG_ICMPv6_NEIGHBOR_DELAYSEC;
delay.tv_nsec = CONFIG_ICMPv6_NEIGHBOR_DELAYNSEC;
ret = icmpv6_wait(¬ify, &delay);
/* icmpv6_wait will return OK if and only if the matching Neighbor
* Advertisement is received. Otherwise, it will return -ETIMEDOUT.
*/
if (ret == OK)
{
break;
}
/* Increment the retry count */
state.snd_retries++;
}
sem_destroy(&state.snd_sem);
icmpv6_callback_free(state.snd_cb);
errout_with_lock:
net_unlock(save);
errout:
return ret;
}
void neighbor_out(FAR struct net_driver_s *dev)
{
FAR const struct neighbor_addr_s *naddr;
FAR struct eth_hdr_s *eth = ETHBUF;
FAR struct ipv6_hdr_s *ip = IPv6BUF;
net_ipv6addr_t ipaddr;
/* Skip sending Neighbor Solicitations when the frame to be transmitted was
* written into a packet socket or if we are sending certain Neighbor
* messages (solicitation, advertisement, echo request).
*/
if (IFF_IS_NOARP(dev->d_flags))
{
/* Clear the indication and let the packet continue on its way. */
IFF_CLR_NOARP(dev->d_flags);
return;
}
/* Find the destination IPv6 address in the Neighbor Table and construct
* the Ethernet header. If the destination IPv6 address isn't on the local
* network, we use the default router's IPv6 address instead.
*
* If no Neighbor Table entry is found, we overwrite the original IPv6
* packet with an Neighbor Solicitation Request for the IPv6 address.
*/
/* First check if destination is a IPv6 multicast address. IPv6
* multicast addresses in IPv6 have the prefix ff00::/8
*
* Bits 120-127: Prefix
* Bits 116-119: Flags (1, 2, or 3 defined)
* Bits 112-115: Scope
*
* REVISIT: Need to revisit IPv6 broadcast support. Broadcast
* IP addresses are not used with IPv6; multicast is used instead.
* Does this mean that all multicast address should go to the
* broadcast Ethernet address?
*/
if ((ip->destipaddr[0] & HTONS(0xff00)) == HTONS(0xff00))
{
memcpy(eth->dest, g_broadcast_ethaddr.ether_addr_octet,
ETHER_ADDR_LEN);
}
#ifdef CONFIG_NET_IGMP
/* Check if the destination address is a multicast address
*
* IPv6 multicast addresses are have the high-order octet of the
* addresses=0xff (ff00::/8.)
*
* REVISIT: See comments above. How do we distinguish broadcast
* from IGMP multicast?
*/
#warning Missing logic
#endif
else
{
/* Check if the destination address is on the local network. */
if (!net_ipv6addr_maskcmp(ip->destipaddr, dev->d_ipv6addr,
dev->d_ipv6netmask))
{
/* Destination address is not on the local network */
#ifdef CONFIG_NET_ROUTE
/* We have a routing table.. find the correct router to use in
* this case (or, as a fall-back, use the device's default router
* address). We will use the router IPv6 address instead of the
* destination address when determining the MAC address.
*/
netdev_ipv6_router(dev, ip->destipaddr, ipaddr);
#else
/* Use the device's default router IPv6 address instead of the
* destination address when determining the MAC address.
*/
net_ipv6addr_copy(ipaddr, dev->d_ipv6draddr);
#endif
}
else
{
/* Else, we use the destination IPv6 address. */
net_ipv6addr_copy(ipaddr, ip->destipaddr);
}
/* Check if we already have this destination address in the Neighbor Table */
naddr = neighbor_lookup(ipaddr);
if (!naddr)
{
nllvdbg("IPv6 Neighbor solicitation for IPv6\n");
/* The destination address was not in our Neighbor Table, so we
* overwrite the IPv6 packet with an ICMDv6 Neighbor Solicitation
* message.
*/
icmpv6_solicit(dev, ipaddr);
return;
}
/* Build an Ethernet header. */
memcpy(eth->dest, naddr->na_addr.ether_addr_octet, ETHER_ADDR_LEN);
}
/* Finish populating the Ethernet header */
memcpy(eth->src, dev->d_mac.ether_addr_octet, ETHER_ADDR_LEN);
eth->type = HTONS(ETHTYPE_IP6);
/* Add the size of the layer layer header to the total size of the
* outgoing packet.
*/
dev->d_len += netdev_ipv6_hdrlen(dev);
nllvdbg("Outgoing IPv6 Packet length: %d (%d)\n",
dev->d_len, (ip->len[0] << 8) | ip->len[1]);
}
