ndp.c File Reference

Neighbour Discovery Protocol. More...

#include <stdint.h>
#include <string.h>
#include <byteswap.h>
#include <errno.h>
#include <gpxe/if_ether.h>
#include <gpxe/iobuf.h>
#include <gpxe/ndp.h>
#include <gpxe/icmp6.h>
#include <gpxe/ip6.h>
#include <gpxe/netdevice.h>

Go to the source code of this file.

Data Structures
struct	ndp_entry
Defines
#define	NUM_NDP_ENTRIES   4
	Number of entries in the neighbour cache table.
#define	ndp_table_end   &ndp_table[NUM_NDP_ENTRIES]
Functions
static struct ndp_entry *	ndp_find_entry (struct in6_addr *in6)
	Find entry in the neighbour cache.
static void	add_ndp_entry (struct net_device *netdev, struct in6_addr *in6, void *ll_addr, int state)
	Add NDP entry.
int	ndp_resolve (struct net_device *netdev, struct in6_addr *dest, struct in6_addr *src, void *dest_ll_addr)
	Resolve the link-layer address.
int	ndp_process_advert (struct io_buffer *iobuf, struct sockaddr_tcpip *st_src __unused, struct sockaddr_tcpip *st_dest __unused)
	Process neighbour advertisement.
Variables
static struct ndp_entry	ndp_table [NUM_NDP_ENTRIES]
	The neighbour cache table.
static unsigned int	next_new_ndp_entry = 0

---

Detailed Description

Neighbour Discovery Protocol.

This file implements address resolution as specified by the neighbour discovery protocol in RFC2461. This protocol is part of the IPv6 protocol family.

Definition in file ndp.c.

---

Define Documentation

#define NUM_NDP_ENTRIES   4

Number of entries in the neighbour cache table.

Definition at line 34 of file ndp.c.

Referenced by add_ndp_entry().

#define ndp_table_end   &ndp_table[NUM_NDP_ENTRIES]

Definition at line 38 of file ndp.c.

Referenced by ndp_find_entry().

---

Function Documentation

static struct ndp_entry* ndp_find_entry

(

struct in6_addr *

in6

)

[static, read]

Find entry in the neighbour cache.

Parameters:

in6

IP6 address

Definition at line 48 of file ndp.c.

References ndp_entry::in6, IP6_EQUAL, NDP_STATE_INVALID, ndp_table, ndp_table_end, NULL, and ndp_entry::state.

Referenced by ndp_process_advert(), and ndp_resolve().

                                        {
        struct ndp_entry *ndp;

        for ( ndp = ndp_table ; ndp < ndp_table_end ; ndp++ ) {
                if ( IP6_EQUAL ( ( *in6 ), ndp->in6 ) && 
                     ( ndp->state != NDP_STATE_INVALID ) ) {
                        return ndp;
                }
        }
        return NULL;
}

static void add_ndp_entry	(	struct net_device *	netdev,
		struct in6_addr *	in6,
		void *	ll_addr,
		int	state
	)			[static]

Add NDP entry.

Parameters:

	netdev	Network device
	in6	IP6 address
	ll_addr	Link-layer address
	state	State of the entry - one of the NDP_STATE_XXX values

Definition at line 69 of file ndp.c.

References DBG, ndp_entry::in6, inet6_ntoa(), ndp_entry::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, ndp_entry::ll_protocol, memcpy, memset(), ll_protocol::name, ndp_table, next_new_ndp_entry, ll_protocol::ntoa, NUM_NDP_ENTRIES, and ndp_entry::state.

Referenced by ndp_resolve().

                                           {
        struct ndp_entry *ndp;
        ndp = &ndp_table[next_new_ndp_entry++ % NUM_NDP_ENTRIES];

        /* Fill up entry */
        ndp->ll_protocol = netdev->ll_protocol;
        memcpy ( &ndp->in6, &( *in6 ), sizeof ( *in6 ) );
        if ( ll_addr ) {
                memcpy ( ndp->ll_addr, ll_addr, netdev->ll_protocol->ll_addr_len );
        } else {
                memset ( ndp->ll_addr, 0, netdev->ll_protocol->ll_addr_len );
        }
        ndp->state = state;
        DBG ( "New neighbour cache entry: IP6 %s => %s %s\n",
              inet6_ntoa ( ndp->in6 ), netdev->ll_protocol->name,
              netdev->ll_protocol->ntoa ( ndp->ll_addr ) );
}

int ndp_resolve	(	struct net_device *	netdev,
		struct in6_addr *	dest,
		struct in6_addr *	src,
		void *	dest_ll_addr
	)

Resolve the link-layer address.

Parameters:

	netdev	Network device
	dest	Destination address
	src	Source address

Return values:

	dest_ll_addr	Destination link-layer address or NULL
	rc	Status

