ndp.c File Reference

IPv6 neighbour discovery protocol. More...

#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>

Go to the source code of this file.

Data Structures
struct	ndp_option_handler
	An NDP option handler. More...
struct	ndp_prefix_settings
	An NDP prefix settings block. More...
struct	ndp_settings
	An NDP settings block. More...
struct	ndp_prefix_operation
	An NDP per-prefix setting operation. More...
struct	ipv6conf
	An IPv6 configurator. More...

Macros
#define	IPV6CONF_MIN_TIMEOUT   ( TICKS_PER_SEC / 8 )
	Router discovery minimum timeout. More...
#define	IPV6CONF_MAX_TIMEOUT   ( TICKS_PER_SEC * 3 )
	Router discovery maximum timeout. More...
#define	IPV6CONF_BLOCK_TIMEOUT   ( TICKS_PER_SEC )
	Router discovery blocked link retry timeout. More...
#define	IPV6CONF_MAX_DEFERRALS   180
	Router discovery maximum number of deferrals. More...
#define	NDP_TAG(type, offset, len)   ( ( (len) << 16 ) | ( (offset) << 8 ) | (type) )
	Construct NDP tag. More...
#define	NDP_TAG_TYPE(tag)   ( ( (tag) >> 0 ) & 0xff )
	Extract NDP tag type. More...
#define	NDP_TAG_OFFSET(tag)   ( ( (tag) >> 8 ) & 0xff )
	Extract NDP tag offset. More...
#define	NDP_TAG_LEN(tag)   ( ( (tag) >> 16 ) & 0xff )
	Extract NDP tag length. More...
#define	NDP_TAG_INSTANCE(tag)   ( ( (tag) >> 24 ) & 0xff )
	Extract NDP tag instance. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER)
static struct ipv6conf *	ipv6conf_demux (struct net_device *netdev)
	Identify IPv6 configurator by network device. More...
static int	ipv6conf_rx_router_advertisement (struct net_device *netdev, struct in6_addr *router, struct ndp_router_advertisement_header *radv, size_t len)
	Handle router advertisement during IPv6 autoconfiguration. More...
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)
	Transmit NDP packet with link-layer address option. More...
static int	ndp_tx_request (struct net_device *netdev, struct net_protocol *net_protocol __unused, const void *net_dest, const void *net_source)
	Transmit NDP neighbour discovery request. More...
static int	ndp_tx_router_solicitation (struct net_device *netdev)
	Transmit NDP router solicitation. More...
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)
	Process NDP neighbour solicitation source link-layer address option. More...
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)
	Process NDP neighbour advertisement target link-layer address option. More...
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)
	Process NDP router advertisement source link-layer address option. More...
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)
	Process NDP router advertisement prefix information option. More...
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)
	Process received NDP option. More...
static int	ndp_rx_options (struct net_device *netdev, struct sockaddr_in6 *sin6_src, union ndp_header *ndp, size_t offset, size_t len)
	Process received NDP packet options. More...
static int	ndp_rx_neighbour (struct io_buffer *iobuf, struct net_device *netdev, struct sockaddr_in6 *sin6_src, struct sockaddr_in6 *sin6_dest __unused)
	Process received NDP neighbour solicitation or advertisement. More...
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)
	Process received NDP router advertisement. More...
static int	ndp_applies (struct settings *settings __unused, const struct setting *setting)
	Check applicability of NDP setting. More...
static int	ndp_fetch (struct settings *settings, struct setting *setting, void *data, size_t len)
	Fetch value of NDP setting. More...
static int	ndp_prefix_applies (struct settings *settings __unused, const struct setting *setting)
	Check applicability of NDP per-prefix setting. More...
static int	ndp_prefix_fetch_ip6 (struct settings *settings, void *data, size_t len)
	Fetch value of NDP IPv6 address setting. More...
static int	ndp_prefix_fetch_len6 (struct settings *settings, void *data, size_t len)
	Fetch value of NDP prefix length setting. More...
static int	ndp_prefix_fetch_gateway6 (struct settings *settings, void *data, size_t len)
	Fetch value of NDP router address setting. More...
static int	ndp_prefix_fetch (struct settings *settings, struct setting *setting, void *data, size_t len)
	Fetch value of NDP pre-prefix setting. More...
