| #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> |
| |
| /** @file |
| * |
| * 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. |
| */ |
| |
| /* A neighbour entry */ |
| struct ndp_entry { |
| /** Target IP6 address */ |
| struct in6_addr in6; |
| /** Link layer protocol */ |
| struct ll_protocol *ll_protocol; |
| /** Link-layer address */ |
| uint8_t ll_addr[MAX_LL_ADDR_LEN]; |
| /** State of the neighbour entry */ |
| int state; |
| }; |
| |
| /** Number of entries in the neighbour cache table */ |
| #define NUM_NDP_ENTRIES 4 |
| |
| /** The neighbour cache table */ |
| static struct ndp_entry ndp_table[NUM_NDP_ENTRIES]; |
| #define ndp_table_end &ndp_table[NUM_NDP_ENTRIES] |
| |
| static unsigned int next_new_ndp_entry = 0; |
| |
| /** |
| * Find entry in the neighbour cache |
| * |
| * @v in6 IP6 address |
| */ |
| static struct ndp_entry * |
| ndp_find_entry ( struct in6_addr *in6 ) { |
| 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; |
| } |
| |
| /** |
| * Add NDP entry |
| * |
| * @v netdev Network device |
| * @v in6 IP6 address |
| * @v ll_addr Link-layer address |
| * @v state State of the entry - one of the NDP_STATE_XXX values |
| */ |
| static void |
| add_ndp_entry ( struct net_device *netdev, struct in6_addr *in6, |
| void *ll_addr, int state ) { |
| 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 ) ); |
| } |
| |
| /** |
| * Resolve the link-layer address |
| * |
| * @v netdev Network device |
| * @v dest Destination address |
| * @v src Source address |
| * @ret dest_ll_addr Destination link-layer address or NULL |
| * @ret 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. |
| */ |
| int ndp_resolve ( struct net_device *netdev, struct in6_addr *dest, |
| struct in6_addr *src, void *dest_ll_addr ) { |
| 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; |
| } |
| |
| /** |
| * Process neighbour advertisement |
| * |
| * @v iobuf I/O buffer |
| * @v st_src Source address |
| * @v st_dest Destination address |
| */ |
| int ndp_process_advert ( struct io_buffer *iobuf, struct sockaddr_tcpip *st_src __unused, |
| struct sockaddr_tcpip *st_dest __unused ) { |
| 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; |
| } |