ipv6.c File Reference

IPv6 protocol. More...

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <assert.h>
#include <byteswap.h>
#include <ipxe/iobuf.h>
#include <ipxe/tcpip.h>
#include <ipxe/if_ether.h>
#include <ipxe/crc32.h>
#include <ipxe/fragment.h>
#include <ipxe/ipstat.h>
#include <ipxe/ndp.h>
#include <ipxe/ipv6.h>

Go to the source code of this file.

Macros
#define	EINVAL_LEN   __einfo_error ( EINFO_EINVAL_LEN )
#define	EINFO_EINVAL_LEN    __einfo_uniqify ( EINFO_EINVAL, 0x01, "Invalid length" )
#define	ENOTSUP_VER   __einfo_error ( EINFO_ENOTSUP_VER )
#define	EINFO_ENOTSUP_VER    __einfo_uniqify ( EINFO_ENOTSUP, 0x01, "Unsupported version" )
#define	ENOTSUP_HDR   __einfo_error ( EINFO_ENOTSUP_HDR )
#define	EINFO_ENOTSUP_HDR    __einfo_uniqify ( EINFO_ENOTSUP, 0x02, "Unsupported header type" )
#define	ENOTSUP_OPT   __einfo_error ( EINFO_ENOTSUP_OPT )
#define	EINFO_ENOTSUP_OPT    __einfo_uniqify ( EINFO_ENOTSUP, 0x03, "Unsupported option" )

Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FILE_SECBOOT (PERMITTED)
struct ip_statistics_family ipv6_statistics_family	__ip_statistics_family (IP_STATISTICS_IPV6)
	IPv6 statistics family.
static uint32_t	ipv6col (struct in6_addr *in)
	Determine debugging colour for IPv6 debug messages.
static unsigned int	ipv6_scope (const struct in6_addr *addr)
	Determine IPv6 address scope.
static void	ipv6_dump_miniroute (struct ipv6_miniroute *miniroute)
	Dump IPv6 routing table entry.
int	ipv6_has_addr (struct net_device *netdev, struct in6_addr *addr)
	Check if network device has a specific IPv6 address.
static unsigned int	ipv6_match_len (struct ipv6_miniroute *miniroute, struct in6_addr *address)
	Count matching bits of an IPv6 routing table entry prefix.
static struct ipv6_miniroute *	ipv6_miniroute (struct net_device *netdev, struct in6_addr *address)
	Find IPv6 routing table entry for a given address.
int	ipv6_add_miniroute (struct net_device *netdev, struct in6_addr *address, unsigned int prefix_len, struct in6_addr *router)
	Add IPv6 routing table entry.
void	ipv6_del_miniroute (struct ipv6_miniroute *miniroute)
	Delete IPv6 minirouting table entry.
struct ipv6_miniroute *	ipv6_route (unsigned int scope_id, struct in6_addr **dest)
	Perform IPv6 routing.
static struct net_device *	ipv6_netdev (struct sockaddr_tcpip *st_dest)
	Determine transmitting network device.
static int	ipv6_check_options (struct ipv6_header *iphdr, struct ipv6_options_header *options, size_t len)
	Check that received options can be safely ignored.
static int	ipv6_is_fragment (struct fragment *fragment, struct io_buffer *iobuf, size_t hdrlen)
	Check if fragment matches fragment reassembly buffer.
static size_t	ipv6_fragment_offset (struct io_buffer *iobuf, size_t hdrlen)
	Get fragment offset.
static int	ipv6_more_fragments (struct io_buffer *iobuf, size_t hdrlen)
	Check if more fragments exist.
static uint16_t	ipv6_pshdr_chksum (struct ipv6_header *iphdr, size_t len, int next_header, uint16_t csum)
	Calculate IPv6 pseudo-header checksum.
static int	ipv6_tx (struct io_buffer *iobuf, struct tcpip_protocol *tcpip_protocol, struct sockaddr_tcpip *st_src, struct sockaddr_tcpip *st_dest, struct net_device *netdev, uint16_t *trans_csum)
	Transmit IPv6 packet.
static int	ipv6_rx (struct io_buffer *iobuf, struct net_device *netdev, const void *ll_dest __unused, const void *ll_source __unused, unsigned int flags __unused)
	Process incoming IPv6 packets.
int	inet6_aton (const char *string, struct in6_addr *in)
	Parse IPv6 address.
char *	inet6_ntoa (const struct in6_addr *in)
	Convert IPv6 address to standard notation.
static const char *	ipv6_ntoa (const void *net_addr)
	Transcribe IPv6 address.
static const char *	ipv6_sock_ntoa (struct sockaddr *sa)
	Transcribe IPv6 socket address.
static int	ipv6_sock_aton (const char *string, struct sockaddr *sa)
	Parse IPv6 socket address.
int	parse_ipv6_setting (const struct setting_type *type __unused, const char *value, void *buf, size_t len)
	Parse IPv6 address setting value.