static int	ndp_register_settings (struct net_device *netdev, struct in6_addr *router, unsigned int lifetime, union ndp_option *options, size_t len)
	Register NDP settings. More...
const struct setting ndp_dns6_setting	__setting (SETTING_IP6_EXTRA, dns6)
	DNS server setting. More...
const struct setting ndp_dnssl_setting	__setting (SETTING_IP_EXTRA, dnssl)
	DNS search list setting. More...
static	LIST_HEAD (ipv6confs)
	List of IPv6 configurators. More...
static void	ipv6conf_free (struct refcnt *refcnt)
	Free IPv6 configurator. More...
static void	ipv6conf_done (struct ipv6conf *ipv6conf, int rc)
	Finish IPv6 autoconfiguration. More...
static void	ipv6conf_expired (struct retry_timer *timer, int fail)
	Handle IPv6 configurator timer expiry. More...
int	start_ipv6conf (struct interface *job, struct net_device *netdev)
	Start IPv6 autoconfiguration. More...

Variables
struct neighbour_discovery	ndp_discovery
	NDP neighbour discovery protocol. More...
static struct ndp_option_handler	ndp_option_handlers []
	NDP option handlers. More...
struct icmpv6_handler ndp_handlers []	__icmpv6_handler
	NDP ICMPv6 handlers. More...
static const struct settings_scope	ndp_settings_scope
	NDP settings scope. More...
static struct settings_operations	ndp_settings_operations
	NDP settings operations. More...
static struct ndp_prefix_operation	ndp_prefix_operations []
	NDP per-prefix settings operations. More...
static struct settings_operations	ndp_prefix_settings_operations
	NDP per-prefix settings operations. More...
static struct interface_operation	ipv6conf_job_op []
	IPv6 configurator job interface operations. More...
static struct interface_descriptor	ipv6conf_job_desc
	IPv6 configurator job interface descriptor. More...
static struct interface_operation	ipv6conf_dhcp_op []
	IPv6 configurator DHCPv6 interface operations. More...
static struct interface_descriptor	ipv6conf_dhcp_desc
	IPv6 configurator DHCPv6 interface descriptor. More...
struct net_device_configurator ipv6_configurator	__net_device_configurator
	IPv6 network device configurator. More...

Detailed Description

IPv6 neighbour discovery protocol.

Definition in file ndp.c.

Macro Definition Documentation

IPV6CONF_MIN_TIMEOUT

#define IPV6CONF_MIN_TIMEOUT   ( TICKS_PER_SEC / 8 )

Router discovery minimum timeout.

Definition at line 44 of file ndp.c.

IPV6CONF_MAX_TIMEOUT

#define IPV6CONF_MAX_TIMEOUT   ( TICKS_PER_SEC * 3 )

Router discovery maximum timeout.

Definition at line 47 of file ndp.c.

IPV6CONF_BLOCK_TIMEOUT

#define IPV6CONF_BLOCK_TIMEOUT   ( TICKS_PER_SEC )

Router discovery blocked link retry timeout.

Definition at line 50 of file ndp.c.

IPV6CONF_MAX_DEFERRALS

#define IPV6CONF_MAX_DEFERRALS   180

Router discovery maximum number of deferrals.

Definition at line 53 of file ndp.c.

NDP_TAG

#define NDP_TAG	(		type,
			offset,
			len
	)		( ( (len) << 16 ) | ( (offset) << 8 ) | (type) )

Construct NDP tag.

Parameters

type	NDP option type
offset	Starting offset of data
len	Length of data (or 0 to use all remaining data)

Return values

tag

NDP tag

Definition at line 632 of file ndp.c.

NDP_TAG_TYPE

#define NDP_TAG_TYPE

(

tag

)

( ( (tag) >> 0 ) & 0xff )

Extract NDP tag type.

Parameters

tag

NDP tag

Return values

type	NDP option type

Definition at line 641 of file ndp.c.

NDP_TAG_OFFSET

#define NDP_TAG_OFFSET

(

tag

)

( ( (tag) >> 8 ) & 0xff )

Extract NDP tag offset.

Parameters

tag

NDP tag

Return values

offset

Starting offset of data

Definition at line 649 of file ndp.c.

NDP_TAG_LEN

#define NDP_TAG_LEN

(

tag

)

( ( (tag) >> 16 ) & 0xff )

Extract NDP tag length.

Parameters

tag

NDP tag

Return values

