/
githubmirror
/
ipxe
Обзор
Документация
Войти
/
githubmirror
/
ipxe
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
src/net/ndp.c
1 305 строк
36 KB
Christian I. Nilsson
[ipv6] Obtain MTU setting from NDP
24 фев 2026, 02:38
24 фев 2026, 02:38
1b6d88d
Код
Авторство
О чём код?
/* * 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 ); FILE_SECBOOT ( PERMITTED ); #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; } /** MTU setting */ const struct setting ndp_mtu_setting __setting ( SETTING_NETDEV, mtu ) = { .name = "mtu", .description = "MTU", .tag = NDP_TAG ( NDP_OPT_MTU, offsetof ( struct ndp_mtu_option, mtu ), sizeof ( uint32_t ) ), .type = &setting_type_int16, .scope = &ndp_settings_scope, }; /** 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, 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; } /** 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, };