int	format_ipv6_setting (const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
	Format IPv6 address setting value.
const struct setting ip6_setting	__setting (SETTING_IP6, ip6)
	IPv6 address setting.
const struct setting len6_setting	__setting (SETTING_IP6, len6)
	IPv6 prefix length setting.
const struct setting gateway6_setting	__setting (SETTING_IP6, gateway6)
	Default gateway setting.
static int	ipv6_applies (struct settings *settings __unused, const struct setting *setting)
	Check applicability of IPv6 link-local address setting.
static int	ipv6_fetch (struct settings *settings, struct setting *setting, void *data, size_t len)
	Fetch IPv6 link-local address setting.
static int	ipv6_register_settings (struct net_device *netdev, void *priv)
	Register IPv6 link-local address settings.
static int	ipv6_create_routes (struct net_device *netdev, struct settings *settings)
	Create IPv6 routing table based on configured settings.
static int	ipv6_create_all_routes (void)
	Create IPv6 routing table based on configured settings.
	REQUIRING_SYMBOL (ipv6_protocol)
	REQUIRE_OBJECT (icmpv6)
	REQUIRE_OBJECT (ndp)

Variables
struct list_head	ipv6_miniroutes = LIST_HEAD_INIT ( ipv6_miniroutes )
	List of IPv6 miniroutes.
static struct ip_statistics	ipv6_stats
	IPv6 statistics.
static struct fragment_reassembler	ipv6_reassembler
	Fragment reassembler.
struct net_protocol ipv6_protocol	__net_protocol
	IPv6 protocol.
struct tcpip_net_protocol ipv6_tcpip_protocol	__tcpip_net_protocol
	IPv6 TCPIP net protocol.
struct sockaddr_converter ipv6_sockaddr_converter	__sockaddr_converter
	IPv6 socket address converter.
const struct settings_scope	ipv6_settings_scope
	IPv6 settings scope.
static struct settings_operations	ipv6_settings_operations
	IPv6 link-local address settings operations.
struct net_driver ipv6_driver	__net_driver
	IPv6 network device driver.
struct settings_applicator ipv6_settings_applicator	__settings_applicator
	IPv6 settings applicator.

Detailed Description

IPv6 protocol.

Definition in file ipv6.c.

Macro Definition Documentation

EINVAL_LEN

#define EINVAL_LEN   __einfo_error ( EINFO_EINVAL_LEN )

Definition at line 47 of file ipv6.c.

Referenced by ipv6_rx().

EINFO_EINVAL_LEN

#define EINFO_EINVAL_LEN    __einfo_uniqify ( EINFO_EINVAL, 0x01, "Invalid length" )

Definition at line 48 of file ipv6.c.

#define EINFO_EINVAL_LEN \
        __einfo_uniqify ( EINFO_EINVAL, 0x01, "Invalid length" )

ENOTSUP_VER

#define ENOTSUP_VER   __einfo_error ( EINFO_ENOTSUP_VER )

Definition at line 50 of file ipv6.c.

Referenced by ipv6_rx().

EINFO_ENOTSUP_VER

#define EINFO_ENOTSUP_VER    __einfo_uniqify ( EINFO_ENOTSUP, 0x01, "Unsupported version" )

Definition at line 51 of file ipv6.c.

#define EINFO_ENOTSUP_VER \
        __einfo_uniqify ( EINFO_ENOTSUP, 0x01, "Unsupported version" )

ENOTSUP_HDR

#define ENOTSUP_HDR   __einfo_error ( EINFO_ENOTSUP_HDR )

Definition at line 53 of file ipv6.c.

EINFO_ENOTSUP_HDR

#define EINFO_ENOTSUP_HDR    __einfo_uniqify ( EINFO_ENOTSUP, 0x02, "Unsupported header type" )

Definition at line 54 of file ipv6.c.

#define EINFO_ENOTSUP_HDR \
        __einfo_uniqify ( EINFO_ENOTSUP, 0x02, "Unsupported header type" )

ENOTSUP_OPT

#define ENOTSUP_OPT   __einfo_error ( EINFO_ENOTSUP_OPT )

Definition at line 56 of file ipv6.c.

Referenced by ipv6_check_options().

EINFO_ENOTSUP_OPT

#define EINFO_ENOTSUP_OPT    __einfo_uniqify ( EINFO_ENOTSUP, 0x03, "Unsupported option" )

Definition at line 57 of file ipv6.c.

#define EINFO_ENOTSUP_OPT \
        __einfo_uniqify ( EINFO_ENOTSUP, 0x03, "Unsupported option" )

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

__ip_statistics_family()

struct ip_statistics_family ipv6_statistics_family __ip_statistics_family

(

IP_STATISTICS_IPV6

)

IPv6 statistics family.

References __ip_statistics_family, IP_STATISTICS_IPV6, and ipv6_stats.

ipv6col()

uint32_t ipv6col ( struct in6_addr * in )

static

Determine debugging colour for IPv6 debug messages.

Parameters

in	IPv6 address

Return values

col	Debugging colour (for DBGC())

Definition at line 79 of file ipv6.c.

                                                {
        return crc32_le ( 0, in, sizeof ( *in ) );
}

References crc32_le(), and in.

Referenced by ipv6_check_options(), ipv6_rx(), and ipv6_tx().

ipv6_scope()

unsigned int ipv6_scope ( const struct in6_addr * addr )

static

Determine IPv6 address scope.

Parameters

addr	IPv6 address

Return values

scope

Address scope

Definition at line 89 of file ipv6.c.

                                                               {
 
        /* Multicast addresses directly include a scope field */
        if ( IN6_IS_ADDR_MULTICAST ( addr ) )
                return ipv6_multicast_scope ( addr );
 
        /* Link-local addresses have link-local scope */
        if ( IN6_IS_ADDR_LINKLOCAL ( addr ) )
                return IPV6_SCOPE_LINK_LOCAL;
 
        /* Site-local addresses have site-local scope */
        if ( IN6_IS_ADDR_SITELOCAL ( addr ) )
                return IPV6_SCOPE_SITE_LOCAL;
 
        /* Unique local addresses do not directly map to a defined
         * scope.  They effectively have a scope which is wider than
         * link-local but narrower than global.  Since the only
         * multicast packets that we transmit are link-local, we can
         * simply choose an arbitrary scope between link-local and
         * global.
         */
        if ( IN6_IS_ADDR_ULA ( addr ) )
                return IPV6_SCOPE_ORGANISATION_LOCAL;
 
        /* All other addresses are assumed to be global */
        return IPV6_SCOPE_GLOBAL;
}

References addr, IN6_IS_ADDR_LINKLOCAL, IN6_IS_ADDR_MULTICAST, IN6_IS_ADDR_SITELOCAL, IN6_IS_ADDR_ULA, ipv6_multicast_scope(), IPV6_SCOPE_GLOBAL, IPV6_SCOPE_LINK_LOCAL, IPV6_SCOPE_ORGANISATION_LOCAL, and IPV6_SCOPE_SITE_LOCAL.

Referenced by ipv6_add_miniroute(), and ipv6_route().

ipv6_dump_miniroute()

void ipv6_dump_miniroute ( struct ipv6_miniroute * miniroute )

inlinestatic

Dump IPv6 routing table entry.

Parameters

miniroute

Routing table entry

Definition at line 123 of file ipv6.c.

                                                         {
        struct net_device *netdev = miniroute->netdev;
 
        DBGC ( netdev, "IPv6 %s has %s %s/%d", netdev->name,
               ( ( miniroute->flags & IPV6_HAS_ADDRESS ) ?
                 "address" : "prefix" ),
               inet6_ntoa ( &miniroute->address ), miniroute->prefix_len );
        if ( miniroute->flags & IPV6_HAS_ROUTER )
                DBGC ( netdev, " router %s", inet6_ntoa ( &miniroute->router ));
        DBGC ( netdev, "\n" );
}

References ipv6_miniroute::address, DBGC, ipv6_miniroute::flags, inet6_ntoa(), IPV6_HAS_ADDRESS, IPV6_HAS_ROUTER, ipv6_miniroute::netdev, netdev, ipv6_miniroute::prefix_len, and ipv6_miniroute::router.

Referenced by ipv6_add_miniroute().

ipv6_has_addr()

int ipv6_has_addr	(	struct net_device *	netdev,
		struct in6_addr *	addr )

Check if network device has a specific IPv6 address.

Parameters

netdev	Network device
addr	IPv6 address

Return values

has_addr

Network device has this IPv6 address

Definition at line 142 of file ipv6.c.

                                                                       {
        struct ipv6_miniroute *miniroute;
 
        list_for_each_entry ( miniroute, &ipv6_miniroutes, list ) {
                if ( ( miniroute->netdev == netdev ) &&
                     ( miniroute->flags & IPV6_HAS_ADDRESS ) &&
                     ( memcmp ( &miniroute->address, addr,
                                sizeof ( miniroute->address ) ) == 0 ) ) {
                        /* Found matching address */
                        return 1;
                }
        }
        return 0;
}

References addr, ipv6_miniroute::address, ipv6_miniroute::flags, IPV6_HAS_ADDRESS, ipv6_miniroutes, ipv6_miniroute::list, list_for_each_entry, memcmp(), ipv6_miniroute::netdev, and netdev.

Referenced by ipv6_rx(), and ndp_rx_neighbour_solicitation_ll_source().

ipv6_match_len()

unsigned int ipv6_match_len ( struct ipv6_miniroute * miniroute, struct in6_addr * address )

static

Count matching bits of an IPv6 routing table entry prefix.

Parameters

miniroute	Routing table entry
address	IPv6 address

Return values

match_len

Number of matching prefix bits

Definition at line 164 of file ipv6.c.

                                                                {
        unsigned int match_len = 0;
        unsigned int i;
        uint32_t diff;
 
        for ( i = 0 ; i < ( sizeof ( address->s6_addr32 ) /
                            sizeof ( address->s6_addr32[0] ) ) ; i++ ) {
 
                diff = ntohl ( ~( ( ~( address->s6_addr32[i] ^
                                       miniroute->address.s6_addr32[i] ) )
                                  & miniroute->prefix_mask.s6_addr32[i] ) );
                match_len += 32;
                if ( diff ) {
                        match_len -= flsl ( diff );
                        break;
                }
        }
 
        return match_len;
}

References address, ipv6_miniroute::address, flsl, ntohl, and ipv6_miniroute::prefix_mask.

Referenced by ipv6_miniroute(), and ipv6_route().

ipv6_miniroute()

struct ipv6_miniroute * ipv6_miniroute ( struct net_device * netdev, struct in6_addr * address )

static

Find IPv6 routing table entry for a given address.

Parameters

netdev	Network device
address	IPv6 address

Return values

miniroute

Routing table entry, or NULL if not found

Definition at line 193 of file ipv6.c.

                                                                           {
        struct ipv6_miniroute *miniroute;
        unsigned int match_len;
 
        list_for_each_entry ( miniroute, &ipv6_miniroutes, list ) {
                if ( miniroute->netdev != netdev )
                        continue;
                match_len = ipv6_match_len ( miniroute, address );
                if ( match_len < miniroute->prefix_len )
                        continue;
                return miniroute;
        }
        return NULL;
}

References address, ipv6_match_len(), ipv6_miniroutes, ipv6_miniroute::list, list_for_each_entry, ipv6_miniroute::netdev, netdev, NULL, and ipv6_miniroute::prefix_len.

Referenced by ipv6_add_miniroute().

ipv6_add_miniroute()

int ipv6_add_miniroute	(	struct net_device *	netdev,
		struct in6_addr *	address,
		unsigned int	prefix_len,
		struct in6_addr *	router )

Add IPv6 routing table entry.

Parameters

netdev	Network device
address	IPv6 address (or prefix)
prefix_len	Prefix length
router	Router address (if any)

Return values

rc	Return status code

Definition at line 218 of file ipv6.c.

                                                                            {
        struct ipv6_miniroute *miniroute;
        uint8_t *prefix_mask;
        unsigned int remaining;
        unsigned int i;
 
        /* Find or create routing table entry */
        miniroute = ipv6_miniroute ( netdev, address );
        if ( miniroute ) {
 
                /* Remove from existing position in routing table */
                list_del ( &miniroute->list );
 
        } else {
 
                /* Create new routing table entry */
                miniroute = zalloc ( sizeof ( *miniroute ) );
                if ( ! miniroute )
                        return -ENOMEM;
                miniroute->netdev = netdev_get ( netdev );
                memcpy ( &miniroute->address, address,
                         sizeof ( miniroute->address ) );
 
                /* Default to prefix length of 64 if none specified */
                if ( ! prefix_len )
                        prefix_len = IPV6_DEFAULT_PREFIX_LEN;
                miniroute->prefix_len = prefix_len;
                assert ( prefix_len <= IPV6_MAX_PREFIX_LEN );
 
                /* Construct prefix mask */
                remaining = prefix_len;
                for ( prefix_mask = miniroute->prefix_mask.s6_addr ;
                      remaining >= 8 ; prefix_mask++, remaining -= 8 ) {
                        *prefix_mask = 0xff;
                }
                if ( remaining )
                        *prefix_mask = ( 0xff << ( 8 - remaining ) );
        }
 
        /* Add to start of routing table */
        list_add ( &miniroute->list, &ipv6_miniroutes );
 
        /* Set or update address, if applicable */
        for ( i = 0 ; i < ( sizeof ( address->s6_addr32 ) /
                            sizeof ( address->s6_addr32[0] ) ) ; i++ ) {
                if ( ( address->s6_addr32[i] &
                       ~miniroute->prefix_mask.s6_addr32[i] ) != 0 ) {
                        memcpy ( &miniroute->address, address,
                                 sizeof ( miniroute->address ) );
                        miniroute->flags |= IPV6_HAS_ADDRESS;
                }
        }
        if ( miniroute->prefix_len == IPV6_MAX_PREFIX_LEN )
                miniroute->flags |= IPV6_HAS_ADDRESS;
 
        /* Update scope */
        miniroute->scope = ipv6_scope ( &miniroute->address );
 
        /* Set or update router, if applicable */
        if ( router ) {
                memcpy ( &miniroute->router, router,
                         sizeof ( miniroute->router ) );
                miniroute->flags |= IPV6_HAS_ROUTER;
        }
 
        ipv6_dump_miniroute ( miniroute );
        return 0;
}

References address, ipv6_miniroute::address, assert, ENOMEM, ipv6_miniroute::flags, IPV6_DEFAULT_PREFIX_LEN, ipv6_dump_miniroute(), IPV6_HAS_ADDRESS, IPV6_HAS_ROUTER, IPV6_MAX_PREFIX_LEN, ipv6_miniroute(), ipv6_miniroutes, ipv6_scope(), ipv6_miniroute::list, list_add, list_del, memcpy(), ipv6_miniroute::netdev, netdev, netdev_get(), ipv6_miniroute::prefix_len, ipv6_miniroute::prefix_mask, ipv6_miniroute::router, ipv6_miniroute::scope, and zalloc().

Referenced by ipv6_create_routes(), and ipv6_table_okx().

ipv6_del_miniroute()

void ipv6_del_miniroute

(

struct ipv6_miniroute *

miniroute

)

Delete IPv6 minirouting table entry.

Parameters

miniroute

Routing table entry

Definition at line 293 of file ipv6.c.

                                                             {
 
        netdev_put ( miniroute->netdev );
        list_del ( &miniroute->list );
        free ( miniroute );
}

References free, ipv6_miniroute::list, list_del, ipv6_miniroute::netdev, and netdev_put().

Referenced by ipv6_create_all_routes(), and ipv6_table_del().

ipv6_route()

struct ipv6_miniroute * ipv6_route	(	unsigned int	scope_id,
		struct in6_addr **	dest )

Perform IPv6 routing.

Parameters

scope_id	Destination address scope ID (for link-local addresses)
dest	Final destination address

Return values

dest	Next hop destination address
miniroute	Routing table entry to use, or NULL if no route

Definition at line 308 of file ipv6.c.

                                                              {
        struct ipv6_miniroute *miniroute;
        struct ipv6_miniroute *chosen = NULL;
        unsigned int best = 0;
        unsigned int match_len;
        unsigned int score;
        unsigned int scope;
 
        /* Calculate destination address scope */
        scope = ipv6_scope ( *dest );
 
        /* Find first usable route in routing table */
        list_for_each_entry ( miniroute, &ipv6_miniroutes, list ) {
 
                /* Skip closed network devices */
                if ( ! netdev_is_open ( miniroute->netdev ) )
                        continue;
 
                /* Skip entries with no usable source address */
                if ( ! ( miniroute->flags & IPV6_HAS_ADDRESS ) )
                        continue;
 
                /* Skip entries with a non-matching scope ID, if
                 * destination specifies a scope ID.
                 */
                if ( scope_id && ( miniroute->netdev->scope_id != scope_id ) )
                        continue;
 
                /* Skip entries that are out of scope */
                if ( miniroute->scope < scope )
                        continue;
 
                /* Calculate match length */
                match_len = ipv6_match_len ( miniroute, *dest );
 
                /* If destination is on-link, then use this route */
                if ( match_len >= miniroute->prefix_len )
                        return miniroute;
 
                /* If destination is unicast, then skip off-link
                 * entries with no router.
                 */
                if ( ! ( IN6_IS_ADDR_MULTICAST ( *dest ) ||
                         ( miniroute->flags & IPV6_HAS_ROUTER ) ) )
                        continue;
 
                /* Choose best route, defined as being the route with
                 * the smallest viable scope.  If two routes both have
                 * the same scope, then prefer the route with the
                 * longest match length.
                 */
                score = ( ( ( IPV6_SCOPE_MAX + 1 - miniroute->scope ) << 8 )
                          + match_len );
                if ( score > best ) {
                        chosen = miniroute;
                        best = score;
                }
        }
 
        /* Return chosen route, if any */
        if ( chosen ) {
                if ( ! IN6_IS_ADDR_MULTICAST ( *dest ) )
                        *dest = &chosen->router;
                return chosen;
        }
 
        return NULL;
}

References dest, ipv6_miniroute::flags, IN6_IS_ADDR_MULTICAST, IPV6_HAS_ADDRESS, IPV6_HAS_ROUTER, ipv6_match_len(), ipv6_miniroutes, ipv6_scope(), IPV6_SCOPE_MAX, ipv6_miniroute::list, list_for_each_entry, ipv6_miniroute::netdev, netdev_is_open(), NULL, ipv6_miniroute::prefix_len, ipv6_miniroute::router, ipv6_miniroute::scope, scope, and net_device::scope_id.

Referenced by ipv6_netdev(), ipv6_route_okx(), and ipv6_tx().

ipv6_netdev()

struct net_device * ipv6_netdev ( struct sockaddr_tcpip * st_dest )

static

Determine transmitting network device.

Parameters

st_dest

Destination network-layer address

Return values

netdev

Transmitting network device, or NULL

Definition at line 384 of file ipv6.c.

                                                                          {
        struct sockaddr_in6 *sin6_dest = ( ( struct sockaddr_in6 * ) st_dest );
        struct in6_addr *dest = &sin6_dest->sin6_addr;
        struct ipv6_miniroute *miniroute;
 
        /* Find routing table entry */
        miniroute = ipv6_route ( sin6_dest->sin6_scope_id, &dest );
        if ( ! miniroute )
                return NULL;
 
        return miniroute->netdev;
}

References dest, ipv6_route(), ipv6_miniroute::netdev, NULL, sockaddr_in6::sin6_addr, and sockaddr_in6::sin6_scope_id.

ipv6_check_options()

int ipv6_check_options ( struct ipv6_header * iphdr, struct ipv6_options_header * options, size_t len )

static

Check that received options can be safely ignored.

Parameters

iphdr	IPv6 header
options	Options extension header
len	Maximum length of header

Return values

rc	Return status code

Definition at line 405 of file ipv6.c.

                                             {
        struct ipv6_option *option = options->options;
        struct ipv6_option *end = ( ( ( void * ) options ) + len );
 
        while ( option < end ) {
                if ( ! IPV6_CAN_IGNORE_OPT ( option->type ) ) {
                        DBGC ( ipv6col ( &iphdr->src ), "IPv6 unrecognised "
                               "option type %#02x:\n", option->type );
                        DBGC_HDA ( ipv6col ( &iphdr->src ), 0,
                                   options, len );
                        return -ENOTSUP_OPT;
                }
                if ( option->type == IPV6_OPT_PAD1 ) {
                        option = ( ( ( void * ) option ) + 1 );
                } else {
                        option = ( ( ( void * ) option->value ) + option->len );
                }
        }
        return 0;
}

References DBGC, DBGC_HDA, end, ENOTSUP_OPT, IPV6_CAN_IGNORE_OPT, IPV6_OPT_PAD1, ipv6col(), len, options, and iphdr::src.

Referenced by ipv6_rx().

ipv6_is_fragment()

int ipv6_is_fragment ( struct fragment * fragment, struct io_buffer * iobuf, size_t hdrlen )

static

Check if fragment matches fragment reassembly buffer.

Parameters

fragment	Fragment reassembly buffer
iobuf	I/O buffer
hdrlen	Length of non-fragmentable potion of I/O buffer

Return values

is_fragment

Fragment matches this reassembly buffer

Definition at line 436 of file ipv6.c.

                                                                       {
        struct ipv6_header *frag_iphdr = fragment->iobuf->data;
        struct ipv6_fragment_header *frag_fhdr =
                ( fragment->iobuf->data + fragment->hdrlen -
                  sizeof ( *frag_fhdr ) );
        struct ipv6_header *iphdr = iobuf->data;
        struct ipv6_fragment_header *fhdr =
                ( iobuf->data + hdrlen - sizeof ( *fhdr ) );
 
        return ( ( memcmp ( &iphdr->src, &frag_iphdr->src,
                            sizeof ( iphdr->src ) ) == 0 ) &&
                 ( fhdr->ident == frag_fhdr->ident ) );
}

References io_buffer::data, fragment::hdrlen, ipv6_fragment_header::ident, fragment::iobuf, memcmp(), iphdr::src, and ipv6_header::src.

ipv6_fragment_offset()

size_t ipv6_fragment_offset ( struct io_buffer * iobuf, size_t hdrlen )

static

Get fragment offset.

Parameters

iobuf	I/O buffer
hdrlen	Length of non-fragmentable potion of I/O buffer

Return values

offset

Offset

Definition at line 458 of file ipv6.c.

                                                                              {
        struct ipv6_fragment_header *fhdr =
                ( iobuf->data + hdrlen - sizeof ( *fhdr ) );
 
        return ( ntohs ( fhdr->offset_more ) & IPV6_MASK_OFFSET );
}

References io_buffer::data, IPV6_MASK_OFFSET, ntohs, and ipv6_fragment_header::offset_more.

ipv6_more_fragments()

int ipv6_more_fragments ( struct io_buffer * iobuf, size_t hdrlen )

static

Check if more fragments exist.

Parameters

iobuf	I/O buffer
hdrlen	Length of non-fragmentable potion of I/O buffer

Return values

more_frags

More fragments exist

Definition at line 472 of file ipv6.c.

                                                                          {
        struct ipv6_fragment_header *fhdr =
                ( iobuf->data + hdrlen - sizeof ( *fhdr ) );
 
        return ( fhdr->offset_more & htons ( IPV6_MASK_MOREFRAGS ) );
}

References io_buffer::data, htons, IPV6_MASK_MOREFRAGS, and ipv6_fragment_header::offset_more.

ipv6_pshdr_chksum()

uint16_t ipv6_pshdr_chksum ( struct ipv6_header * iphdr, size_t len, int next_header, uint16_t csum )

static

Calculate IPv6 pseudo-header checksum.

Parameters

iphdr	IPv6 header
len	Payload length
next_header	Next header type
csum	Existing checksum

Return values

csum	Updated checksum

Definition at line 497 of file ipv6.c.

                                                                     {
        struct ipv6_pseudo_header pshdr;
 
        /* Build pseudo-header */
        memcpy ( &pshdr.src, &iphdr->src, sizeof ( pshdr.src ) );
        memcpy ( &pshdr.dest, &iphdr->dest, sizeof ( pshdr.dest ) );
        pshdr.len = htonl ( len );
        memset ( pshdr.zero, 0, sizeof ( pshdr.zero ) );
        pshdr.next_header = next_header;
 
        /* Update the checksum value */
        return tcpip_continue_chksum ( csum, &pshdr, sizeof ( pshdr ) );
}

References iphdr::dest, ipv6_pseudo_header::dest, htonl, ipv6_pseudo_header::len, len, memcpy(), memset(), ipv6_pseudo_header::next_header, iphdr::src, ipv6_pseudo_header::src, tcpip_continue_chksum(), and ipv6_pseudo_header::zero.

Referenced by ipv6_rx(), and ipv6_tx().

ipv6_tx()

int ipv6_tx ( struct io_buffer * iobuf, struct tcpip_protocol * tcpip_protocol, struct sockaddr_tcpip * st_src, struct sockaddr_tcpip * st_dest, struct net_device * netdev, uint16_t * trans_csum )

static

Transmit IPv6 packet.

Parameters

iobuf	I/O buffer
tcpip	Transport-layer protocol
st_src	Source network-layer address
st_dest	Destination network-layer address
netdev	Network device to use if no route found, or NULL
trans_csum	Transport-layer checksum to complete, or NULL

Return values

rc

Status

This function expects a transport-layer segment and prepends the IPv6 header

Definition at line 526 of file ipv6.c.

                                            {
        struct sockaddr_in6 *sin6_src = ( ( struct sockaddr_in6 * ) st_src );
        struct sockaddr_in6 *sin6_dest = ( ( struct sockaddr_in6 * ) st_dest );
        struct ipv6_miniroute *miniroute;
        struct ipv6_header *iphdr;
        struct in6_addr *src = NULL;
        struct in6_addr *next_hop;
        uint8_t ll_dest_buf[MAX_LL_ADDR_LEN];
        const void *ll_dest;
        size_t len;
        int rc;
 
        /* Update statistics */
        ipv6_stats.out_requests++;
 
        /* Fill up the IPv6 header, except source address */
        len = iob_len ( iobuf );
        iphdr = iob_push ( iobuf, sizeof ( *iphdr ) );
        memset ( iphdr, 0, sizeof ( *iphdr ) );
        iphdr->ver_tc_label = htonl ( IPV6_VER );
        iphdr->len = htons ( len );
        iphdr->next_header = tcpip_protocol->tcpip_proto;
        iphdr->hop_limit = IPV6_HOP_LIMIT;
        memcpy ( &iphdr->dest, &sin6_dest->sin6_addr, sizeof ( iphdr->dest ) );
 
        /* Use routing table to identify next hop and transmitting netdev */
        next_hop = &iphdr->dest;
        if ( ( miniroute = ipv6_route ( sin6_dest->sin6_scope_id,
                                        &next_hop ) ) != NULL ) {
                src = &miniroute->address;
                netdev = miniroute->netdev;
        }
        if ( ! netdev ) {
                DBGC ( ipv6col ( &iphdr->dest ), "IPv6 has no route to %s\n",
                       inet6_ntoa ( &iphdr->dest ) );
                ipv6_stats.out_no_routes++;
                rc = -ENETUNREACH;
                goto err;
        }
        if ( sin6_src && ! IN6_IS_ADDR_UNSPECIFIED ( &sin6_src->sin6_addr ) )
                src = &sin6_src->sin6_addr;
        if ( src )
                memcpy ( &iphdr->src, src, sizeof ( iphdr->src ) );
 
        /* Fix up checksums */
        if ( trans_csum ) {
                *trans_csum = ipv6_pshdr_chksum ( iphdr, len,
                                                  tcpip_protocol->tcpip_proto,
                                                  *trans_csum );
                if ( ! *trans_csum )
                        *trans_csum = tcpip_protocol->zero_csum;
        }
 
        /* Print IPv6 header for debugging */
        DBGC2 ( ipv6col ( &iphdr->dest ), "IPv6 TX %s->",
                inet6_ntoa ( &iphdr->src ) );
        DBGC2 ( ipv6col ( &iphdr->dest ), "%s len %zd next %d\n",
                inet6_ntoa ( &iphdr->dest ), len, iphdr->next_header );
 
        /* Calculate link-layer destination address, if possible */
        if ( IN6_IS_ADDR_MULTICAST ( next_hop ) ) {
                /* Multicast address */
                ipv6_stats.out_mcast_pkts++;
                if ( ( rc = netdev->ll_protocol->mc_hash ( AF_INET6, next_hop,
                                                           ll_dest_buf ) ) !=0){
                        DBGC ( ipv6col ( &iphdr->dest ), "IPv6 could not hash "
                               "multicast %s: %s\n", inet6_ntoa ( next_hop ),
                               strerror ( rc ) );
                        goto err;
                }
                ll_dest = ll_dest_buf;
        } else {
                /* Unicast address */
                ll_dest = NULL;
        }
 
        /* Update statistics */
        ipv6_stats.out_transmits++;
        ipv6_stats.out_octets += iob_len ( iobuf );
 
        /* Hand off to link layer (via NDP if applicable) */
        if ( ll_dest ) {
                if ( ( rc = net_tx ( iobuf, netdev, &ipv6_protocol, ll_dest,
                                     netdev->ll_addr ) ) != 0 ) {
                        DBGC ( ipv6col ( &iphdr->dest ), "IPv6 could not "
                               "transmit packet via %s: %s\n",
                               netdev->name, strerror ( rc ) );
                        return rc;
                }
        } else {
                if ( ( rc = ndp_tx ( iobuf, netdev, next_hop,
                                     &iphdr->src ) ) != 0 ) {
                        DBGC ( ipv6col ( &iphdr->dest ), "IPv6 could not "
                               "transmit packet via %s: %s\n",
                               netdev->name, strerror ( rc ) );
                        return rc;
                }
        }
 
        return 0;
 
 err:
        free_iob ( iobuf );
        return rc;
}

References ipv6_miniroute::address, AF_INET6, DBGC, DBGC2, iphdr::dest, ENETUNREACH, free_iob(), htonl, htons, IN6_IS_ADDR_MULTICAST, IN6_IS_ADDR_UNSPECIFIED, inet6_ntoa(), iob_len(), iob_push, IPV6_HOP_LIMIT, ipv6_pshdr_chksum(), ipv6_route(), ipv6_stats, IPV6_VER, ipv6col(), iphdr::len, len, MAX_LL_ADDR_LEN, memcpy(), memset(), ndp_tx(), net_tx(), ipv6_miniroute::netdev, netdev, NULL, rc, sockaddr_in6::sin6_addr, sockaddr_in6::sin6_scope_id, iphdr::src, src, strerror(), tcpip_protocol::tcpip_proto, and tcpip_protocol::zero_csum.

ipv6_rx()

int ipv6_rx ( struct io_buffer * iobuf, struct net_device * netdev, const void *ll_dest __unused, const void *ll_source __unused, unsigned int flags __unused )

static

Process incoming IPv6 packets.

Parameters

iobuf	I/O buffer
netdev	Network device
ll_dest	Link-layer destination address
ll_source	Link-layer destination source
flags	Packet flags

Return values

rc	Return status code

This function expects an IPv6 network datagram. It processes the headers and sends it to the transport layer.

Definition at line 650 of file ipv6.c.

                                                   {
        struct ipv6_header *iphdr = iobuf->data;
        union ipv6_extension_header *ext;
        union {
                struct sockaddr_in6 sin6;
                struct sockaddr_tcpip st;
        } src, dest;
        uint16_t pshdr_csum;
        size_t len;
        size_t hdrlen;
        size_t extlen;
        int this_header;
        int next_header;
        int rc;
 
        /* Update statistics */
        ipv6_stats.in_receives++;
        ipv6_stats.in_octets += iob_len ( iobuf );
        if ( flags & LL_BROADCAST ) {
                ipv6_stats.in_bcast_pkts++;
        } else if ( flags & LL_MULTICAST ) {
                ipv6_stats.in_mcast_pkts++;
        }
 
        /* Sanity check the IPv6 header */
        if ( iob_len ( iobuf ) < sizeof ( *iphdr ) ) {
                DBGC ( ipv6col ( &iphdr->src ), "IPv6 packet too short at %zd "
                       "bytes (min %zd bytes)\n", iob_len ( iobuf ),
                       sizeof ( *iphdr ) );
                rc = -EINVAL_LEN;
                goto err_header;
        }
        if ( ( iphdr->ver_tc_label & htonl ( IPV6_MASK_VER ) ) !=
             htonl ( IPV6_VER ) ) {
                DBGC ( ipv6col ( &iphdr->src ), "IPv6 version %#08x not "
                       "supported\n", ntohl ( iphdr->ver_tc_label ) );
                rc = -ENOTSUP_VER;
                goto err_header;
        }
 
        /* Truncate packet to specified length */
        len = ntohs ( iphdr->len );
        if ( len > iob_len ( iobuf ) ) {
                DBGC ( ipv6col ( &iphdr->src ), "IPv6 length too long at %zd "
                       "bytes (packet is %zd bytes)\n", len, iob_len ( iobuf ));
                ipv6_stats.in_truncated_pkts++;
                rc = -EINVAL_LEN;
                goto err_other;
        }
        iob_unput ( iobuf, ( iob_len ( iobuf ) - len - sizeof ( *iphdr ) ) );
        hdrlen = sizeof ( *iphdr );
 
        /* Print IPv6 header for debugging */
        DBGC2 ( ipv6col ( &iphdr->src ), "IPv6 RX %s<-",
                inet6_ntoa ( &iphdr->dest ) );
        DBGC2 ( ipv6col ( &iphdr->src ), "%s len %zd next %d\n",
                inet6_ntoa ( &iphdr->src ), len, iphdr->next_header );
 
        /* Discard unicast packets not destined for us */
        if ( ( ! ( flags & LL_MULTICAST ) ) &&
             ( ! ipv6_has_addr ( netdev, &iphdr->dest ) ) ) {
                DBGC ( ipv6col ( &iphdr->src ), "IPv6 discarding non-local "
                       "unicast packet for %s\n", inet6_ntoa ( &iphdr->dest ) );
                ipv6_stats.in_addr_errors++;
                rc = -EPIPE;
                goto err_other;
        }
 
        /* Process any extension headers */
        next_header = iphdr->next_header;
        while ( 1 ) {
 
                /* Extract extension header */
                this_header = next_header;
                ext = ( iobuf->data + hdrlen );
                extlen = sizeof ( ext->pad );
                if ( iob_len ( iobuf ) < ( hdrlen + extlen ) ) {
                        DBGC ( ipv6col ( &iphdr->src ), "IPv6 too short for "
                               "extension header type %d at %zd bytes (min "
                               "%zd bytes)\n", this_header,
                               ( iob_len ( iobuf ) - hdrlen ), extlen );
                        rc = -EINVAL_LEN;
                        goto err_header;
                }
 
                /* Determine size of extension header (if applicable) */
                if ( ( this_header == IPV6_HOPBYHOP ) ||
                     ( this_header == IPV6_DESTINATION ) ||
                     ( this_header == IPV6_ROUTING ) ) {
                        /* Length field is present */
                        extlen += ext->common.len;
                } else if ( this_header == IPV6_FRAGMENT ) {
                        /* Length field is reserved and ignored (RFC2460) */
                } else {
                        /* Not an extension header; assume rest is payload */
                        break;
                }
                if ( iob_len ( iobuf ) < ( hdrlen + extlen ) ) {
                        DBGC ( ipv6col ( &iphdr->src ), "IPv6 too short for "
                               "extension header type %d at %zd bytes (min "
                               "%zd bytes)\n", this_header,
                               ( iob_len ( iobuf ) - hdrlen ), extlen );
                        rc = -EINVAL_LEN;
                        goto err_header;
                }
                hdrlen += extlen;
                next_header = ext->common.next_header;
                DBGC2 ( ipv6col ( &iphdr->src ), "IPv6 RX %s<-",
                        inet6_ntoa ( &iphdr->dest ) );
                DBGC2 ( ipv6col ( &iphdr->src ), "%s ext type %d len %zd next "
                        "%d\n", inet6_ntoa ( &iphdr->src ), this_header,
                        extlen, next_header );
 
                /* Process this extension header */
                if ( ( this_header == IPV6_HOPBYHOP ) ||
                     ( this_header == IPV6_DESTINATION ) ) {
 
                        /* Check that all options can be ignored */
                        if ( ( rc = ipv6_check_options ( iphdr, &ext->options,
                                                         extlen ) ) != 0 )
                                goto err_header;
 
                } else if ( this_header == IPV6_FRAGMENT ) {
 
                        /* Reassemble fragments */
                        iobuf = fragment_reassemble ( &ipv6_reassembler, iobuf,
                                                      &hdrlen );
                        if ( ! iobuf )
                                return 0;
                        iphdr = iobuf->data;
                }
        }
 
        /* Construct socket address, calculate pseudo-header checksum,
         * and hand off to transport layer
         */
        memset ( &src, 0, sizeof ( src ) );
        src.sin6.sin6_family = AF_INET6;
        memcpy ( &src.sin6.sin6_addr, &iphdr->src,
                 sizeof ( src.sin6.sin6_addr ) );
        src.sin6.sin6_scope_id = netdev->scope_id;
        memset ( &dest, 0, sizeof ( dest ) );
        dest.sin6.sin6_family = AF_INET6;
        memcpy ( &dest.sin6.sin6_addr, &iphdr->dest,
                 sizeof ( dest.sin6.sin6_addr ) );
        dest.sin6.sin6_scope_id = netdev->scope_id;
        iob_pull ( iobuf, hdrlen );
        pshdr_csum = ipv6_pshdr_chksum ( iphdr, iob_len ( iobuf ),
                                         next_header, TCPIP_EMPTY_CSUM );
        if ( ( rc = tcpip_rx ( iobuf, netdev, next_header, &src.st, &dest.st,
                               pshdr_csum, &ipv6_stats ) ) != 0 ) {
                DBGC ( ipv6col ( &src.sin6.sin6_addr ), "IPv6 received packet "
                                "rejected by stack: %s\n", strerror ( rc ) );
                return rc;
        }
 
        return 0;
 
 err_header:
        ipv6_stats.in_hdr_errors++;
 err_other:
        free_iob ( iobuf );
        return rc;
}

References __unused, AF_INET6, io_buffer::data, DBGC, DBGC2, dest, iphdr::dest, EINVAL_LEN, ENOTSUP_VER, EPIPE, ext, flags, fragment_reassemble(), free_iob(), htonl, inet6_ntoa(), iob_len(), iob_pull, iob_unput, ipv6_check_options(), IPV6_DESTINATION, IPV6_FRAGMENT, ipv6_has_addr(), IPV6_HOPBYHOP, IPV6_MASK_VER, ipv6_pshdr_chksum(), ipv6_reassembler, IPV6_ROUTING, ipv6_stats, IPV6_VER, ipv6col(), iphdr::len, len, LL_BROADCAST, LL_MULTICAST, memcpy(), memset(), netdev, ntohl, ntohs, rc, sin6, iphdr::src, src, st, strerror(), TCPIP_EMPTY_CSUM, and tcpip_rx().

inet6_aton()

int inet6_aton	(	const char *	string,
		struct in6_addr *	in )

Parse IPv6 address.

Parameters

string

IPv6 address string

Return values

in	IPv6 address to fill in
rc	Return status code

Definition at line 825 of file ipv6.c.

                                                           {
        uint16_t *word = in->s6_addr16;
        uint16_t *end = ( word + ( sizeof ( in->s6_addr16 ) /
                                   sizeof ( in->s6_addr16[0] ) ) );
        uint16_t *pad = NULL;
        const char *nptr = string;
        char *endptr;
        unsigned long value;
        size_t pad_len;
        size_t move_len;
 
        /* Parse string */
        while ( 1 ) {
 
                /* Parse current word */
                value = strtoul ( nptr, &endptr, 16 );
                if ( value > 0xffff ) {
                        DBG ( "IPv6 invalid word value %#lx in \"%s\"\n",
                              value, string );
                        return -EINVAL;
                }
                *(word++) = htons ( value );
 
                /* Parse separator */
                if ( ! *endptr )
                        break;
                if ( *endptr != ':' ) {
                        DBG ( "IPv6 invalid separator '%c' in \"%s\"\n",
                              *endptr, string );
                        return -EINVAL;
                }
                if ( ( endptr == nptr ) && ( nptr != string ) ) {
                        if ( pad ) {
                                DBG ( "IPv6 invalid multiple \"::\" in "
                                      "\"%s\"\n", string );
                                return -EINVAL;
                        }
                        pad = word;
                }
                nptr = ( endptr + 1 );
 
                /* Check for overrun */
                if ( word == end ) {
                        DBG ( "IPv6 too many words in \"%s\"\n", string );
                        return -EINVAL;
                }
        }
 
        /* Insert padding if specified */
        if ( pad ) {
                move_len = ( ( ( void * ) word ) - ( ( void * ) pad ) );
                pad_len = ( ( ( void * ) end ) - ( ( void * ) word ) );
                memmove ( ( ( ( void * ) pad ) + pad_len ), pad, move_len );
                memset ( pad, 0, pad_len );
        } else if ( word != end ) {
                DBG ( "IPv6 underlength address \"%s\"\n", string );
                return -EINVAL;
        }
 
        return 0;
}

References DBG, EINVAL, end, htons, in, memmove(), memset(), NULL, pad, pad_len, string, strtoul(), and value.

Referenced by inet6_aton_fail_okx(), inet6_aton_okx(), ipv6_route_okx(), ipv6_sock_aton(), ipv6_table_okx(), and parse_ipv6_setting().

inet6_ntoa()

char * inet6_ntoa

(

const struct in6_addr *

in

)

Convert IPv6 address to standard notation.

Parameters

in	IPv6 address

Return values

string

IPv6 address string in canonical format

RFC5952 defines the canonical format for IPv6 textual representation.

Definition at line 895 of file ipv6.c.

                                                {
        static char buf[41]; /* ":xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx" */
        char *out = buf;
        char *longest_start = NULL;
        char *start = NULL;
        int longest_len = 1;
        int len = 0;
        char *dest;
        unsigned int i;
        uint16_t value;
 
        /* Format address, keeping track of longest run of zeros */
        for ( i = 0 ; i < ( sizeof ( in->s6_addr16 ) /
                            sizeof ( in->s6_addr16[0] ) ) ; i++ ) {
                value = ntohs ( in->s6_addr16[i] );
                if ( value == 0 ) {
                        if ( len++ == 0 )
                                start = out;
                        if ( len > longest_len ) {
                                longest_start = start;
                                longest_len = len;
                        }
                } else {
                        len = 0;
                }
                out += sprintf ( out, ":%x", value );
        }
 
        /* Abbreviate longest run of zeros, if applicable */
        if ( longest_start ) {
                dest = strcpy ( ( longest_start + 1 ),
                                ( longest_start + ( 2 * longest_len ) ) );
                if ( dest[0] == '\0' )
                        dest[1] = '\0';
                dest[0] = ':';
        }
        return ( ( longest_start == buf ) ? buf : ( buf + 1 ) );
}

References dest, in, len, ntohs, NULL, out, sprintf, start, strcpy(), and value.

Referenced by dhcpv6_rx(), format_ipv6_setting(), inet6_aton_okx(), inet6_ntoa_okx(), ipv6_dump_miniroute(), ipv6_ntoa(), ipv6_route_okx(), ipv6_rx(), ipv6_sock_ntoa(), ipv6_tx(), ndp_prefix_fetch_ip6(), ndp_rx_neighbour_advertisement_ll_target(), ndp_rx_neighbour_solicitation_ll_source(), ndp_rx_router_advertisement_ll_source(), ndp_rx_router_advertisement_prefix(), and route_ipv6_print().

ipv6_ntoa()

const char * ipv6_ntoa ( const void * net_addr )

static

Transcribe IPv6 address.

Parameters

net_addr

IPv6 address

Return values

string

IPv6 address in standard notation

Definition at line 941 of file ipv6.c.

                                                       {
        return inet6_ntoa ( net_addr );
}

References inet6_ntoa().

ipv6_sock_ntoa()

const char * ipv6_sock_ntoa ( struct sockaddr * sa )

static

Transcribe IPv6 socket address.

Parameters

sa	Socket address

Return values

string

Socket address in standard notation

Definition at line 951 of file ipv6.c.

                                                           {
        static char buf[ 39 /* "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx" */ +
                         1 /* "%" */ + NETDEV_NAME_LEN + 1 /* NUL */ ];
        struct sockaddr_in6 *sin6 = ( ( struct sockaddr_in6 * ) sa );
        struct in6_addr *in = &sin6->sin6_addr;
        struct net_device *netdev;
        const char *netdev_name;
 
        /* Identify network device, if applicable */
        if ( IN6_IS_ADDR_LINKLOCAL ( in ) || IN6_IS_ADDR_MULTICAST ( in ) ) {
                netdev = find_netdev_by_scope_id ( sin6->sin6_scope_id );
                netdev_name = ( netdev ? netdev->name : "UNKNOWN" );
        } else {
                netdev_name = NULL;
        }
 
        /* Format socket address */
        snprintf ( buf, sizeof ( buf ), "%s%s%s", inet6_ntoa ( in ),
                   ( netdev_name ? "%" : "" ),
                   ( netdev_name ? netdev_name : "" ) );
        return buf;
}

References find_netdev_by_scope_id(), in, IN6_IS_ADDR_LINKLOCAL, IN6_IS_ADDR_MULTICAST, inet6_ntoa(), netdev, NETDEV_NAME_LEN, NULL, sa, sin6, and snprintf().

ipv6_sock_aton()

int ipv6_sock_aton ( const char * string, struct sockaddr * sa )

static

Parse IPv6 socket address.

Parameters

string	Socket address string
sa	Socket address to fill in

Return values

rc	Return status code

Definition at line 981 of file ipv6.c.

                                                                      {
        struct sockaddr_in6 *sin6 = ( ( struct sockaddr_in6 * ) sa );
        struct in6_addr in;
        struct net_device *netdev;
        size_t len;
        char *tmp;
        char *in_string;
        char *netdev_string;
        int rc;
 
        /* Create modifiable copy of string */
        tmp = strdup ( string );
        if ( ! tmp ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        in_string = tmp;
 
        /* Strip surrounding "[...]", if present */
        len = strlen ( in_string );
        if ( ( in_string[0] == '[' ) && ( in_string[ len - 1 ] == ']' ) ) {
                in_string[ len - 1 ] = '\0';
                in_string++;
        }
 
        /* Split at network device name, if present */
        netdev_string = strchr ( in_string, '%' );
        if ( netdev_string )
                *(netdev_string++) = '\0';
 
        /* Parse IPv6 address portion */
        if ( ( rc = inet6_aton ( in_string, &in ) ) != 0 )
                goto err_inet6_aton;
 
        /* Parse scope ID, if applicable */
        if ( netdev_string ) {
 
                /* Parse explicit network device name, if present */
                netdev = find_netdev ( netdev_string );
                if ( ! netdev ) {
                        rc = -ENODEV;
                        goto err_find_netdev;
                }
                sin6->sin6_scope_id = netdev->scope_id;
 
        } else if ( IN6_IS_ADDR_LINKLOCAL ( &in ) ||
                    IN6_IS_ADDR_MULTICAST ( &in ) ) {
 
                /* If no network device is explicitly specified for a
                 * link-local or multicast address, default to using
                 * "netX" (if existent).
                 */
                netdev = last_opened_netdev();
                if ( netdev )
                        sin6->sin6_scope_id = netdev->scope_id;
        }
 
        /* Copy IPv6 address portion to socket address */
        memcpy ( &sin6->sin6_addr, &in, sizeof ( sin6->sin6_addr ) );
 
 err_find_netdev:
 err_inet6_aton:
        free ( tmp );
 err_alloc:
        return rc;
}

References ENODEV, ENOMEM, find_netdev(), free, in, IN6_IS_ADDR_LINKLOCAL, IN6_IS_ADDR_MULTICAST, inet6_aton(), last_opened_netdev(), len, memcpy(), netdev, rc, sa, sin6, strchr(), strdup(), strlen(), and tmp.

parse_ipv6_setting()

int parse_ipv6_setting	(	const struct setting_type *type	__unused,
		const char *	value,
		void *	buf,
		size_t	len )

Parse IPv6 address setting value.

Parameters

type	Setting type
value	Formatted setting value
buf	Buffer to contain raw value
len	Length of buffer

Return values

len	Length of raw value, or negative error

Definition at line 1083 of file ipv6.c.

                                                                    {
        struct in6_addr ipv6;
        int rc;
 
        /* Parse IPv6 address */
        if ( ( rc = inet6_aton ( value, &ipv6 ) ) != 0 )
                return rc;
 
        /* Copy to buffer */
        if ( len > sizeof ( ipv6 ) )
                len = sizeof ( ipv6 );
        memcpy ( buf, &ipv6, len );
 
        return ( sizeof ( ipv6 ) );
}

References __unused, inet6_aton(), len, memcpy(), rc, type, and value.

format_ipv6_setting()

int format_ipv6_setting	(	const struct setting_type *type	__unused,
		const void *	raw,
		size_t	raw_len,
		char *	buf,
		size_t	len )

Format IPv6 address setting value.

Parameters

type	Setting type
raw	Raw setting value
raw_len	Length of raw setting value
buf	Buffer to contain formatted value
len	Length of buffer

Return values

len	Length of formatted value, or negative error

Definition at line 1110 of file ipv6.c.

                                       {
        const struct in6_addr *ipv6 = raw;
 
        if ( raw_len < sizeof ( *ipv6 ) )
                return -EINVAL;
        return snprintf ( buf, len, "%s", inet6_ntoa ( ipv6 ) );
}

References __unused, EINVAL, inet6_ntoa(), len, raw, raw_len, snprintf(), and type.

__setting() [1/3]

const struct setting ip6_setting __setting	(	SETTING_IP6	,
		ip6	)

IPv6 address setting.

References __setting, ip6_setting, ipv6_settings_scope, and SETTING_IP6.

__setting() [2/3]

const struct setting len6_setting __setting	(	SETTING_IP6	,
		len6	)

IPv6 prefix length setting.

References __setting, ipv6_settings_scope, len6_setting, and SETTING_IP6.

__setting() [3/3]

const struct setting gateway6_setting __setting	(	SETTING_IP6	,
		gateway6	)

Default gateway setting.

References __setting, gateway6_setting, ipv6_settings_scope, and SETTING_IP6.

ipv6_applies()

int ipv6_applies ( struct settings *settings __unused, const struct setting * setting )

static

Check applicability of IPv6 link-local address setting.

Parameters

settings	Settings block
setting	Setting to fetch

Return values

applies

Setting applies within this settings block

Definition at line 1154 of file ipv6.c.

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

References __unused, ipv6_settings_scope, and setting::scope.

ipv6_fetch()

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

static

Fetch IPv6 link-local address 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 1169 of file ipv6.c.

                                                 {
        struct net_device *netdev =
                container_of ( settings->parent, struct net_device,
                               settings.settings );
        struct in6_addr ip6;
        uint8_t *len6;
        int prefix_len;
        int rc;
 
        /* Construct link-local address from EUI-64 as per RFC 2464 */
        memset ( &ip6, 0, sizeof ( ip6 ) );
        prefix_len = ipv6_link_local ( &ip6, netdev );
        if ( prefix_len < 0 ) {
                rc = prefix_len;
                return rc;
        }
 
        /* Handle setting */
        if ( setting_cmp ( setting, &ip6_setting ) == 0 ) {
 
                /* Return link-local ip6 */
                if ( len > sizeof ( ip6 ) )
                        len = sizeof ( ip6 );
                memcpy ( data, &ip6, len );
                return sizeof ( ip6 );
 
        } else if ( setting_cmp ( setting, &len6_setting ) == 0 ) {
 
                /* Return prefix length */
                if ( len ) {
                        len6 = data;
                        *len6 = prefix_len;
                }
                return sizeof ( *len6 );
 
        }
 
        return -ENOENT;
}

References container_of, data, ENOENT, ip6_setting, ipv6_link_local(), len, len6_setting, memcpy(), memset(), netdev, settings::parent, rc, and setting_cmp().

ipv6_register_settings()

int ipv6_register_settings ( struct net_device * netdev, void * priv )

static

Register IPv6 link-local address settings.

Parameters

netdev	Network device
priv	Private data

Return values

rc	Return status code

Definition at line 1223 of file ipv6.c.

                                                                            {
        struct settings *parent = netdev_settings ( netdev );
        struct settings *settings = priv;
        int rc;
 
        /* Initialise and register settings */
        settings_init ( settings, &ipv6_settings_operations,
                        &netdev->refcnt, &ipv6_settings_scope );
        settings->order = IPV6_ORDER_LINK_LOCAL;
        if ( ( rc = register_settings ( settings, parent,
                                        IPV6_SETTINGS_NAME ) ) != 0 )
                return rc;
 
        return 0;
}

References IPV6_ORDER_LINK_LOCAL, IPV6_SETTINGS_NAME, ipv6_settings_operations, ipv6_settings_scope, netdev, netdev_settings(), settings::order, settings::parent, priv, rc, register_settings(), and settings_init().

ipv6_create_routes()

int ipv6_create_routes ( struct net_device * netdev, struct settings * settings )

static

Create IPv6 routing table based on configured settings.

Parameters

netdev	Network device
settings	Settings block

Return values

rc	Return status code

Definition at line 1253 of file ipv6.c.

                                                            {
        struct settings *child;
        struct settings *origin;
        struct in6_addr ip6_buf;
        struct in6_addr gateway6_buf;
        struct in6_addr *ip6 = &ip6_buf;
        struct in6_addr *gateway6 = &gateway6_buf;
        uint8_t len6;
        size_t len;
        int rc;
 
        /* First, create routing table for any child settings.  We do
         * this depth-first and in reverse order so that the end
         * result reflects the relative priorities of the settings
         * blocks.
         */
        list_for_each_entry_reverse ( child, &settings->children, siblings )
                ipv6_create_routes ( netdev, child );
 
        /* Fetch IPv6 address, if any */
        len = fetch_setting ( settings, &ip6_setting, &origin, NULL,
                              ip6, sizeof ( *ip6 ) );
        if ( ( len != sizeof ( *ip6 ) ) || ( origin != settings ) )
                return 0;
 
        /* Fetch prefix length, if defined */
        len = fetch_setting ( settings, &len6_setting, &origin, NULL,
                              &len6, sizeof ( len6 ) );
        if ( ( len != sizeof ( len6 ) ) || ( origin != settings ) )
                len6 = 0;
        if ( len6 > IPV6_MAX_PREFIX_LEN )
                len6 = IPV6_MAX_PREFIX_LEN;
 
        /* Fetch gateway, if defined */
        len = fetch_setting ( settings, &gateway6_setting, &origin, NULL,
                              gateway6, sizeof ( *gateway6 ) );
        if ( ( len != sizeof ( *gateway6 ) ) || ( origin != settings ) )
                gateway6 = NULL;
 
        /* Create or update route */
        if ( ( rc = ipv6_add_miniroute ( netdev, ip6, len6, gateway6 ) ) != 0){
                DBGC ( netdev, "IPv6 %s could not add route: %s\n",
                       netdev->name, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References settings::children, DBGC, fetch_setting(), gateway6_setting, ip6_setting, ipv6_add_miniroute(), ipv6_create_routes(), IPV6_MAX_PREFIX_LEN, len, len6_setting, list_for_each_entry_reverse, netdev, NULL, origin, rc, and strerror().

Referenced by ipv6_create_all_routes(), and ipv6_create_routes().

ipv6_create_all_routes()

int ipv6_create_all_routes ( void )

static

Create IPv6 routing table based on configured settings.

Return values

rc	Return status code

Definition at line 1308 of file ipv6.c.

                                           {
        struct ipv6_miniroute *miniroute;
        struct ipv6_miniroute *tmp;
        struct net_device *netdev;
        struct settings *settings;
        int rc;
 
        /* Delete all existing routes */
        list_for_each_entry_safe ( miniroute, tmp, &ipv6_miniroutes, list )
                ipv6_del_miniroute ( miniroute );
 
        /* Create routes for each configured network device */
        for_each_netdev ( netdev ) {
                settings = netdev_settings ( netdev );
                if ( ( rc = ipv6_create_routes ( netdev, settings ) ) != 0 )
                        return rc;
        }
 
        return 0;
}

References for_each_netdev, ipv6_create_routes(), ipv6_del_miniroute(), ipv6_miniroutes, list_for_each_entry_safe, netdev, netdev_settings(), rc, and tmp.

REQUIRING_SYMBOL()

REQUIRING_SYMBOL

(

ipv6_protocol

)

REQUIRE_OBJECT() [1/2]

REQUIRE_OBJECT

(

icmpv6

)

REQUIRE_OBJECT() [2/2]

REQUIRE_OBJECT

(

ndp

)

Variable Documentation

ipv6_miniroutes

struct list_head ipv6_miniroutes = LIST_HEAD_INIT ( ipv6_miniroutes )

List of IPv6 miniroutes.

Definition at line 61 of file ipv6.c.

Referenced by ipv6_add_miniroute(), ipv6_create_all_routes(), ipv6_has_addr(), ipv6_miniroute(), ipv6_route(), ipv6_route_okx(), ipv6_table_del(), ipv6_table_okx(), and route_ipv6_print().

ipv6_stats

struct ip_statistics ipv6_stats

static

IPv6 statistics.

Definition at line 64 of file ipv6.c.

Referenced by __ip_statistics_family(), ipv6_rx(), and ipv6_tx().

ipv6_reassembler

struct fragment_reassembler ipv6_reassembler

static

Initial value:

= {
        .list = LIST_HEAD_INIT ( ipv6_reassembler.list ),
        .is_fragment = ipv6_is_fragment,
        .fragment_offset = ipv6_fragment_offset,
        .more_fragments = ipv6_more_fragments,
        .stats = &ipv6_stats,
}

Fragment reassembler.

Definition at line 480 of file ipv6.c.

                                                      {
        .list = LIST_HEAD_INIT ( ipv6_reassembler.list ),
        .is_fragment = ipv6_is_fragment,
        .fragment_offset = ipv6_fragment_offset,
        .more_fragments = ipv6_more_fragments,
        .stats = &ipv6_stats,
};

Referenced by ipv6_rx().

__net_protocol

struct net_protocol ipv6_protocol __net_protocol

Initial value:

= {
        .name = "IPv6",
        .net_proto = htons ( ETH_P_IPV6 ),
        .net_addr_len = sizeof ( struct in6_addr ),
        .rx = ipv6_rx,
        .ntoa = ipv6_ntoa,
}

IPv6 protocol.

AoE protocol.

Definition at line 1049 of file ipv6.c.

                                                   {
        .name = "IPv6",
        .net_proto = htons ( ETH_P_IPV6 ),
        .net_addr_len = sizeof ( struct in6_addr ),
        .rx = ipv6_rx,
        .ntoa = ipv6_ntoa,
};

__tcpip_net_protocol

struct tcpip_net_protocol ipv6_tcpip_protocol __tcpip_net_protocol

Initial value:

= {
        .name = "IPv6",
        .sa_family = AF_INET6,
        .header_len = sizeof ( struct ipv6_header ),
        .net_protocol = &ipv6_protocol,
        .tx = ipv6_tx,
        .netdev = ipv6_netdev,
}

IPv6 TCPIP net protocol.

Definition at line 1058 of file ipv6.c.

                                                                     {
        .name = "IPv6",
        .sa_family = AF_INET6,
        .header_len = sizeof ( struct ipv6_header ),
        .net_protocol = &ipv6_protocol,
        .tx = ipv6_tx,
        .netdev = ipv6_netdev,
};

__sockaddr_converter

struct sockaddr_converter ipv6_sockaddr_converter __sockaddr_converter

Initial value:

= {
        .family = AF_INET6,
        .ntoa = ipv6_sock_ntoa,
        .aton = ipv6_sock_aton,
}

IPv6 socket address converter.

Definition at line 1068 of file ipv6.c.

                                                                         {
        .family = AF_INET6,
        .ntoa = ipv6_sock_ntoa,
        .aton = ipv6_sock_aton,
};

ipv6_settings_scope

const struct settings_scope ipv6_settings_scope

IPv6 settings scope.

IPv6 setting scope.

Definition at line 1121 of file ipv6.c.

Referenced by __setting(), __setting(), __setting(), dhcpv6_applies(), ipv6_applies(), ipv6_register_settings(), and ndp_prefix_applies().

ipv6_settings_operations

struct settings_operations ipv6_settings_operations

static

Initial value:

= {
        .applies = ipv6_applies,
        .fetch = ipv6_fetch,
}

IPv6 link-local address settings operations.

Definition at line 1211 of file ipv6.c.

                                                             {
        .applies = ipv6_applies,
        .fetch = ipv6_fetch,
};

Referenced by ipv6_register_settings().

__net_driver

struct net_driver ipv6_driver __net_driver

Initial value:

= {
        .name = "IPv6",
        .priv_len = sizeof ( struct settings ),
        .probe = ipv6_register_settings,
}

IPv6 network device driver.

Definition at line 1240 of file ipv6.c.

                                             {
        .name = "IPv6",
        .priv_len = sizeof ( struct settings ),
        .probe = ipv6_register_settings,
};

__settings_applicator

struct settings_applicator ipv6_settings_applicator __settings_applicator

Initial value:

= {
        .apply = ipv6_create_all_routes,
}

IPv6 settings applicator.

Definition at line 1330 of file ipv6.c.

                                                                            {
        .apply = ipv6_create_all_routes,
};