len	Length of data (or 0 to use all remaining data)

Definition at line 657 of file ndp.c.

NDP_TAG_INSTANCE

#define NDP_TAG_INSTANCE

(

tag

)

( ( (tag) >> 24 ) & 0xff )

Extract NDP tag instance.

Parameters

tag

NDP tag

Return values

instance

Instance

Definition at line 665 of file ndp.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

ipv6conf_demux()

static struct ipv6conf * ipv6conf_demux ( struct net_device *  netdev )

static

Identify IPv6 configurator by network device.

Parameters

netdev

Network device

Return values

ipv6	IPv6 configurator, or NULL

Definition at line 1118 of file ndp.c.

                                                                      {
        struct ipv6conf *ipv6conf;

        list_for_each_entry ( ipv6conf, &ipv6confs, list ) {
                if ( ipv6conf->netdev == netdev )
                        return ipv6conf;
        }
        return NULL;
}

References ipv6conf::list, list_for_each_entry, netdev, ipv6conf::netdev, and NULL.

Referenced by ipv6conf_rx_router_advertisement().

ipv6conf_rx_router_advertisement()

static int ipv6conf_rx_router_advertisement ( struct net_device *  netdev, struct in6_addr *  router, struct ndp_router_advertisement_header *  radv, size_t  len  )

static

Handle router advertisement during IPv6 autoconfiguration.

Parameters

netdev	Network device
router	Router address
radv	Router advertisement
len	Length of router advertisement

Return values

rc	Return status code

This function assumes that the router advertisement is well-formed, since it must have already passed through option processing.

Definition at line 1191 of file ndp.c.

                                                {
        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, router,
                                           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;
}

References DBGC, ipv6conf::dhcp, ndp_router_advertisement_header::flags, ipv6conf_demux(), ipv6conf_done(), len, ndp_router_advertisement_header::lifetime, net_device::name, ndp_register_settings(), NDP_ROUTER_MANAGED, NDP_ROUTER_OTHER, netdev, ntohl, offsetof, ndp_router_advertisement_header::option, rc, start_dhcpv6(), stop_timer(), strerror(), ipv6conf::timer, and typeof().

Referenced by ndp_rx_router_advertisement().

ndp_tx_ll_addr()

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  )

static

Transmit NDP packet with link-layer address option.

Parameters

netdev	Network device
sin6_src	Source socket address
sin6_dest	Destination socket address
data	NDP header
len	Size of NDP header
option_type	NDP option type

Return values

rc	Return status code

Definition at line 73 of file ndp.c.

                                                       {
        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;
}

References alloc_iob(), ndp_option_header::blocks, icmp_header::chksum, data, io_buffer::data, DBGC, ENOMEM, ndp_ll_addr_option::header, ndp_header::icmp, iob_put, iob_reserve, len, ndp_ll_addr_option::ll_addr, net_device::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, MAX_LL_NET_HEADER_LEN, memcpy(), net_device::name, NDP_OPTION_BLKSZ, netdev, rc, strerror(), tcpip_chksum(), tcpip_tx(), and ndp_option_header::type.

Referenced by ndp_rx_neighbour_solicitation_ll_source(), ndp_tx_request(), and ndp_tx_router_solicitation().

ndp_tx_request()

static int ndp_tx_request ( struct net_device *  netdev, struct net_protocol *net_protocol  __unused, const void *  net_dest, const void *  net_source  )

static

Transmit NDP neighbour discovery request.

Parameters

netdev	Network device
net_protocol	Network-layer protocol
net_dest	Destination network-layer address
net_source	Source network-layer address

Return values

rc	Return status code

Definition at line 126 of file ndp.c.

                                                                           {
        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;
}

References AF_INET6, ndp_neighbour_header::icmp, ICMPV6_NEIGHBOUR_SOLICITATION, ipv6_solicited_node(), memcpy(), memset(), NDP_OPT_LL_SOURCE, ndp_tx_ll_addr(), netdev, rc, net_device::scope_id, sockaddr_in6::sin6_addr, sockaddr_in6::sin6_family, sockaddr_in6::sin6_scope_id, ndp_neighbour_header::target, and icmp_header::type.

ndp_tx_router_solicitation()

static int ndp_tx_router_solicitation ( struct net_device *  netdev )

static

Transmit NDP router solicitation.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 172 of file ndp.c.

                                                                    {
        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;
}

