blob: 373a9360b1ed419c2d62700f7374959f8d46bfc8 [file] [log] [blame]
/*
* Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
FILE_LICENCE ( GPL2_OR_LATER );
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/in.h>
#include <ipxe/iobuf.h>
#include <ipxe/tcpip.h>
#include <ipxe/ipv6.h>
#include <ipxe/icmpv6.h>
#include <ipxe/neighbour.h>
#include <ipxe/dhcpv6.h>
#include <ipxe/timer.h>
#include <ipxe/ndp.h>
/** @file
*
* IPv6 neighbour discovery protocol
*
*/
/** Router discovery minimum timeout */
#define IPV6CONF_MIN_TIMEOUT ( TICKS_PER_SEC / 8 )
/** Router discovery maximum timeout */
#define IPV6CONF_MAX_TIMEOUT ( TICKS_PER_SEC * 3 )
/** Router discovery blocked link retry timeout */
#define IPV6CONF_BLOCK_TIMEOUT ( TICKS_PER_SEC )
/** Router discovery maximum number of deferrals */
#define IPV6CONF_MAX_DEFERRALS 180
static struct ipv6conf * ipv6conf_demux ( struct net_device *netdev );
static int
ipv6conf_rx_router_advertisement ( struct net_device *netdev,
struct in6_addr *router,
struct ndp_router_advertisement_header *radv,
size_t len );
/**
* Transmit NDP packet with link-layer address option
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v sin6_dest Destination socket address
* @v data NDP header
* @v len Size of NDP header
* @v option_type NDP option type
* @ret rc Return status code
*/
static int ndp_tx_ll_addr ( struct net_device *netdev,
struct sockaddr_in6 *sin6_src,
struct sockaddr_in6 *sin6_dest,
const void *data, size_t len,
unsigned int option_type ) {
struct sockaddr_tcpip *st_src =
( ( struct sockaddr_tcpip * ) sin6_src );
struct sockaddr_tcpip *st_dest =
( ( struct sockaddr_tcpip * ) sin6_dest );
struct ll_protocol *ll_protocol = netdev->ll_protocol;
struct io_buffer *iobuf;
struct ndp_ll_addr_option *ll_addr_opt;
union ndp_header *ndp;
size_t option_len;
int rc;
/* Allocate and populate buffer */
option_len = ( ( sizeof ( *ll_addr_opt ) +
ll_protocol->ll_addr_len + NDP_OPTION_BLKSZ - 1 ) &
~( NDP_OPTION_BLKSZ - 1 ) );
iobuf = alloc_iob ( MAX_LL_NET_HEADER_LEN + len + option_len );
if ( ! iobuf )
return -ENOMEM;
iob_reserve ( iobuf, MAX_LL_NET_HEADER_LEN );
memcpy ( iob_put ( iobuf, len ), data, len );
ll_addr_opt = iob_put ( iobuf, option_len );
ll_addr_opt->header.type = option_type;
ll_addr_opt->header.blocks = ( option_len / NDP_OPTION_BLKSZ );
memcpy ( ll_addr_opt->ll_addr, netdev->ll_addr,
ll_protocol->ll_addr_len );
ndp = iobuf->data;
ndp->icmp.chksum = tcpip_chksum ( ndp, ( len + option_len ) );
/* Transmit packet */
if ( ( rc = tcpip_tx ( iobuf, &icmpv6_protocol, st_src, st_dest,
netdev, &ndp->icmp.chksum ) ) != 0 ) {
DBGC ( netdev, "NDP %s could not transmit packet: %s\n",
netdev->name, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Transmit NDP neighbour discovery request
*
* @v netdev Network device
* @v net_protocol Network-layer protocol
* @v net_dest Destination network-layer address
* @v net_source Source network-layer address
* @ret rc Return status code
*/
static int ndp_tx_request ( struct net_device *netdev,
struct net_protocol *net_protocol __unused,
const void *net_dest, const void *net_source ) {
struct sockaddr_in6 sin6_src;
struct sockaddr_in6 sin6_dest;
struct ndp_neighbour_header neigh;
int rc;
/* Construct source address */
memset ( &sin6_src, 0, sizeof ( sin6_src ) );
sin6_src.sin6_family = AF_INET6;
memcpy ( &sin6_src.sin6_addr, net_source,
sizeof ( sin6_src.sin6_addr ) );
/* Construct multicast destination address */
memset ( &sin6_dest, 0, sizeof ( sin6_dest ) );
sin6_dest.sin6_family = AF_INET6;
sin6_dest.sin6_scope_id = netdev->scope_id;
ipv6_solicited_node ( &sin6_dest.sin6_addr, net_dest );
/* Construct neighbour header */
memset ( &neigh, 0, sizeof ( neigh ) );
neigh.icmp.type = ICMPV6_NEIGHBOUR_SOLICITATION;
memcpy ( &neigh.target, net_dest, sizeof ( neigh.target ) );
/* Transmit neighbour discovery packet */
if ( ( rc = ndp_tx_ll_addr ( netdev, &sin6_src, &sin6_dest, &neigh,
sizeof ( neigh ),
NDP_OPT_LL_SOURCE ) ) != 0 )
return rc;
return 0;
}
/** NDP neighbour discovery protocol */
struct neighbour_discovery ndp_discovery = {
.name = "NDP",
.tx_request = ndp_tx_request,
};
/**
* Transmit NDP router solicitation
*
* @v netdev Network device
* @ret rc Return status code
*/
static int ndp_tx_router_solicitation ( struct net_device *netdev ) {
struct ndp_router_solicitation_header rsol;
struct sockaddr_in6 sin6_dest;
int rc;
/* Construct multicast destination address */
memset ( &sin6_dest, 0, sizeof ( sin6_dest ) );
sin6_dest.sin6_family = AF_INET6;
sin6_dest.sin6_scope_id = netdev->scope_id;
ipv6_all_routers ( &sin6_dest.sin6_addr );
/* Construct router solicitation */
memset ( &rsol, 0, sizeof ( rsol ) );
rsol.icmp.type = ICMPV6_ROUTER_SOLICITATION;
/* Transmit packet */
if ( ( rc = ndp_tx_ll_addr ( netdev, NULL, &sin6_dest, &rsol,
sizeof ( rsol ), NDP_OPT_LL_SOURCE ) ) !=0)
return rc;
return 0;
}
/**
* Process NDP neighbour solicitation source link-layer address option
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v ndp NDP packet
* @v option NDP option
* @v len NDP option length
* @ret rc Return status code
*/
static int
ndp_rx_neighbour_solicitation_ll_source ( struct net_device *netdev,
struct sockaddr_in6 *sin6_src,
union ndp_header *ndp,
union ndp_option *option,
size_t len ) {
struct ndp_neighbour_header *neigh = &ndp->neigh;
struct ndp_ll_addr_option *ll_addr_opt = &option->ll_addr;
struct ll_protocol *ll_protocol = netdev->ll_protocol;
int rc;
/* Silently ignore neighbour solicitations for addresses we do
* not own.
*/
if ( ! ipv6_has_addr ( netdev, &neigh->target ) )
return 0;
/* Sanity check */
if ( offsetof ( typeof ( *ll_addr_opt ),
ll_addr[ll_protocol->ll_addr_len] ) > len ) {
DBGC ( netdev, "NDP %s neighbour solicitation link-layer "
"address option too short at %zd bytes\n",
netdev->name, len );
return -EINVAL;
}
/* Create or update neighbour cache entry */
if ( ( rc = neighbour_define ( netdev, &ipv6_protocol,
&sin6_src->sin6_addr,
ll_addr_opt->ll_addr ) ) != 0 ) {
DBGC ( netdev, "NDP %s could not define %s => %s: %s\n",
netdev->name, inet6_ntoa ( &sin6_src->sin6_addr ),
ll_protocol->ntoa ( ll_addr_opt->ll_addr ),
strerror ( rc ) );
return rc;
}
/* Convert neighbour header to advertisement */
memset ( neigh, 0, offsetof ( typeof ( *neigh ), target ) );
neigh->icmp.type = ICMPV6_NEIGHBOUR_ADVERTISEMENT;
neigh->flags = ( NDP_NEIGHBOUR_SOLICITED | NDP_NEIGHBOUR_OVERRIDE );
/* Send neighbour advertisement */
if ( ( rc = ndp_tx_ll_addr ( netdev, NULL, sin6_src, neigh,
sizeof ( *neigh ),
NDP_OPT_LL_TARGET ) ) != 0 )
return rc;
return 0;
}
/**
* Process NDP neighbour advertisement target link-layer address option
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v ndp NDP packet
* @v option NDP option
* @v len NDP option length
* @ret rc Return status code
*/
static int
ndp_rx_neighbour_advertisement_ll_target ( struct net_device *netdev,
struct sockaddr_in6 *sin6_src
__unused,
union ndp_header *ndp,
union ndp_option *option,
size_t len ) {
struct ndp_neighbour_header *neigh = &ndp->neigh;
struct ndp_ll_addr_option *ll_addr_opt = &option->ll_addr;
struct ll_protocol *ll_protocol = netdev->ll_protocol;
int rc;
/* Sanity check */
if ( offsetof ( typeof ( *ll_addr_opt ),
ll_addr[ll_protocol->ll_addr_len] ) > len ) {
DBGC ( netdev, "NDP %s neighbour advertisement link-layer "
"address option too short at %zd bytes\n",
netdev->name, len );
return -EINVAL;
}
/* Update neighbour cache entry, if any */
if ( ( rc = neighbour_update ( netdev, &ipv6_protocol, &neigh->target,
ll_addr_opt->ll_addr ) ) != 0 ) {
DBGC ( netdev, "NDP %s could not update %s => %s: %s\n",
netdev->name, inet6_ntoa ( &neigh->target ),
ll_protocol->ntoa ( ll_addr_opt->ll_addr ),
strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Process NDP router advertisement source link-layer address option
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v ndp NDP packet
* @v option NDP option
* @v len NDP option length
* @ret rc Return status code
*/
static int
ndp_rx_router_advertisement_ll_source ( struct net_device *netdev,
struct sockaddr_in6 *sin6_src,
union ndp_header *ndp __unused,
union ndp_option *option, size_t len ) {
struct ndp_ll_addr_option *ll_addr_opt = &option->ll_addr;
struct ll_protocol *ll_protocol = netdev->ll_protocol;
int rc;
/* Sanity check */
if ( offsetof ( typeof ( *ll_addr_opt ),
ll_addr[ll_protocol->ll_addr_len] ) > len ) {
DBGC ( netdev, "NDP %s router advertisement link-layer address "
"option too short at %zd bytes\n", netdev->name, len );
return -EINVAL;
}
/* Define neighbour cache entry */
if ( ( rc = neighbour_define ( netdev, &ipv6_protocol,
&sin6_src->sin6_addr,
ll_addr_opt->ll_addr ) ) != 0 ) {
DBGC ( netdev, "NDP %s could not define %s => %s: %s\n",
netdev->name, inet6_ntoa ( &sin6_src->sin6_addr ),
ll_protocol->ntoa ( ll_addr_opt->ll_addr ),
strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Process NDP router advertisement prefix information option
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v ndp NDP packet
* @v option NDP option
* @v len NDP option length
* @ret rc Return status code
*/
static int
ndp_rx_router_advertisement_prefix ( struct net_device *netdev,
struct sockaddr_in6 *sin6_src,
union ndp_header *ndp,
union ndp_option *option, size_t len ) {
struct ndp_router_advertisement_header *radv = &ndp->radv;
struct ndp_prefix_information_option *prefix_opt = &option->prefix;
/* Sanity check */
if ( sizeof ( *prefix_opt ) > len ) {
DBGC ( netdev, "NDP %s router advertisement prefix option too "
"short at %zd bytes\n", netdev->name, len );
return -EINVAL;
}
DBGC ( netdev, "NDP %s found %sdefault router %s ",
netdev->name, ( radv->lifetime ? "" : "non-" ),
inet6_ntoa ( &sin6_src->sin6_addr ) );
DBGC ( netdev, "for %s-link %sautonomous prefix %s/%d\n",
( ( prefix_opt->flags & NDP_PREFIX_ON_LINK ) ? "on" : "off" ),
( ( prefix_opt->flags & NDP_PREFIX_AUTONOMOUS ) ? "" : "non-" ),
inet6_ntoa ( &prefix_opt->prefix ), prefix_opt->prefix_len );
return 0;
}
/** An NDP option handler */
struct ndp_option_handler {
/** ICMPv6 type */
uint8_t icmp_type;
/** Option type */
uint8_t option_type;
/**
* Handle received option
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v ndp NDP packet
* @v option NDP option
* @ret rc Return status code
*/
int ( * rx ) ( struct net_device *netdev, struct sockaddr_in6 *sin6_src,
union ndp_header *ndp, union ndp_option *option,
size_t len );
};
/** NDP option handlers */
static struct ndp_option_handler ndp_option_handlers[] = {
{
.icmp_type = ICMPV6_NEIGHBOUR_SOLICITATION,
.option_type = NDP_OPT_LL_SOURCE,
.rx = ndp_rx_neighbour_solicitation_ll_source,
},
{
.icmp_type = ICMPV6_NEIGHBOUR_ADVERTISEMENT,
.option_type = NDP_OPT_LL_TARGET,
.rx = ndp_rx_neighbour_advertisement_ll_target,
},
{
.icmp_type = ICMPV6_ROUTER_ADVERTISEMENT,
.option_type = NDP_OPT_LL_SOURCE,
.rx = ndp_rx_router_advertisement_ll_source,
},
{
.icmp_type = ICMPV6_ROUTER_ADVERTISEMENT,
.option_type = NDP_OPT_PREFIX,
.rx = ndp_rx_router_advertisement_prefix,
},
};
/**
* Process received NDP option
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v ndp NDP packet
* @v option NDP option
* @v len Option length
* @ret rc Return status code
*/
static int ndp_rx_option ( struct net_device *netdev,
struct sockaddr_in6 *sin6_src, union ndp_header *ndp,
union ndp_option *option, size_t len ) {
struct ndp_option_handler *handler;
unsigned int i;
/* Locate a suitable option handler, if any */
for ( i = 0 ; i < ( sizeof ( ndp_option_handlers ) /
sizeof ( ndp_option_handlers[0] ) ) ; i++ ) {
handler = &ndp_option_handlers[i];
if ( ( handler->icmp_type == ndp->icmp.type ) &&
( handler->option_type == option->header.type ) ) {
return handler->rx ( netdev, sin6_src, ndp,
option, len );
}
}
/* Silently ignore unknown options as per RFC 4861 */
return 0;
}
/**
* Process received NDP packet options
*
* @v netdev Network device
* @v sin6_src Source socket address
* @v ndp NDP header
* @v offset Offset to NDP options
* @v len Length of NDP packet
* @ret rc Return status code
*/
static int ndp_rx_options ( struct net_device *netdev,
struct sockaddr_in6 *sin6_src,
union ndp_header *ndp, size_t offset, size_t len ) {
union ndp_option *option;
size_t remaining;
size_t option_len;
int rc;
/* Sanity check */
if ( len < offset ) {
DBGC ( netdev, "NDP %s packet too short at %zd bytes (min %zd "
"bytes)\n", netdev->name, len, offset );
return -EINVAL;
}
/* Search for option */
option = ( ( ( void * ) ndp ) + offset );
remaining = ( len - offset );
while ( remaining ) {
/* Sanity check */
if ( ( remaining < sizeof ( option->header ) ) ||
( option->header.blocks == 0 ) ||
( remaining < ( option->header.blocks *
NDP_OPTION_BLKSZ ) ) ) {
DBGC ( netdev, "NDP %s bad option length:\n",
netdev->name );
DBGC_HDA ( netdev, 0, option, remaining );
return -EINVAL;
}
option_len = ( option->header.blocks * NDP_OPTION_BLKSZ );
/* Handle option */
if ( ( rc = ndp_rx_option ( netdev, sin6_src, ndp, option,
option_len ) ) != 0 )
return rc;
/* Move to next option */
option = ( ( ( void * ) option ) + option_len );
remaining -= option_len;
}
return 0;
}
/**
* Process received NDP neighbour solicitation or advertisement
*
* @v iobuf I/O buffer
* @v netdev Network device
* @v sin6_src Source socket address
* @v sin6_dest Destination socket address
* @ret rc Return status code
*/
static int ndp_rx_neighbour ( struct io_buffer *iobuf,
struct net_device *netdev,
struct sockaddr_in6 *sin6_src,
struct sockaddr_in6 *sin6_dest __unused ) {
union ndp_header *ndp = iobuf->data;
struct ndp_neighbour_header *neigh = &ndp->neigh;
size_t len = iob_len ( iobuf );
int rc;
/* Process options */
if ( ( rc = ndp_rx_options ( netdev, sin6_src, ndp,
offsetof ( typeof ( *neigh ), option ),
len ) ) != 0 )
goto err_options;
err_options:
free_iob ( iobuf );
return rc;
}
/**
* Process received NDP router advertisement
*
* @v iobuf I/O buffer
* @v netdev Network device
* @v sin6_src Source socket address
* @v sin6_dest Destination socket address
* @ret rc Return status code
*/
static int
ndp_rx_router_advertisement ( struct io_buffer *iobuf,
struct net_device *netdev,
struct sockaddr_in6 *sin6_src,
struct sockaddr_in6 *sin6_dest __unused ) {
union ndp_header *ndp = iobuf->data;
struct ndp_router_advertisement_header *radv = &ndp->radv;
struct in6_addr *router = &sin6_src->sin6_addr;
size_t len = iob_len ( iobuf );
int rc;
/* Process options */
if ( ( rc = ndp_rx_options ( netdev, sin6_src, ndp,
offsetof ( typeof ( *radv ), option ),
len ) ) != 0 )
goto err_options;
/* Pass to IPv6 autoconfiguration */
if ( ( rc = ipv6conf_rx_router_advertisement ( netdev, router,
radv, len ) ) != 0 )
goto err_ipv6conf;
err_ipv6conf:
err_options:
free_iob ( iobuf );
return rc;
}
/** NDP ICMPv6 handlers */
struct icmpv6_handler ndp_handlers[] __icmpv6_handler = {
{
.type = ICMPV6_NEIGHBOUR_SOLICITATION,
.rx = ndp_rx_neighbour,
},
{
.type = ICMPV6_NEIGHBOUR_ADVERTISEMENT,
.rx = ndp_rx_neighbour,
},
{
.type = ICMPV6_ROUTER_ADVERTISEMENT,
.rx = ndp_rx_router_advertisement,
},
};
/****************************************************************************
*
* NDP settings
*
*/
/** An NDP prefix settings block */
struct ndp_prefix_settings {
/** Settings interface */
struct settings settings;
/** Name */
char name[4];
/** Prefix information option */
struct ndp_prefix_information_option *prefix;
};
/** An NDP settings block */
struct ndp_settings {
/** Reference counter */
struct refcnt refcnt;
/** Settings interface */
struct settings settings;
/** Router address */
struct in6_addr router;
/** Router lifetime */
unsigned int lifetime;
/** Length of NDP options */
size_t len;
/** NDP options */
union ndp_option options[0];
};
/** NDP settings scope */
static const struct settings_scope ndp_settings_scope;
/**
* Construct NDP tag
*
* @v type NDP option type
* @v offset Starting offset of data
* @v len Length of data (or 0 to use all remaining data)
* @ret tag NDP tag
*/
#define NDP_TAG( type, offset, len ) \
( ( (len) << 16 ) | ( (offset) << 8 ) | (type) )
/**
* Extract NDP tag type
*
* @v tag NDP tag
* @ret type NDP option type
*/
#define NDP_TAG_TYPE( tag ) ( ( (tag) >> 0 ) & 0xff )
/**
* Extract NDP tag offset
*
* @v tag NDP tag
* @ret offset Starting offset of data
*/
#define NDP_TAG_OFFSET( tag ) ( ( (tag) >> 8 ) & 0xff )
/**
* Extract NDP tag length
*
* @v tag NDP tag
* @ret len Length of data (or 0 to use all remaining data)
*/
#define NDP_TAG_LEN( tag ) ( ( (tag) >> 16 ) & 0xff )
/**
* Extract NDP tag instance
*
* @v tag NDP tag
* @ret instance Instance
*/
#define NDP_TAG_INSTANCE( tag ) ( ( (tag) >> 24 ) & 0xff )
/**
* Check applicability of NDP setting
*
* @v settings Settings block
* @v setting Setting to fetch
* @ret applies Setting applies within this settings block
*/
static int ndp_applies ( struct settings *settings __unused,
const struct setting *setting ) {
return ( setting->scope == &ndp_settings_scope );
}
/**
* Fetch value of NDP setting
*
* @v settings Settings block
* @v setting Setting to fetch
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
static int ndp_fetch ( struct settings *settings,
struct setting *setting,
void *data, size_t len ) {
struct ndp_settings *ndpset =
container_of ( settings, struct ndp_settings, settings );
struct net_device *netdev =
container_of ( settings->parent, struct net_device,
settings.settings );
union ndp_option *option;
unsigned int tag_type;
unsigned int tag_offset;
unsigned int tag_len;
unsigned int tag_instance;
size_t offset;
size_t option_len;
void *option_data;
/* Parse setting tag */
tag_type = NDP_TAG_TYPE ( setting->tag );
tag_offset = NDP_TAG_OFFSET ( setting->tag );
tag_len = NDP_TAG_LEN ( setting->tag );
tag_instance = NDP_TAG_INSTANCE ( setting->tag );
/* Scan through NDP options for requested type. We can assume
* that the options are well-formed, otherwise they would have
* been rejected prior to being stored.
*/
for ( offset = 0 ; offset < ndpset->len ; offset += option_len ) {
/* Calculate option length */
option = ( ( ( void * ) ndpset->options ) + offset );
option_len = ( option->header.blocks * NDP_OPTION_BLKSZ );
/* Skip options that do not match this tag */
if ( option->header.type != tag_type )
continue;
/* Skip previous instances of this option */
if ( tag_instance-- != 0 )
continue;
/* Sanity check */
if ( ( tag_offset + tag_len ) > option_len ) {
DBGC ( netdev, "NDP %s option %d too short\n",
netdev->name, tag_type );
return -EINVAL;
}
if ( ! tag_len )
tag_len = ( option_len - tag_offset );
option_data = ( ( ( void * ) option ) + tag_offset );
/* Copy data to output buffer */
if ( len > tag_len )
len = tag_len;
memcpy ( data, option_data, len );
/* Default to hex if no type is specified */
if ( ! setting->type )
setting->type = &setting_type_hex;
return tag_len;
}
return -ENOENT;
}
/** NDP settings operations */
static struct settings_operations ndp_settings_operations = {
.applies = ndp_applies,
.fetch = ndp_fetch,
};
/**
* Check applicability of NDP per-prefix setting
*
* @v settings Settings block
* @v setting Setting to fetch
* @ret applies Setting applies within this settings block
*/
static int ndp_prefix_applies ( struct settings *settings __unused,
const struct setting *setting ) {
return ( setting->scope == &ipv6_settings_scope );
}
/**
* Fetch value of NDP IPv6 address setting
*
* @v settings Settings block
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
static int ndp_prefix_fetch_ip6 ( struct settings *settings, void *data,
size_t len ) {
struct ndp_prefix_settings *prefset =
container_of ( settings, struct ndp_prefix_settings, settings );
struct ndp_settings *ndpset =
container_of ( settings->parent, struct ndp_settings, settings);
struct net_device *netdev =
container_of ( ndpset->settings.parent, struct net_device,
settings.settings );
struct ndp_prefix_information_option *prefix = prefset->prefix;
struct in6_addr *ip6 = &prefix->prefix;
struct in6_addr slaac;
int prefix_len;
int rc;
/* Skip dead prefixes */
if ( ! prefix->valid )
return -ENOENT;
/* Construct IPv6 address via SLAAC, if applicable */
if ( prefix->flags & NDP_PREFIX_AUTONOMOUS ) {
memcpy ( &slaac, ip6, sizeof ( slaac ) );
prefix_len = ipv6_eui64 ( &slaac, netdev );
if ( prefix_len == prefix->prefix_len ) {
/* Correctly configured prefix: use SLAAC address */
ip6 = &slaac;
} else if ( prefix_len < 0 ) {
/* Link layer does not support SLAAC */
rc = prefix_len;
DBGC ( netdev, "NDP %s does not support SLAAC: %s\n",
netdev->name, strerror ( rc ) );
} else {
/* Prefix length incorrect: assume a badly
* configured router and ignore SLAAC address.
*/
DBGC ( netdev, "NDP %s ignoring misconfigured SLAAC "
"on prefix %s/%d\n", netdev->name,
inet6_ntoa ( ip6 ), prefix->prefix_len );
}
}
/* Fill in IPv6 address */
if ( len > sizeof ( *ip6 ) )
len = sizeof ( *ip6 );
memcpy ( data, ip6, len );
return sizeof ( *ip6 );
}
/**
* Fetch value of NDP prefix length setting
*
* @v settings Settings block
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
static int ndp_prefix_fetch_len6 ( struct settings *settings, void *data,
size_t len ) {
struct ndp_prefix_settings *prefset =
container_of ( settings, struct ndp_prefix_settings, settings );
struct ndp_prefix_information_option *prefix = prefset->prefix;
uint8_t *len6;
/* Fill in prefix length */
if ( len >= sizeof ( *len6 ) ) {
/* We treat an off-link prefix as having a prefix
* length covering the entire IPv6 address.
*/
len6 = data;
*len6 = ( ( prefix->flags & NDP_PREFIX_ON_LINK ) ?
prefix->prefix_len : -1UL );
}
return sizeof ( *len6 );
}
/**
* Fetch value of NDP router address setting
*
* @v settings Settings block
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
static int ndp_prefix_fetch_gateway6 ( struct settings *settings,
void *data, size_t len ) {
struct ndp_settings *ndpset =
container_of ( settings->parent, struct ndp_settings, settings);
/* Treat non-routing router as non-existent */
if ( ! ndpset->lifetime )
return -ENOENT;
/* Fill in router address */
if ( len > sizeof ( ndpset->router ) )
len = sizeof ( ndpset->router );
memcpy ( data, &ndpset->router, len );
return sizeof ( ndpset->router );
}
/** An NDP per-prefix setting operation */
struct ndp_prefix_operation {
/** Generic setting */
const struct setting *setting;
/**
* Fetch value of setting
*
* @v settings Settings block
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
int ( * fetch ) ( struct settings *settings, void *data, size_t len );
};
/** NDP per-prefix settings operations */
static struct ndp_prefix_operation ndp_prefix_operations[] = {
{ &ip6_setting, ndp_prefix_fetch_ip6 },
{ &len6_setting, ndp_prefix_fetch_len6 },
{ &gateway6_setting, ndp_prefix_fetch_gateway6 },
};
/**
* Fetch value of NDP pre-prefix setting
*
* @v settings Settings block
* @v setting Setting to fetch
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
static int ndp_prefix_fetch ( struct settings *settings,
struct setting *setting,
void *data, size_t len ) {
struct ndp_prefix_operation *op;
unsigned int i;
/* Handle per-prefix settings */
for ( i = 0 ; i < ( sizeof ( ndp_prefix_operations ) /
sizeof ( ndp_prefix_operations[0] ) ) ; i++ ) {
op = &ndp_prefix_operations[i];
if ( setting_cmp ( setting, op->setting ) == 0 )
return op->fetch ( settings, data, len );
}
return -ENOENT;
}
/** NDP per-prefix settings operations */
static struct settings_operations ndp_prefix_settings_operations = {
.applies = ndp_prefix_applies,
.fetch = ndp_prefix_fetch,
};
/**
* Register NDP settings
*
* @v netdev Network device
* @v router Router address
* @v lifetime Router lifetime
* @v options NDP options
* @v len Length of options
* @ret rc Return status code
*/
static int ndp_register_settings ( struct net_device *netdev,
struct in6_addr *router,
unsigned int lifetime,
union ndp_option *options, size_t len ) {
struct settings *parent = netdev_settings ( netdev );
union ndp_option *option;
struct ndp_settings *ndpset;
struct ndp_prefix_settings *prefset;
size_t offset;
size_t option_len;
unsigned int prefixes;
unsigned int instance;
int order;
int rc;
/* Count number of prefix options. We can assume that the
* options are well-formed, otherwise they would have been
* rejected prior to being stored.
*/
order = IPV6_ORDER_PREFIX_ONLY;
for ( prefixes = 0, offset = 0 ; offset < len ; offset += option_len ) {
/* Skip non-prefix options */
option = ( ( ( void * ) options ) + offset );
option_len = ( option->header.blocks * NDP_OPTION_BLKSZ );
if ( option->header.type != NDP_OPT_PREFIX )
continue;
/* Count number of prefixes */
prefixes++;
/* Increase overall order if we have SLAAC addresses */
if ( option->prefix.flags & NDP_PREFIX_AUTONOMOUS )
order = IPV6_ORDER_SLAAC;
}
/* Allocate and initialise structure */
ndpset = zalloc ( sizeof ( *ndpset ) + len +
( prefixes * sizeof ( *prefset ) ) );
if ( ! ndpset ) {
rc = -ENOMEM;
goto err_alloc;
}
ref_init ( &ndpset->refcnt, NULL );
settings_init ( &ndpset->settings, &ndp_settings_operations,
&ndpset->refcnt, &ndp_settings_scope );
ndpset->settings.order = order;
memcpy ( &ndpset->router, router, sizeof ( ndpset->router ) );
ndpset->lifetime = lifetime;
ndpset->len = len;
memcpy ( ndpset->options, options, len );
prefset = ( ( ( void * ) ndpset->options ) + len );
/* Register settings */
if ( ( rc = register_settings ( &ndpset->settings, parent,
NDP_SETTINGS_NAME ) ) != 0 )
goto err_register;
/* Construct and register per-prefix settings */
for ( instance = 0, offset = 0 ; offset < len ; offset += option_len ) {
/* Skip non-prefix options */
option = ( ( ( void * ) ndpset->options ) + offset );
option_len = ( option->header.blocks * NDP_OPTION_BLKSZ );
if ( option->header.type != NDP_OPT_PREFIX )
continue;
/* Initialise structure */
settings_init ( &prefset->settings,
&ndp_prefix_settings_operations,
&ndpset->refcnt, &ndp_settings_scope );
prefset->settings.order =
( ( option->prefix.flags & NDP_PREFIX_AUTONOMOUS ) ?
IPV6_ORDER_SLAAC : IPV6_ORDER_PREFIX_ONLY );
prefset->prefix = &option->prefix;
snprintf ( prefset->name, sizeof ( prefset->name ), "%d",
instance++ );
/* Register settings */
if ( ( rc = register_settings ( &prefset->settings,
&ndpset->settings,
prefset->name ) ) != 0 )
goto err_register_prefix;
/* Move to next per-prefix settings */
prefset++;
}
assert ( instance == prefixes );
ref_put ( &ndpset->refcnt );
return 0;
err_register_prefix:
unregister_settings ( &ndpset->settings );
err_register:
ref_put ( &ndpset->refcnt );
err_alloc:
return rc;
}
/** DNS server setting */
const struct setting ndp_dns6_setting __setting ( SETTING_IP6_EXTRA, dns6 ) = {
.name = "dns6",
.description = "DNS server",
.tag = NDP_TAG ( NDP_OPT_RDNSS,
offsetof ( struct ndp_rdnss_option, addresses ), 0 ),
.type = &setting_type_ipv6,
.scope = &ndp_settings_scope,
};
/** DNS search list setting */
const struct setting ndp_dnssl_setting __setting ( SETTING_IP_EXTRA, dnssl ) = {
.name = "dnssl",
.description = "DNS search list",
.tag = NDP_TAG ( NDP_OPT_DNSSL,
offsetof ( struct ndp_dnssl_option, names ), 0 ),
.type = &setting_type_dnssl,
.scope = &ndp_settings_scope,
};
/****************************************************************************
*
* IPv6 autoconfiguration
*
*/
/** An IPv6 configurator */
struct ipv6conf {
/** Reference count */
struct refcnt refcnt;
/** List of configurators */
struct list_head list;
/** Job control interface */
struct interface job;
/** DHCPv6 interface */
struct interface dhcp;
/** Network device being configured */
struct net_device *netdev;
/** Retransmission timer */
struct retry_timer timer;
/** Deferred discovery counter */
unsigned int deferred;
};
/** List of IPv6 configurators */
static LIST_HEAD ( ipv6confs );
/**
* Free IPv6 configurator
*
* @v refcnt Reference count
*/
static void ipv6conf_free ( struct refcnt *refcnt ) {
struct ipv6conf *ipv6conf =
container_of ( refcnt, struct ipv6conf, refcnt );
netdev_put ( ipv6conf->netdev );
free ( ipv6conf );
}
/**
* Identify IPv6 configurator by network device
*
* @v netdev Network device
* @ret ipv6 IPv6 configurator, or NULL
*/
static struct ipv6conf * ipv6conf_demux ( struct net_device *netdev ) {
struct ipv6conf *ipv6conf;
list_for_each_entry ( ipv6conf, &ipv6confs, list ) {
if ( ipv6conf->netdev == netdev )
return ipv6conf;
}
return NULL;
}
/**
* Finish IPv6 autoconfiguration
*
* @v ipv6 IPv6 configurator
* @v rc Reason for finishing
*/
static void ipv6conf_done ( struct ipv6conf *ipv6conf, int rc ) {
/* Shut down interfaces */
intf_shutdown ( &ipv6conf->job, rc );
intf_shutdown ( &ipv6conf->dhcp, rc );
/* Stop timer */
stop_timer ( &ipv6conf->timer );
/* Remove from list and drop list's reference */
list_del ( &ipv6conf->list );
ref_put ( &ipv6conf->refcnt );
}
/**
* Handle IPv6 configurator timer expiry
*
* @v timer Retry timer
* @v fail Failure indicator
*/
static void ipv6conf_expired ( struct retry_timer *timer, int fail ) {
struct ipv6conf *ipv6conf =
container_of ( timer, struct ipv6conf, timer );
struct net_device *netdev = ipv6conf->netdev;
/* If we have failed, terminate autoconfiguration */
if ( fail ) {
ipv6conf_done ( ipv6conf, -ETIMEDOUT );
return;
}
/* Otherwise, transmit router solicitation and restart timer */
start_timer ( &ipv6conf->timer );
ndp_tx_router_solicitation ( netdev );
/* If link is blocked, defer router discovery timeout */
if ( netdev_link_blocked ( netdev ) &&
( ipv6conf->deferred++ <= IPV6CONF_MAX_DEFERRALS ) ) {
DBGC ( netdev, "NDP %s deferring discovery timeout\n",
netdev->name );
start_timer_fixed ( &ipv6conf->timer, IPV6CONF_BLOCK_TIMEOUT );
}
}
/**
* Handle router advertisement during IPv6 autoconfiguration
*
* @v netdev Network device
* @v router Router address
* @v radv Router advertisement
* @v len Length of router advertisement
* @ret rc Return status code
*
* This function assumes that the router advertisement is well-formed,
* since it must have already passed through option processing.
*/
static int
ipv6conf_rx_router_advertisement ( struct net_device *netdev,
struct in6_addr *router,
struct ndp_router_advertisement_header *radv,
size_t len ) {
struct ipv6conf *ipv6conf;
size_t option_len;
int stateful;
int rc;
/* Identify IPv6 configurator, if any */
ipv6conf = ipv6conf_demux ( netdev );
/* Do nothing unless IPv6 autoconfiguration is in progress */
if ( ! ipv6conf )
return 0;
/* If this is not the first solicited router advertisement, ignore it */
if ( ! timer_running ( &ipv6conf->timer ) )
return 0;
/* Stop router solicitation timer */
stop_timer ( &ipv6conf->timer );
/* Register NDP settings */
option_len = ( len - offsetof ( typeof ( *radv ), option ) );
if ( ( rc = ndp_register_settings ( netdev, router,
ntohl ( radv->lifetime ),
radv->option, option_len ) ) != 0 )
return rc;
/* Start DHCPv6 if required */
if ( radv->flags & ( NDP_ROUTER_MANAGED | NDP_ROUTER_OTHER ) ) {
stateful = ( radv->flags & NDP_ROUTER_MANAGED );
if ( ( rc = start_dhcpv6 ( &ipv6conf->dhcp, netdev,
stateful ) ) != 0 ) {
DBGC ( netdev, "NDP %s could not start state%s DHCPv6: "
"%s\n", netdev->name,
( stateful ? "ful" : "less" ), strerror ( rc ) );
ipv6conf_done ( ipv6conf, rc );
return rc;
}
return 0;
}
/* Otherwise, terminate autoconfiguration */
ipv6conf_done ( ipv6conf, 0 );
return 0;
}
/** IPv6 configurator job interface operations */
static struct interface_operation ipv6conf_job_op[] = {
INTF_OP ( intf_close, struct ipv6conf *, ipv6conf_done ),
};
/** IPv6 configurator job interface descriptor */
static struct interface_descriptor ipv6conf_job_desc =
INTF_DESC ( struct ipv6conf, job, ipv6conf_job_op );
/** IPv6 configurator DHCPv6 interface operations */
static struct interface_operation ipv6conf_dhcp_op[] = {
INTF_OP ( intf_close, struct ipv6conf *, ipv6conf_done ),
};
/** IPv6 configurator DHCPv6 interface descriptor */
static struct interface_descriptor ipv6conf_dhcp_desc =
INTF_DESC ( struct ipv6conf, dhcp, ipv6conf_dhcp_op );
/**
* Start IPv6 autoconfiguration
*
* @v job Job control interface
* @v netdev Network device
* @ret rc Return status code
*/
int start_ipv6conf ( struct interface *job, struct net_device *netdev ) {
struct ipv6conf *ipv6conf;
/* Allocate and initialise structure */
ipv6conf = zalloc ( sizeof ( *ipv6conf ) );
if ( ! ipv6conf )
return -ENOMEM;
ref_init ( &ipv6conf->refcnt, ipv6conf_free );
intf_init ( &ipv6conf->job, &ipv6conf_job_desc, &ipv6conf->refcnt );
intf_init ( &ipv6conf->dhcp, &ipv6conf_dhcp_desc, &ipv6conf->refcnt );
timer_init ( &ipv6conf->timer, ipv6conf_expired, &ipv6conf->refcnt );
set_timer_limits ( &ipv6conf->timer, IPV6CONF_MIN_TIMEOUT,
IPV6CONF_MAX_TIMEOUT );
ipv6conf->netdev = netdev_get ( netdev );
/* Start timer to initiate router solicitation */
start_timer_nodelay ( &ipv6conf->timer );
/* Attach parent interface, transfer reference to list, and return */
intf_plug_plug ( &ipv6conf->job, job );
list_add ( &ipv6conf->list, &ipv6confs );
return 0;
}
/** IPv6 network device configurator */
struct net_device_configurator ipv6_configurator __net_device_configurator = {
.name = "ipv6",
.start = start_ipv6conf,
};