This function looks up the neighbour cache for an entry corresponding to the destination address. If it finds a valid entry, it fills up dest_ll_addr and returns 0. Otherwise it sends a neighbour solicitation to the solicited multicast address.

Definition at line 102 of file ndp.c.

References add_ndp_entry(), DBG, ENOENT, icmp6_send_solicit(), inet6_ntoa(), ndp_entry::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, memcpy, ll_protocol::name, ndp_find_entry(), NDP_STATE_INCOMPLETE, NDP_STATE_REACHABLE, ll_protocol::ntoa, NULL, and ndp_entry::state.

Referenced by ipv6_tx().

                                                             {
        struct ll_protocol *ll_protocol = netdev->ll_protocol;
        struct ndp_entry *ndp;
        int rc;

        ndp = ndp_find_entry ( dest );
        /* Check if the entry is valid */
        if ( ndp && ndp->state == NDP_STATE_REACHABLE ) {
                DBG ( "Neighbour cache hit: IP6 %s => %s %s\n",
                      inet6_ntoa ( *dest ), ll_protocol->name,
                      ll_protocol->ntoa ( ndp->ll_addr ) );
                memcpy ( dest_ll_addr, ndp->ll_addr, ll_protocol->ll_addr_len );
                return 0;
        }

        /* Check if the entry was already created */
        if ( ndp ) {
                DBG ( "Awaiting neighbour advertisement\n" );
                /* For test */
//              ndp->state = NDP_STATE_REACHABLE;
//              memcpy ( ndp->ll_addr, netdev->ll_addr, 6 );
//              assert ( ndp->ll_protocol->ll_addr_len == 6 );
//              icmp6_test_nadvert ( netdev, dest, ndp->ll_addr );
//              assert ( ndp->state == NDP_STATE_REACHABLE );
                /* Take it out till here */
                return -ENOENT;
        }
        DBG ( "Neighbour cache miss: IP6 %s\n", inet6_ntoa ( *dest ) );

        /* Add entry in the neighbour cache */
        add_ndp_entry ( netdev, dest, NULL, NDP_STATE_INCOMPLETE );

        /* Send neighbour solicitation */
        if ( ( rc = icmp6_send_solicit ( netdev, src, dest ) ) != 0 ) {
                return rc;
        }
        return -ENOENT;
}

int ndp_process_advert	(	struct io_buffer *	iobuf,
		struct sockaddr_tcpip *st_src	__unused,
		struct sockaddr_tcpip *st_dest	__unused
	)

Process neighbour advertisement.

Parameters:

	iobuf	I/O buffer
	st_src	Source address
	st_dest	Destination address

Definition at line 149 of file ndp.c.

References assert, neighbour_advert::code, io_buffer::data, DBG, EINVAL, neighbour_advert::flags, ICMP6_FLAGS_SOLICITED, ndp_entry::in6, iob_len(), IP6_EQUAL, ndp_entry::ll_addr, ll_protocol::ll_addr_len, ndp_entry::ll_protocol, memcpy, ndp_find_entry(), NDP_STATE_REACHABLE, neighbour_advert::opt_len, neighbour_advert::opt_ll_addr, neighbour_advert::opt_type, ndp_entry::state, and neighbour_advert::target.

Referenced by icmp6_rx().

                                                                     {
        struct neighbour_advert *nadvert = iobuf->data;
        struct ndp_entry *ndp;

        /* Sanity check */
        if ( iob_len ( iobuf ) < sizeof ( *nadvert ) ) {
                DBG ( "Packet too short (%zd bytes)\n", iob_len ( iobuf ) );
                return -EINVAL;
        }

        assert ( nadvert->code == 0 );
        assert ( nadvert->flags & ICMP6_FLAGS_SOLICITED );
        assert ( nadvert->opt_type == 2 );

        /* Update the neighbour cache, if entry is present */
        ndp = ndp_find_entry ( &nadvert->target );
        if ( ndp ) {

        assert ( nadvert->opt_len ==
                        ( ( 2 + ndp->ll_protocol->ll_addr_len ) / 8 ) );

                if ( IP6_EQUAL ( ndp->in6, nadvert->target ) ) {
                        memcpy ( ndp->ll_addr, nadvert->opt_ll_addr,
                                 ndp->ll_protocol->ll_addr_len );
                        ndp->state = NDP_STATE_REACHABLE;
                        return 0;
                }
        }
        DBG ( "Unsolicited advertisement (dropping packet)\n" );
        return 0;
}

---

Variable Documentation

struct ndp_entry ndp_table[NUM_NDP_ENTRIES] [static]

The neighbour cache table.

Definition at line 37 of file ndp.c.

Referenced by add_ndp_entry(), and ndp_find_entry().

unsigned int next_new_ndp_entry = 0 [static]

Definition at line 40 of file ndp.c.

Referenced by add_ndp_entry().