References AF_INET6, ndp_router_solicitation_header::icmp, ICMPV6_ROUTER_SOLICITATION, ipv6_all_routers(), memset(), NDP_OPT_LL_SOURCE, ndp_tx_ll_addr(), netdev, NULL, rc, net_device::scope_id, sockaddr_in6::sin6_addr, sockaddr_in6::sin6_family, sockaddr_in6::sin6_scope_id, and icmp_header::type.

Referenced by ipv6conf_expired().

ndp_rx_neighbour_solicitation_ll_source()

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  )

static

Process NDP neighbour solicitation source link-layer address option.

Parameters

netdev	Network device
sin6_src	Source socket address
ndp	NDP packet
option	NDP option
len	NDP option length

Return values

rc	Return status code

Definition at line 206 of file ndp.c.

                                                       {
        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;
}

References DBGC, EINVAL, ndp_neighbour_header::flags, ndp_neighbour_header::icmp, ICMPV6_NEIGHBOUR_ADVERTISEMENT, inet6_ntoa(), ipv6_has_addr(), len, ndp_ll_addr_option::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, memset(), net_device::name, NDP_NEIGHBOUR_OVERRIDE, NDP_NEIGHBOUR_SOLICITED, NDP_OPT_LL_TARGET, ndp_tx_ll_addr(), ndp_header::neigh, neighbour_define(), netdev, ll_protocol::ntoa, NULL, offsetof, rc, sockaddr_in6::sin6_addr, strerror(), ndp_neighbour_header::target, icmp_header::type, and typeof().

ndp_rx_neighbour_advertisement_ll_target()

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  )

static

Process NDP neighbour advertisement target link-layer address option.

Parameters

netdev	Network device
sin6_src	Source socket address
ndp	NDP packet
option	NDP option
len	NDP option length

Return values

rc	Return status code

Definition at line 267 of file ndp.c.

                                                        {
        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;
}

References DBGC, EINVAL, inet6_ntoa(), len, ndp_ll_addr_option::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, net_device::name, ndp_header::neigh, neighbour_update(), netdev, ll_protocol::ntoa, offsetof, rc, strerror(), ndp_neighbour_header::target, and typeof().

ndp_rx_router_advertisement_ll_source()

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  )

static

Process NDP router advertisement source link-layer address option.

Parameters

netdev	Network device
sin6_src	Source socket address
ndp	NDP packet
option	NDP option
len	NDP option length

Return values

rc	Return status code

Definition at line 311 of file ndp.c.

                                                                               {
        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;
}

References DBGC, EINVAL, inet6_ntoa(), len, ndp_ll_addr_option::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, net_device::name, neighbour_define(), netdev, ll_protocol::ntoa, offsetof, rc, sockaddr_in6::sin6_addr, strerror(), and typeof().

ndp_rx_router_advertisement_prefix()

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  )

static

Process NDP router advertisement prefix information option.

Parameters

netdev	Network device
sin6_src	Source socket address
ndp	NDP packet
option	NDP option
len	NDP option length

Return values

rc	Return status code

Definition at line 352 of file ndp.c.

                                                                            {
        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;
}

References DBGC, EINVAL, ndp_prefix_information_option::flags, inet6_ntoa(), len, ndp_router_advertisement_header::lifetime, net_device::name, NDP_PREFIX_AUTONOMOUS, NDP_PREFIX_ON_LINK, netdev, ndp_prefix_information_option::prefix, ndp_prefix_information_option::prefix_len, ndp_header::radv, and sockaddr_in6::sin6_addr.

ndp_rx_option()

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  )

static

Process received NDP option.

Parameters

netdev	Network device
sin6_src	Source socket address
ndp	NDP packet
option	NDP option
len	Option length

Return values

rc	Return status code

Definition at line 431 of file ndp.c.

                                                                  {
        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;
}

References ndp_header::icmp, ndp_option_handler::icmp_type, len, ndp_option_handlers, netdev, ndp_option_handler::option_type, ndp_option_handler::rx, and icmp_header::type.

Referenced by ndp_rx_options().

ndp_rx_options()

static int ndp_rx_options ( struct net_device *  netdev, struct sockaddr_in6 *  sin6_src, union ndp_header *  ndp, size_t  offset, size_t  len  )

static

Process received NDP packet options.

Parameters

netdev	Network device
sin6_src	Source socket address
ndp	NDP header
offset	Offset to NDP options
len	Length of NDP packet

Return values

rc	Return status code

Definition at line 462 of file ndp.c.

                                                                               {
        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;
}

References DBGC, DBGC_HDA, EINVAL, len, net_device::name, NDP_OPTION_BLKSZ, ndp_rx_option(), netdev, offset, and rc.

Referenced by ndp_rx_neighbour(), and ndp_rx_router_advertisement().

ndp_rx_neighbour()

static int ndp_rx_neighbour ( struct io_buffer *  iobuf, struct net_device *  netdev, struct sockaddr_in6 *  sin6_src, struct sockaddr_in6 *sin6_dest  __unused  )

static

Process received NDP neighbour solicitation or advertisement.

Parameters

iobuf	I/O buffer
netdev	Network device
sin6_src	Source socket address
sin6_dest	Destination socket address

Return values

rc	Return status code

Definition at line 516 of file ndp.c.

                                                                        {
        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;
}

References io_buffer::data, free_iob(), iob_len(), len, ndp_rx_options(), ndp_header::neigh, netdev, offsetof, rc, and typeof().

ndp_rx_router_advertisement()

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  )

static

Process received NDP router advertisement.

Parameters

iobuf	I/O buffer
netdev	Network device
sin6_src	Source socket address
sin6_dest	Destination socket address

Return values

rc	Return status code

Definition at line 546 of file ndp.c.

                                                                        {
        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;
}

References io_buffer::data, free_iob(), iob_len(), ipv6conf_rx_router_advertisement(), len, ndp_rx_options(), netdev, offsetof, ndp_header::radv, rc, sockaddr_in6::sin6_addr, and typeof().

ndp_applies()

static int ndp_applies ( struct settings *settings  __unused, const struct setting *  setting  )

static

Check applicability of NDP setting.

Parameters

settings	Settings block
setting	Setting to fetch

Return values

applies

Setting applies within this settings block

Definition at line 674 of file ndp.c.

                                                         {

        return ( setting->scope == &ndp_settings_scope );
}

References ndp_settings_scope, and setting::scope.

ndp_fetch()

static int ndp_fetch ( struct settings *  settings, struct setting *  setting, void *  data, size_t  len  )

static

Fetch value of NDP setting.

Parameters

settings	Settings block
setting	Setting to fetch
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 689 of file ndp.c.

                                                {
        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;
}

References container_of, data, DBGC, EINVAL, ENOENT, len, ndp_settings::len, memcpy(), net_device::name, NDP_OPTION_BLKSZ, NDP_TAG_INSTANCE, NDP_TAG_LEN, NDP_TAG_OFFSET, NDP_TAG_TYPE, netdev, offset, ndp_settings::options, settings::parent, setting::tag, and setting::type.

ndp_prefix_applies()

static int ndp_prefix_applies ( struct settings *settings  __unused, const struct setting *  setting  )

static

Check applicability of NDP per-prefix setting.

Parameters

settings	Settings block
setting	Setting to fetch

Return values

applies

Setting applies within this settings block

Definition at line 768 of file ndp.c.

                                                                {

        return ( setting->scope == &ipv6_settings_scope );
}

References ipv6_settings_scope, and setting::scope.

ndp_prefix_fetch_ip6()

static int ndp_prefix_fetch_ip6 ( struct settings *  settings, void *  data, size_t  len  )

static

Fetch value of NDP IPv6 address setting.

Parameters

settings	Settings block
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 782 of file ndp.c.

                                               {
        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 );
}

References container_of, data, DBGC, ENOENT, inet6_ntoa(), ipv6_eui64(), len, memcpy(), net_device::name, NDP_PREFIX_AUTONOMOUS, netdev, settings::parent, prefix, ndp_prefix_settings::prefix, rc, ndp_settings::settings, and strerror().

ndp_prefix_fetch_len6()

static int ndp_prefix_fetch_len6 ( struct settings *  settings, void *  data, size_t  len  )

static

Fetch value of NDP prefix length setting.

Parameters

settings	Settings block
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 839 of file ndp.c.

                                                {
        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 );
}

References container_of, data, len, NDP_PREFIX_ON_LINK, prefix, and ndp_prefix_settings::prefix.

ndp_prefix_fetch_gateway6()

static int ndp_prefix_fetch_gateway6 ( struct settings *  settings, void *  data, size_t  len  )

static

Fetch value of NDP router address setting.

Parameters

settings	Settings block
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 867 of file ndp.c.

                                                                {
        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 );
}

References container_of, data, ENOENT, len, ndp_settings::lifetime, memcpy(), settings::parent, and ndp_settings::router.

ndp_prefix_fetch()

static int ndp_prefix_fetch ( struct settings *  settings, struct setting *  setting, void *  data, size_t  len  )

static

Fetch value of NDP pre-prefix setting.

Parameters

settings	Settings block
setting	Setting to fetch
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 915 of file ndp.c.

                                                       {
        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;
}

References data, ENOENT, len, ndp_prefix_operations, op, and setting_cmp().

ndp_register_settings()

static int ndp_register_settings ( struct net_device *  netdev, struct in6_addr *  router, unsigned int  lifetime, union ndp_option *  options, size_t  len  )

static

Register NDP settings.

Parameters

netdev	Network device
router	Router address
lifetime	Router lifetime
options	NDP options
len	Length of options

Return values

rc	Return status code

Definition at line 948 of file ndp.c.

                                                                           {
        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;
}

References assert(), ENOMEM, IPV6_ORDER_PREFIX_ONLY, IPV6_ORDER_SLAAC, len, ndp_settings::len, lifetime, ndp_settings::lifetime, memcpy(), ndp_prefix_settings::name, NDP_OPT_PREFIX, NDP_OPTION_BLKSZ, NDP_PREFIX_AUTONOMOUS, ndp_prefix_settings_operations, NDP_SETTINGS_NAME, ndp_settings_operations, ndp_settings_scope, netdev, netdev_settings(), NULL, offset, options, ndp_settings::options, settings::order, settings::parent, ndp_prefix_settings::prefix, rc, ref_init, ref_put, ndp_settings::refcnt, register_settings(), ndp_settings::router, ndp_prefix_settings::settings, ndp_settings::settings, settings_init(), snprintf(), unregister_settings(), and zalloc().

Referenced by ipv6conf_rx_router_advertisement().

__setting() [1/2]

const struct setting ndp_dns6_setting __setting	(	SETTING_IP6_EXTRA	,
		dns6
	)

DNS server setting.

__setting() [2/2]

const struct setting ndp_dnssl_setting __setting	(	SETTING_IP_EXTRA	,
		dnssl
	)

DNS search list setting.

LIST_HEAD()

static LIST_HEAD ( ipv6confs  )

static

List of IPv6 configurators.

ipv6conf_free()

static void ipv6conf_free ( struct refcnt *  refcnt )

static

Free IPv6 configurator.

Parameters

refcnt

Reference count

Definition at line 1104 of file ndp.c.

                                                    {
        struct ipv6conf *ipv6conf =
                container_of ( refcnt, struct ipv6conf, refcnt );

        netdev_put ( ipv6conf->netdev );
        free ( ipv6conf );
}

References container_of, free, ipv6conf::netdev, and netdev_put().

Referenced by start_ipv6conf().

ipv6conf_done()

static void ipv6conf_done ( struct ipv6conf *  ipv6conf, int  rc  )

static

Finish IPv6 autoconfiguration.

Parameters

ipv6	IPv6 configurator
rc	Reason for finishing

Definition at line 1134 of file ndp.c.

                                                                {

        /* 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 );
}

References ipv6conf::dhcp, intf_shutdown(), ipv6conf::job, ipv6conf::list, list_del, rc, ref_put, ipv6conf::refcnt, stop_timer(), and ipv6conf::timer.

Referenced by ipv6conf_expired(), and ipv6conf_rx_router_advertisement().

ipv6conf_expired()

static void ipv6conf_expired ( struct retry_timer *  timer, int  fail  )

static

Handle IPv6 configurator timer expiry.

Parameters

timer	Retry timer
fail	Failure indicator

Definition at line 1154 of file ndp.c.

                                                                     {
        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 );
        }
}

References container_of, DBGC, ipv6conf::deferred, ETIMEDOUT, IPV6CONF_BLOCK_TIMEOUT, ipv6conf_done(), IPV6CONF_MAX_DEFERRALS, net_device::name, ndp_tx_router_solicitation(), netdev, ipv6conf::netdev, netdev_link_blocked(), start_timer(), start_timer_fixed(), and ipv6conf::timer.

Referenced by start_ipv6conf().

start_ipv6conf()

int start_ipv6conf	(	struct interface *	job,
		struct net_device *	netdev
	)

Start IPv6 autoconfiguration.

Parameters

job	Job control interface
netdev	Network device

Return values

rc	Return status code

Definition at line 1266 of file ndp.c.

                                                                        {
        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;
}

References ipv6conf::dhcp, ENOMEM, intf_init(), intf_plug_plug(), ipv6conf_dhcp_desc, ipv6conf_expired(), ipv6conf_free(), ipv6conf_job_desc, IPV6CONF_MAX_TIMEOUT, IPV6CONF_MIN_TIMEOUT, ipv6conf::job, ipv6conf::list, list_add, netdev, ipv6conf::netdev, netdev_get(), ref_init, ipv6conf::refcnt, start_timer_nodelay(), ipv6conf::timer, and zalloc().

Variable Documentation

ndp_discovery

struct neighbour_discovery ndp_discovery

Initial value:

= {
        .name = "NDP",
        .tx_request = ndp_tx_request,
}

NDP neighbour discovery protocol.

Definition at line 161 of file ndp.c.

Referenced by ndp_tx().

ndp_option_handlers

struct ndp_option_handler ndp_option_handlers[]

static

Initial value:

= {
        {
                .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,
        },
}

NDP option handlers.

Definition at line 398 of file ndp.c.

Referenced by ndp_rx_option().

__icmpv6_handler

struct icmpv6_handler ndp_handlers [] __icmpv6_handler

Initial value:

= {
        {
                .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 ICMPv6 handlers.

Definition at line 574 of file ndp.c.

ndp_settings_scope

const struct settings_scope ndp_settings_scope

static

NDP settings scope.

Definition at line 622 of file ndp.c.

Referenced by ndp_applies(), and ndp_register_settings().

ndp_settings_operations

struct settings_operations ndp_settings_operations

static

Initial value:

= {
        .applies = ndp_applies,
        .fetch = ndp_fetch,
}

NDP settings operations.

Definition at line 756 of file ndp.c.

Referenced by ndp_register_settings().

ndp_prefix_operations

struct ndp_prefix_operation ndp_prefix_operations[]

static

Initial value:

= {
        { &ip6_setting, ndp_prefix_fetch_ip6 },
        { &len6_setting, ndp_prefix_fetch_len6 },
        { &gateway6_setting, ndp_prefix_fetch_gateway6 },
}

NDP per-prefix settings operations.

Definition at line 900 of file ndp.c.

Referenced by ndp_prefix_fetch().

ndp_prefix_settings_operations

struct settings_operations ndp_prefix_settings_operations

static

Initial value:

= {
        .applies = ndp_prefix_applies,
        .fetch = ndp_prefix_fetch,
}

NDP per-prefix settings operations.

Definition at line 933 of file ndp.c.

Referenced by ndp_register_settings().

ipv6conf_job_op

struct interface_operation ipv6conf_job_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct ipv6conf *, ipv6conf_done ),
}

IPv6 configurator job interface operations.

Definition at line 1242 of file ndp.c.

ipv6conf_job_desc

struct interface_descriptor ipv6conf_job_desc

static

Initial value:

=
        INTF_DESC ( struct ipv6conf, job, ipv6conf_job_op )

IPv6 configurator job interface descriptor.

Definition at line 1247 of file ndp.c.

Referenced by start_ipv6conf().

ipv6conf_dhcp_op

struct interface_operation ipv6conf_dhcp_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct ipv6conf *, ipv6conf_done ),
}

IPv6 configurator DHCPv6 interface operations.

Definition at line 1251 of file ndp.c.

ipv6conf_dhcp_desc

struct interface_descriptor ipv6conf_dhcp_desc

static

Initial value:

=
        INTF_DESC ( struct ipv6conf, dhcp, ipv6conf_dhcp_op )

IPv6 configurator DHCPv6 interface descriptor.

Definition at line 1256 of file ndp.c.

Referenced by start_ipv6conf().

__net_device_configurator

struct net_device_configurator ipv6_configurator __net_device_configurator

Initial value:

= {
        .name = "ipv6",
        .start = start_ipv6conf,
}

IPv6 network device configurator.

Definition at line 1291 of file ndp.c.