Request for Comments: 3542 M. Thomas
Obsoletes: 2292 Consultant
Category: Informational E. Nordmark
Sun
T. Jinmei
Toshiba
May 2003
Advanced Sockets Application Program Interface (API) for IPv6
Status of this Memo
This memo provides information for the Internet community. It does
not specify an Internet standard of any kind. Distribution of this
memo is unlimited.
Copyright Notice
Copyright (C) The Internet Society (2003). All Rights Reserved.
Abstract
This document provides sockets Application Program Interface (API) to
support "advanced" IPv6 applications, as a supplement to a separate
specification, RFC3493. The expected applications include Ping,
Traceroute, routing daemons and the like, which typically use raw
sockets to access IPv6 or ICMPv6 header fields. This document
proposes some portable interfaces for applications that use raw
sockets under IPv6. There are other features of IPv6 that some
applications will need to access: interface identification
(specifying the outgoing interface and determining the incoming
interface), IPv6 extension headers, and path Maximum Transmission
Unit (MTU) information. This document provides API access to these
features too. Additionally, some extended interfaces to libraries
for the "r" commands are defined. The extension will provide better
backward compatibility to existing implementations that are not
IPv6-capable.
Table of Contents
1. Introduction .............................................. 3
2. Common Structures and Definitions ......................... 5
2.1 The ip6_hdr Structure ................................ 6
2.1.1 IPv6 Next Header Values ....................... 6
2.1.2 IPv6 Extension Headers ........................ 7
2.1.3 IPv6 Options .................................. 8
2.2 The icmp6_hdr Structure .............................. 10
2.2.1 ICMPv6 Type and Code Values ................... 10
2.2.2 ICMPv6 Neighbor Discovery Definitions ......... 11
2.2.3 Multicast Listener Discovery Definitions ...... 14
2.2.4 ICMPv6 Router Renumbering Definitions ......... 14
2.3 Address Testing Macros ............................... 16
2.4 Protocols File ....................................... 16
3. IPv6 Raw Sockets .......................................... 17
3.1 Checksums ............................................ 18
3.2 ICMPv6 Type Filtering ................................ 19
3.3 ICMPv6 Verification of Received Packets .............. 22
4. Access to IPv6 and Extension Headers ...................... 22
4.1 TCP Implications ..................................... 24
4.2 UDP and Raw Socket Implications ...................... 25
5. Extensions to Socket Ancillary Data ....................... 26
5.1 CMSG_NXTHDR .......................................... 26
5.2 CMSG_SPACE ........................................... 26
5.3 CMSG_LEN ............................................. 27
6. Packet Information ........................................ 27
6.1 Specifying/Receiving the Interface ................... 28
6.2 Specifying/Receiving Source/Destination Address ...... 29
6.3 Specifying/Receiving the Hop Limit ................... 29
6.4 Specifying the Next Hop Address ...................... 30
6.5 Specifying/Receiving the Traffic Class value ......... 31
6.6 Additional Errors with sendmsg() and setsockopt() .... 32
6.7 Summary of Outgoing Interface Selection .............. 32
7. Routing Header Option ..................................... 33
7.1 inet6_rth_space ...................................... 35
7.2 inet6_rth_init ....................................... 35
7.3 inet6_rth_add ........................................ 36
7.4 inet6_rth_reverse .................................... 36
7.5 inet6_rth_segments ................................... 36
7.6 inet6_rth_getaddr .................................... 36
8. Hop-By-Hop Options ........................................ 37
8.1 Receiving Hop-by-Hop Options ......................... 38
8.2 Sending Hop-by-Hop Options ........................... 38
9. Destination Options ....................................... 39
9.1 Receiving Destination Options ........................ 39
9.2 Sending Destination Options .......................... 39
10. Hop-by-Hop and Destination Options Processing ............. 40
10.1 inet6_opt_init ...................................... 41
10.2 inet6_opt_append .................................... 41
10.3 inet6_opt_finish .................................... 42
10.4 inet6_opt_set_val ................................... 42
10.5 inet6_opt_next ...................................... 42
10.6 inet6_opt_find ...................................... 43
10.7 inet6_opt_get_val ................................... 43
11. Additional Advanced API Functions ......................... 44
11.1 Sending with the Minimum MTU ........................ 44
11.2 Sending without Fragmentation ....................... 45
11.3 Path MTU Discovery and UDP .......................... 46
11.4 Determining the Current Path MTU .................... 47
12. Ordering of Ancillary Data and IPv6 Extension Headers ..... 48
13. IPv6-Specific Options with IPv4-Mapped IPv6 Addresses ..... 50
14. Extended interfaces for rresvport, rcmd and rexec ......... 51
14.1 rresvport_af ........................................ 51
14.2 rcmd_af ............................................. 51
14.3 rexec_af ............................................ 52
15. Summary of New Definitions ................................ 52
16. Security Considerations ................................... 56
17. Changes from RFC2292 ..................................... 57
18. References ................................................ 59
19. Acknowledgments ........................................... 59
20. Appendix A: Ancillary Data Overview ....................... 60
20.1 The msghdr Structure ................................ 60
20.2 The cmsghdr Structure ............................... 61
20.3 Ancillary Data Object Macros ........................ 62
20.3.1 CMSG_FIRSTHDR ............................... 63
20.3.2 CMSG_NXTHDR ................................. 64
20.3.3 CMSG_DATA ................................... 65
20.3.4 CMSG_SPACE .................................. 65
20.3.5 CMSG_LEN .................................... 65
21. Appendix B: Examples Using the inet6_rth_XXX() Functions .. 65
21.1 Sending a Routing Header ............................ 65
21.2 Receiving Routing Headers ........................... 70
22. Appendix C: Examples Using the inet6_opt_XXX() Functions .. 72
22.1 Building Options .................................... 72
22.2 Parsing Received Options ............................ 74
23. Authors' Addresses ........................................ 76
24. Full Copyright Statement .................................. 77
1. Introduction
A separate specification [RFC-3493] contains changes to the sockets
API to support IP version 6. Those changes are for TCP and UDP-based
applications. This document defines some of the "advanced" features
of the sockets API that are required for applications to take
advantage of additional features of IPv6.
Today, the portability of applications using IPv4 raw sockets is
quite high, but this is mainly because most IPv4 implementations
started from a common base (the Berkeley source code) or at least
started with the Berkeley header files. This allows programs such as
Ping and Traceroute, for example, to compile with minimal effort on
many hosts that support the sockets API. With IPv6, however, there
is no common source code base that implementors are starting from,
and the possibility for divergence at this level between different
implementations is high. To avoid a complete lack of portability
amongst applications that use raw IPv6 sockets, some standardization
is necessary.
There are also features from the basic IPv6 specification that are
not addressed in [RFC-3493]: sending and receiving Routing headers,
Hop-by-Hop options, and Destination options, specifying the outgoing
interface, being told of the receiving interface, and control of path
MTU information.
This document updates and replaces RFC2292. This revision is based
on implementation experience of RFC2292, as well as some additional
extensions that have been found to be useful through the IPv6
deployment. Note, however, that further work on this document may
still be needed. Once the API specification becomes mature and is
deployed among implementations, it may be formally standardized by a
more appropriate body, such as has been done with the Basic API
[RFC-3493].
This document can be divided into the following main sections.
1. Definitions of the basic constants and structures required for
applications to use raw IPv6 sockets. This includes structure
definitions for the IPv6 and ICMPv6 headers and all associated
constants (e.g., values for the Next Header field).
2. Some basic semantic definitions for IPv6 raw sockets. For
example, a raw ICMPv4 socket requires the application to calculate
and store the ICMPv4 header checksum. But with IPv6 this would
require the application to choose the source IPv6 address because
the source address is part of the pseudo header that ICMPv6 now
uses for its checksum computation. It should be defined that with
a raw ICMPv6 socket the kernel always calculates and stores the
ICMPv6 header checksum.
3. Packet information: how applications can obtain the received
interface, destination address, and received hop limit, along with
specifying these values on a per-packet basis. There are a class
of applications that need this capability and the technique should
be portable.
4. Access to the optional Routing header, Hop-by-Hop options, and
Destination options extension headers.
5. Additional features required for improved IPv6 application
portability.
The packet information along with access to the extension headers
(Routing header, Hop-by-Hop options, and Destination options) are
specified using the "ancillary data" fields that were added to the
4.3BSD Reno sockets API in 1990. The reason is that these ancillary
data fields are part of the Posix standard [POSIX] and should
therefore be adopted by most vendors.
This document does not address application access to either the
authentication header or the encapsulating security payload header.
Many examples in this document omit error checking in favor of
brevity and clarity.
We note that some of the functions and socket options defined in this
document may have error returns that are not defined in this
document. Some of these possible error returns will be recognized
only as implementations proceed.
Datatypes in this document follow the Posix format: intN_t means a
signed integer of exactly N bits (e.g., int16_t) and uintN_t means an
unsigned integer of exactly N bits (e.g., uint32_t).
Note that we use the (unofficial) terminology ICMPv4, IGMPv4, and
ARPv4 to avoid any confusion with the newer ICMPv6 protocol.
2. Common Structures and Definitions
Many advanced applications examine fields in the IPv6 header and set
and examine fields in the various ICMPv6 headers. Common structure
definitions for these protocol headers are required, along with
common constant definitions for the structure members.
This API assumes that the fields in the protocol headers are left in
the network byte order, which is big-endian for the Internet
protocols. If not, then either these constants or the fields being
tested must be converted at run-time, using something like htons() or
htonl().
Two new header files are defined: <netinet/ip6.h> and
<netinet/icmp6.h>.
When an include file is specified, that include file is allowed to
include other files that do the actual declaration or definition.
2.1. The ip6_hdr Structure
The following structure is defined as a result of including
<netinet/ip6.h>. Note that this is a new header.
struct ip6_hdr {
union {
struct ip6_hdrctl {
uint32_t ip6_un1_flow; /* 4 bits version, 8 bits TC, 20 bits
flow-ID */
uint16_t ip6_un1_plen; /* payload length */
uint8_t ip6_un1_nxt; /* next header */
uint8_t ip6_un1_hlim; /* hop limit */
} ip6_un1;
uint8_t ip6_un2_vfc; /* 4 bits version, top 4 bits
tclass */
} ip6_ctlun;
struct in6_addr ip6_src; /* source address */
struct in6_addr ip6_dst; /* destination address */
};
#define ip6_vfc ip6_ctlun.ip6_un2_vfc
#define ip6_flow ip6_ctlun.ip6_un1.ip6_un1_flow
#define ip6_plen ip6_ctlun.ip6_un1.ip6_un1_plen
#define ip6_nxt ip6_ctlun.ip6_un1.ip6_un1_nxt
#define ip6_hlim ip6_ctlun.ip6_un1.ip6_un1_hlim
#define ip6_hops ip6_ctlun.ip6_un1.ip6_un1_hlim
2.1.1. IPv6 Next Header Values
IPv6 defines many new values for the Next Header field. The
following constants are defined as a result of including
<netinet/in.h>.
#define IPPROTO_HOPOPTS 0 /* IPv6 Hop-by-Hop options */
#define IPPROTO_IPV6 41 /* IPv6 header */
#define IPPROTO_ROUTING 43 /* IPv6 Routing header */
#define IPPROTO_FRAGMENT 44 /* IPv6 fragment header */
#define IPPROTO_ESP 50 /* encapsulating security payload */
#define IPPROTO_AH 51 /* authentication header */
#define IPPROTO_ICMPV6 58 /* ICMPv6 */
#define IPPROTO_NONE 59 /* IPv6 no next header */
#define IPPROTO_DSTOPTS 60 /* IPv6 Destination options */
Berkeley-derived IPv4 implementations also define IPPROTO_IP to be 0.
This should not be a problem since IPPROTO_IP is used only with IPv4
sockets and IPPROTO_HOPOPTS only with IPv6 sockets.
2.1.2. IPv6 Extension Headers
Six extension headers are defined for IPv6. We define structures for
all except the Authentication header and Encapsulating Security
Payload header, both of which are beyond the scope of this document.
The following structures are defined as a result of including
<netinet/ip6.h>.
/* Hop-by-Hop options header */
struct ip6_hbh {
uint8_t ip6h_nxt; /* next header */
uint8_t ip6h_len; /* length in units of 8 octets */
/* followed by options */
};
/* Destination options header */
struct ip6_dest {
uint8_t ip6d_nxt; /* next header */
uint8_t ip6d_len; /* length in units of 8 octets */
/* followed by options */
};
/* Routing header */
struct ip6_rthdr {
uint8_t ip6r_nxt; /* next header */
uint8_t ip6r_len; /* length in units of 8 octets */
uint8_t ip6r_type; /* routing type */
uint8_t ip6r_segleft; /* segments left */
/* followed by routing type specific data */
};
/* Type 0 Routing header */
struct ip6_rthdr0 {
uint8_t ip6r0_nxt; /* next header */
uint8_t ip6r0_len; /* length in units of 8 octets */
uint8_t ip6r0_type; /* always zero */
uint8_t ip6r0_segleft; /* segments left */
uint32_t ip6r0_reserved; /* reserved field */
/* followed by up to 127 struct in6_addr */
};
/* Fragment header */
struct ip6_frag {
uint8_t ip6f_nxt; /* next header */
uint8_t ip6f_reserved; /* reserved field */
uint16_t ip6f_offlg; /* offset, reserved, and flag */
uint32_t ip6f_ident; /* identification */
};
#if BYTE_ORDER == BIG_ENDIAN
#define IP6F_OFF_MASK 0xfff8 /* mask out offset from
ip6f_offlg */
#define IP6F_RESERVED_MASK 0x0006 /* reserved bits in
ip6f_offlg */
#define IP6F_MORE_FRAG 0x0001 /* more-fragments flag */
#else /* BYTE_ORDER == LITTLE_ENDIAN */
#define IP6F_OFF_MASK 0xf8ff /* mask out offset from
ip6f_offlg */
#define IP6F_RESERVED_MASK 0x0600 /* reserved bits in
ip6f_offlg */
#define IP6F_MORE_FRAG 0x0100 /* more-fragments flag */
#endif
2.1.3. IPv6 Options
Several options are defined for IPv6, and we define structures and
macro definitions for some of them below. The following structures
are defined as a result of including <netinet/ip6.h>.
/* IPv6 options */
struct ip6_opt {
uint8_t ip6o_type;
uint8_t ip6o_len;
};
/*
* The high-order 3 bits of the option type define the behavior
* when processing an unknown option and whether or not the option
* content changes in flight.
*/
#define IP6OPT_TYPE(o) ((o) & 0xc0)
#define IP6OPT_TYPE_SKIP 0x00
#define IP6OPT_TYPE_DISCARD 0x40
#define IP6OPT_TYPE_FORCEICMP 0x80
#define IP6OPT_TYPE_ICMP 0xc0
#define IP6OPT_MUTABLE 0x20
#define IP6OPT_PAD1 0x00 /* 00 0 00000 */
#define IP6OPT_PADN 0x01 /* 00 0 00001 */
#define IP6OPT_JUMBO 0xc2 /* 11 0 00010 */
#define IP6OPT_NSAP_ADDR 0xc3 /* 11 0 00011 */
#define IP6OPT_TUNNEL_LIMIT 0x04 /* 00 0 00100 */
#define IP6OPT_ROUTER_ALERT 0x05 /* 00 0 00101 */
/* Jumbo Payload Option */
struct ip6_opt_jumbo {
uint8_t ip6oj_type;
uint8_t ip6oj_len;
uint8_t ip6oj_jumbo_len[4];
};
#define IP6OPT_JUMBO_LEN 6
/* NSAP Address Option */
struct ip6_opt_nsap {
uint8_t ip6on_type;
uint8_t ip6on_len;
uint8_t ip6on_src_nsap_len;
uint8_t ip6on_dst_nsap_len;
/* followed by source NSAP */
/* followed by destination NSAP */
};
/* Tunnel Limit Option */
struct ip6_opt_tunnel {
uint8_t ip6ot_type;
uint8_t ip6ot_len;
uint8_t ip6ot_encap_limit;
};
/* Router Alert Option */
struct ip6_opt_router {
uint8_t ip6or_type;
uint8_t ip6or_len;
uint8_t ip6or_value[2];
};
/* Router alert values (in network byte order) */
#ifdef _BIG_ENDIAN
#define IP6_ALERT_MLD 0x0000
#define IP6_ALERT_RSVP 0x0001
#define IP6_ALERT_AN 0x0002
#else
#define IP6_ALERT_MLD 0x0000
#define IP6_ALERT_RSVP 0x0100
#define IP6_ALERT_AN 0x0200
#endif
2.2. The icmp6_hdr Structure
The ICMPv6 header is needed by numerous IPv6 applications including
Ping, Traceroute, router discovery daemons, and neighbor discovery
daemons. The following structure is defined as a result of including
<netinet/icmp6.h>. Note that this is a new header.
struct icmp6_hdr {
uint8_t icmp6_type; /* type field */
uint8_t icmp6_code; /* code field */
uint16_t icmp6_cksum; /* checksum field */
union {
uint32_t icmp6_un_data32[1]; /* type-specific field */
uint16_t icmp6_un_data16[2]; /* type-specific field */
uint8_t icmp6_un_data8[4]; /* type-specific field */
} icmp6_dataun;
};
#define icmp6_data32 icmp6_dataun.icmp6_un_data32
#define icmp6_data16 icmp6_dataun.icmp6_un_data16
#define icmp6_data8 icmp6_dataun.icmp6_un_data8
#define icmp6_pptr icmp6_data32[0] /* parameter prob */
#define icmp6_mtu icmp6_data32[0] /* packet too big */
#define icmp6_id icmp6_data16[0] /* echo request/reply */
#define icmp6_seq icmp6_data16[1] /* echo request/reply */
#define icmp6_maxdelay icmp6_data16[0] /* mcast group
membership */
2.2.1. ICMPv6 Type and Code Values
In addition to a common structure for the ICMPv6 header, common
definitions are required for the ICMPv6 type and code fields. The
following constants are also defined as a result of including
<netinet/icmp6.h>.
#define ICMP6_DST_UNREACH 1
#define ICMP6_PACKET_TOO_BIG 2
#define ICMP6_TIME_EXCEEDED 3
#define ICMP6_PARAM_PROB 4
#define ICMP6_INFOMSG_MASK 0x80 /* all informational
messages */
#define ICMP6_ECHO_REQUEST 128
#define ICMP6_ECHO_REPLY 129
#define ICMP6_DST_UNREACH_NOROUTE 0 /* no route to
destination */
#define ICMP6_DST_UNREACH_ADMIN 1 /* communication with
destination */
/* admin. prohibited */
#define ICMP6_DST_UNREACH_BEYONDSCOPE 2 /* beyond scope of source
address */
#define ICMP6_DST_UNREACH_ADDR 3 /* address unreachable */
#define ICMP6_DST_UNREACH_NOPORT 4 /* bad port */
#define ICMP6_TIME_EXCEED_TRANSIT 0 /* Hop Limit == 0 in
transit */
#define ICMP6_TIME_EXCEED_REASSEMBLY 1 /* Reassembly time out */
#define ICMP6_PARAMPROB_HEADER 0 /* erroneous header
field */
#define ICMP6_PARAMPROB_NEXTHEADER 1 /* unrecognized
Next Header */
#define ICMP6_PARAMPROB_OPTION 2 /* unrecognized
IPv6 option */
The five ICMP message types defined by IPv6 neighbor discovery (133-
137) are defined in the next section.
2.2.2. ICMPv6 Neighbor Discovery Definitions
The following structures and definitions are defined as a result of
including <netinet/icmp6.h>.
#define ND_ROUTER_SOLICIT 133
#define ND_ROUTER_ADVERT 134
#define ND_NEIGHBOR_SOLICIT 135
#define ND_NEIGHBOR_ADVERT 136
#define ND_REDIRECT 137
struct nd_router_solicit { /* router solicitation */
struct icmp6_hdr nd_rs_hdr;
/* could be followed by options */
};
#define nd_rs_type nd_rs_hdr.icmp6_type
#define nd_rs_code nd_rs_hdr.icmp6_code
#define nd_rs_cksum nd_rs_hdr.icmp6_cksum
#define nd_rs_reserved nd_rs_hdr.icmp6_data32[0]
struct nd_router_advert { /* router advertisement */
struct icmp6_hdr nd_ra_hdr;
uint32_t nd_ra_reachable; /* reachable time */
uint32_t nd_ra_retransmit; /* retransmit timer */
/* could be followed by options */
};
#define nd_ra_type nd_ra_hdr.icmp6_type
#define nd_ra_code nd_ra_hdr.icmp6_code
#define nd_ra_cksum nd_ra_hdr.icmp6_cksum
#define nd_ra_curhoplimit nd_ra_hdr.icmp6_data8[0]
#define nd_ra_flags_reserved nd_ra_hdr.icmp6_data8[1]
#define ND_RA_FLAG_MANAGED 0x80
#define ND_RA_FLAG_OTHER 0x40
#define nd_ra_router_lifetime nd_ra_hdr.icmp6_data16[1]
struct nd_neighbor_solicit { /* neighbor solicitation */
struct icmp6_hdr nd_ns_hdr;
struct in6_addr nd_ns_target; /* target address */
/* could be followed by options */
};
#define nd_ns_type nd_ns_hdr.icmp6_type
#define nd_ns_code nd_ns_hdr.icmp6_code
#define nd_ns_cksum nd_ns_hdr.icmp6_cksum
#define nd_ns_reserved nd_ns_hdr.icmp6_data32[0]
struct nd_neighbor_advert { /* neighbor advertisement */
struct icmp6_hdr nd_na_hdr;
struct in6_addr nd_na_target; /* target address */
/* could be followed by options */
};
#define nd_na_type nd_na_hdr.icmp6_type
#define nd_na_code nd_na_hdr.icmp6_code
#define nd_na_cksum nd_na_hdr.icmp6_cksum
#define nd_na_flags_reserved nd_na_hdr.icmp6_data32[0]
#if BYTE_ORDER == BIG_ENDIAN
#define ND_NA_FLAG_ROUTER 0x80000000
#define ND_NA_FLAG_SOLICITED 0x40000000
#define ND_NA_FLAG_OVERRIDE 0x20000000
#else /* BYTE_ORDER == LITTLE_ENDIAN */
#define ND_NA_FLAG_ROUTER 0x00000080
#define ND_NA_FLAG_SOLICITED 0x00000040
#define ND_NA_FLAG_OVERRIDE 0x00000020
#endif
struct nd_redirect { /* redirect */
struct icmp6_hdr nd_rd_hdr;
struct in6_addr nd_rd_target; /* target address */
struct in6_addr nd_rd_dst; /* destination address */
/* could be followed by options */
};
#define nd_rd_type nd_rd_hdr.icmp6_type
#define nd_rd_code nd_rd_hdr.icmp6_code
#define nd_rd_cksum nd_rd_hdr.icmp6_cksum
#define nd_rd_reserved nd_rd_hdr.icmp6_data32[0]
struct nd_opt_hdr { /* Neighbor discovery option header */
uint8_t nd_opt_type;
uint8_t nd_opt_len; /* in units of 8 octets */
/* followed by option specific data */
};
#define ND_OPT_SOURCE_LINKADDR 1
#define ND_OPT_TARGET_LINKADDR 2
#define ND_OPT_PREFIX_INFORMATION 3
#define ND_OPT_REDIRECTED_HEADER 4
#define ND_OPT_MTU 5
struct nd_opt_prefix_info { /* prefix information */
uint8_t nd_opt_pi_type;
uint8_t nd_opt_pi_len;
uint8_t nd_opt_pi_prefix_len;
uint8_t nd_opt_pi_flags_reserved;
uint32_t nd_opt_pi_valid_time;
uint32_t nd_opt_pi_preferred_time;
uint32_t nd_opt_pi_reserved2;
struct in6_addr nd_opt_pi_prefix;
};
#define ND_OPT_PI_FLAG_ONLINK 0x80
#define ND_OPT_PI_FLAG_AUTO 0x40
struct nd_opt_rd_hdr { /* redirected header */
uint8_t nd_opt_rh_type;
uint8_t nd_opt_rh_len;
uint16_t nd_opt_rh_reserved1;
uint32_t nd_opt_rh_reserved2;
/* followed by IP header and data */
};
struct nd_opt_mtu { /* MTU option */
uint8_t nd_opt_mtu_type;
uint8_t nd_opt_mtu_len;
uint16_t nd_opt_mtu_reserved;
uint32_t nd_opt_mtu_mtu;
};
We note that the nd_na_flags_reserved flags have the same byte
ordering problems as we showed with ip6f_offlg.
2.2.3. Multicast Listener Discovery Definitions
The following structures and definitions are defined as a result of
including <netinet/icmp6.h>.
#define MLD_LISTENER_QUERY 130
#define MLD_LISTENER_REPORT 131
#define MLD_LISTENER_REDUCTION 132
struct mld_hdr {
struct icmp6_hdr mld_icmp6_hdr;
struct in6_addr mld_addr; /* multicast address */
};
#define mld_type mld_icmp6_hdr.icmp6_type
#define mld_code mld_icmp6_hdr.icmp6_code
#define mld_cksum mld_icmp6_hdr.icmp6_cksum
#define mld_maxdelay mld_icmp6_hdr.icmp6_data16[0]
#define mld_reserved mld_icmp6_hdr.icmp6_data16[1]
2.2.4. ICMPv6 Router Renumbering Definitions
The following structures and definitions are defined as a result of
including <netinet/icmp6.h>.
#define ICMP6_ROUTER_RENUMBERING 138 /* router renumbering */
struct icmp6_router_renum { /* router renumbering header */
struct icmp6_hdr rr_hdr;
uint8_t rr_segnum;
uint8_t rr_flags;
uint16_t rr_maxdelay;
uint32_t rr_reserved;
};
#define rr_type rr_hdr.icmp6_type
#define rr_code rr_hdr.icmp6_code
#define rr_cksum rr_hdr.icmp6_cksum
#define rr_seqnum rr_hdr.icmp6_data32[0]
/* Router renumbering flags */
#define ICMP6_RR_FLAGS_TEST 0x80
#define ICMP6_RR_FLAGS_REQRESULT 0x40
#define ICMP6_RR_FLAGS_FORCEAPPLY 0x20
#define ICMP6_RR_FLAGS_SPECSITE 0x10
#define ICMP6_RR_FLAGS_PREVDONE 0x08
struct rr_pco_match { /* match prefix part */
uint8_t rpm_code;
uint8_t rpm_len;
uint8_t rpm_ordinal;
uint8_t rpm_matchlen;
uint8_t rpm_minlen;
uint8_t rpm_maxlen;
uint16_t rpm_reserved;
struct in6_addr rpm_prefix;
};
/* PCO code values */
#define RPM_PCO_ADD 1
#define RPM_PCO_CHANGE 2
#define RPM_PCO_SETGLOBAL 3
struct rr_pco_use { /* use prefix part */
uint8_t rpu_uselen;
uint8_t rpu_keeplen;
uint8_t rpu_ramask;
uint8_t rpu_raflags;
uint32_t rpu_vltime;
uint32_t rpu_pltime;
uint32_t rpu_flags;
struct in6_addr rpu_prefix;
};
#define ICMP6_RR_PCOUSE_RAFLAGS_ONLINK 0x20
#define ICMP6_RR_PCOUSE_RAFLAGS_AUTO 0x10
#if BYTE_ORDER == BIG_ENDIAN
#define ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME 0x80000000
#define ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME 0x40000000
#elif BYTE_ORDER == LITTLE_ENDIAN
#define ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME 0x80
#define ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME 0x40
#endif
struct rr_result { /* router renumbering result message */
uint16_t rrr_flags;
uint8_t rrr_ordinal;
uint8_t rrr_matchedlen;
uint32_t rrr_ifid;
struct in6_addr rrr_prefix;
};
#if BYTE_ORDER == BIG_ENDIAN
#define ICMP6_RR_RESULT_FLAGS_OOB 0x0002
#define ICMP6_RR_RESULT_FLAGS_FORBIDDEN 0x0001
#elif BYTE_ORDER == LITTLE_ENDIAN
#define ICMP6_RR_RESULT_FLAGS_OOB 0x0200
#define ICMP6_RR_RESULT_FLAGS_FORBIDDEN 0x0100
#endif
2.3. Address Testing Macros
The basic API ([RFC-3493]) defines some macros for testing an IPv6
address for certain properties. This API extends those definitions
with additional address testing macros, defined as a result of
including <netinet/in.h>.
int IN6_ARE_ADDR_EQUAL(const struct in6_addr *,
const struct in6_addr *);
This macro returns non-zero if the addresses are equal; otherwise it
returns zero.
2.4. Protocols File
Many hosts provide the file /etc/protocols that contains the names of
the various IP protocols and their protocol number (e.g., the value
of the protocol field in the IPv4 header for that protocol, such as 1
for ICMP). Some programs then call the function getprotobyname() to
obtain the protocol value that is then specified as the third
argument to the socket() function. For example, the Ping program
contains code of the form
struct protoent *proto;
proto = getprotobyname("icmp");
s = socket(AF_INET, SOCK_RAW, proto->p_proto);
Common names are required for the new IPv6 protocols in this file, to
provide portability of applications that call the getprotoXXX()
functions.
We define the following protocol names with the values shown. These
are taken under http://www.iana.org/numbers.html.
hopopt 0 # hop-by-hop options for ipv6
ipv6 41 # ipv6
ipv6-route 43 # routing header for ipv6
ipv6-frag 44 # fragment header for ipv6
esp 50 # encapsulating security payload for ipv6
ah 51 # authentication header for ipv6
ipv6-icmp 58 # icmp for ipv6
ipv6-nonxt 59 # no next header for ipv6
ipv6-opts 60 # destination options for ipv6
3. IPv6 Raw Sockets
Raw sockets bypass the transport layer (TCP or UDP). With IPv4, raw
sockets are used to access ICMPv4, IGMPv4, and to read and write IPv4
datagrams containing a protocol field that the kernel does not
process. An example of the latter is a routing daemon for OSPF,
since it uses IPv4 protocol field 89. With IPv6 raw sockets will be
used for ICMPv6 and to read and write IPv6 datagrams containing a
Next Header field that the kernel does not process. Examples of the
latter are a routing daemon for OSPF for IPv6 and RSVP (protocol
field 46).
All data sent via raw sockets must be in network byte order and all
data received via raw sockets will be in network byte order. This
differs from the IPv4 raw sockets, which did not specify a byte
ordering and used the host's byte order for certain IP header fields.
Another difference from IPv4 raw sockets is that complete packets
(that is, IPv6 packets with extension headers) cannot be sent or
received using the IPv6 raw sockets API. Instead, ancillary data
objects are used to transfer the extension headers and hoplimit
information, as described in Section 6. Should an application need
access to the complete IPv6 packet, some other technique, such as the
datalink interfaces BPF or DLPI, must be used.
All fields except the flow label in the IPv6 header that an
application might want to change (i.e., everything other than the
version number) can be modified using ancillary data and/or socket
options by the application for output. All fields except the flow
label in a received IPv6 header (other than the version number and
Next Header fields) and all extension headers that an application
might want to know are also made available to the application as
ancillary data on input. Hence there is no need for a socket option
similar to the IPv4 IP_HDRINCL socket option and on receipt the
application will only receive the payload i.e., the data after the
IPv6 header and all the extension headers.
This API does not define access to the flow label field, because
today there is no standard usage of the field.
When writing to a raw socket the kernel will automatically fragment
the packet if its size exceeds the path MTU, inserting the required
fragment headers. On input the kernel reassembles received
fragments, so the reader of a raw socket never sees any fragment
headers.
When we say "an ICMPv6 raw socket" we mean a socket created by
calling the socket function with the three arguments AF_INET6,
SOCK_RAW, and IPPROTO_ICMPV6.
Most IPv4 implementations give special treatment to a raw socket
created with a third argument to socket() of IPPROTO_RAW, whose value
is normally 255, to have it mean that the application will send down
complete packets including the IPv4 header. (Note: This feature was
added to IPv4 in 1988 by Van Jacobson to support traceroute, allowing
a complete IP header to be passed by the application, before the
IP_HDRINCL socket option was added.) We note that IPPROTO_RAW has no
special meaning to an IPv6 raw socket (and the IANA currently
reserves the value of 255 when used as a next-header field).
3.1. Checksums
The kernel will calculate and insert the ICMPv6 checksum for ICMPv6
raw sockets, since this checksum is mandatory.
For other raw IPv6 sockets (that is, for raw IPv6 sockets created
with a third argument other than IPPROTO_ICMPV6), the application
must set the new IPV6_CHECKSUM socket option to have the kernel (1)
compute and store a checksum for output, and (2) verify the received
checksum on input, discarding the packet if the checksum is in error.
This option prevents applications from having to perform source
address selection on the packets they send. The checksum will
incorporate the IPv6 pseudo-header, defined in Section 8.1 of [RFC-
2460]. This new socket option also specifies an integer offset into
the user data of where the checksum is located.
int offset = 2;
setsockopt(fd, IPPROTO_IPV6, IPV6_CHECKSUM, &offset,
sizeof(offset));
By default, this socket option is disabled. Setting the offset to -1
also disables the option. By disabled we mean (1) the kernel will
not calculate and store a checksum for outgoing packets, and (2) the
kernel will not verify a checksum for received packets.
This option assumes the use of the 16-bit one's complement of the
one's complement sum as the checksum algorithm and that the checksum
field is aligned on a 16-bit boundary. Thus, specifying a positive
odd value as offset is invalid, and setsockopt() will fail for such
offset values.
An attempt to set IPV6_CHECKSUM for an ICMPv6 socket will fail.
Also, an attempt to set or get IPV6_CHECKSUM for a non-raw IPv6
socket will fail.
(Note: Since the checksum is always calculated by the kernel for an
ICMPv6 socket, applications are not able to generate ICMPv6 packets
with incorrect checksums (presumably for testing purposes) using this
API.)
3.2. ICMPv6 Type Filtering
ICMPv4 raw sockets receive most ICMPv4 messages received by the
kernel. (We say "most" and not "all" because Berkeley-derived
kernels never pass echo requests, timestamp requests, or address mask
requests to a raw socket. Instead these three messages are processed
entirely by the kernel.) But ICMPv6 is a superset of ICMPv4, also
including the functionality of IGMPv4 and ARPv4. This means that an
ICMPv6 raw socket can potentially receive many more messages than
would be received with an ICMPv4 raw socket: ICMP messages similar to
ICMPv4, along with neighbor solicitations, neighbor advertisements,
and the three multicast listener discovery messages.
Most applications using an ICMPv6 raw socket care about only a small
subset of the ICMPv6 message types. To transfer extraneous ICMPv6
messages from the kernel to user can incur a significant overhead.
Therefore this API includes a method of filtering ICMPv6 messages by
the ICMPv6 type field.
Each ICMPv6 raw socket has an associated filter whose datatype is
defined as
struct icmp6_filter;
This structure, along with the macros and constants defined later in
this section, are defined as a result of including the
<netinet/icmp6.h>.
The current filter is fetched and stored using getsockopt() and
setsockopt() with a level of IPPROTO_ICMPV6 and an option name of
ICMP6_FILTER.
Six macros operate on an icmp6_filter structure:
void ICMP6_FILTER_SETPASSALL (struct icmp6_filter *);
void ICMP6_FILTER_SETBLOCKALL(struct icmp6_filter *);
void ICMP6_FILTER_SETPASS ( int, struct icmp6_filter *);
void ICMP6_FILTER_SETBLOCK( int, struct icmp6_filter *);
int ICMP6_FILTER_WILLPASS (int,
const struct icmp6_filter *);
int ICMP6_FILTER_WILLBLOCK(int,
const struct icmp6_filter *);
The first argument to the last four macros (an integer) is an ICMPv6
message type, between 0 and 255. The pointer argument to all six
macros is a pointer to a filter that is modified by the first four
macros and is examined by the last two macros.
The first two macros, SETPASSALL and SETBLOCKALL, let us specify that
all ICMPv6 messages are passed to the application or that all ICMPv6
messages are blocked from being passed to the application.
The next two macros, SETPASS and SETBLOCK, let us specify that
messages of a given ICMPv6 type should be passed to the application
or not passed to the application (blocked).
The final two macros, WILLPASS and WILLBLOCK, return true or false
depending whether the specified message type is passed to the
application or blocked from being passed to the application by the
filter pointed to by the second argument.
When an ICMPv6 raw socket is created, it will by default pass all
ICMPv6 message types to the application.
As an example, a program that wants to receive only router
advertisements could execute the following:
struct icmp6_filter myfilt;
fd = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
ICMP6_FILTER_SETBLOCKALL(&myfilt);
ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &myfilt);
setsockopt(fd, IPPROTO_ICMPV6, ICMP6_FILTER, &myfilt,
sizeof(myfilt));
The filter structure is declared and then initialized to block all
messages types. The filter structure is then changed to allow router
advertisement messages to be passed to the application and the filter
is installed using setsockopt().
In order to clear an installed filter the application can issue a
setsockopt for ICMP6_FILTER with a zero length. When no such filter
has been installed, getsockopt() will return the kernel default
filter.
The icmp6_filter structure is similar to the fd_set datatype used
with the select() function in the sockets API. The icmp6_filter
structure is an opaque datatype and the application should not care
how it is implemented. All the application does with this datatype
is allocate a variable of this type, pass a pointer to a variable of
this type to getsockopt() and setsockopt(), and operate on a variable
of this type using the six macros that we just defined.
Nevertheless, it is worth showing a simple implementation of this
datatype and the six macros.
struct icmp6_filter {
uint32_t icmp6_filt[8]; /* 8*32 = 256 bits */
};
#define ICMP6_FILTER_WILLPASS(type, filterp) \
((((filterp)->icmp6_filt[(type) >> 5]) & \
(1 << ((type) & 31))) != 0)
#define ICMP6_FILTER_WILLBLOCK(type, filterp) \
((((filterp)->icmp6_filt[(type) >> 5]) & \
(1 << ((type) & 31))) == 0)
#define ICMP6_FILTER_SETPASS(type, filterp) \
((((filterp)->icmp6_filt[(type) >> 5]) |= \
(1 << ((type) & 31))))
#define ICMP6_FILTER_SETBLOCK(type, filterp) \
((((filterp)->icmp6_filt[(type) >> 5]) &= \
~(1 << ((type) & 31))))
#define ICMP6_FILTER_SETPASSALL(filterp) \
memset((filterp), 0xFF, sizeof(struct icmp6_filter))
#define ICMP6_FILTER_SETBLOCKALL(filterp) \
memset((filterp), 0, sizeof(struct icmp6_filter))
(Note: These sample definitions have two limitations that an
implementation may want to change. The first four macros evaluate
their first argument two times. The second two macros require the
inclusion of the <string.h> header for the memset() function.)
3.3. ICMPv6 Verification of Received Packets
The protocol stack will verify the ICMPv6 checksum and discard any
packets with invalid checksums.
An implementation might perform additional validity checks on the
ICMPv6 message content and discard malformed packets. However, a
portable application must not assume that such validity checks have
been performed.
The protocol stack should not automatically discard packets if the
ICMP type is unknown to the stack. For extensibility reasons
received ICMP packets with any type (informational or error) must be
passed to the applications (subject to ICMP6_FILTER filtering on the
type value and the checksum verification).
4. Access to IPv6 and Extension Headers
Applications need to be able to control IPv6 header and extension
header content when sending as well as being able to receive the
content of these headers. This is done by defining socket option
types which can be used both with setsockopt and with ancillary data.
Ancillary data is discussed in Appendix A. The following optional
information can be exchanged between the application and the kernel:
1. The send/receive interface and source/destination address,
2. The hop limit,
3. Next hop address,
4. The traffic class,
5. Routing header,
6. Hop-by-Hop options header, and
7. Destination options header.
First, to receive any of this optional information (other than the
next hop address, which can only be set) on a UDP or raw socket, the
application must call setsockopt() to turn on the corresponding flag:
int on = 1;
setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on));
setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on, sizeof(on));
setsockopt(fd, IPPROTO_IPV6, IPV6_RECVRTHDR, &on, sizeof(on));
setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPOPTS, &on, sizeof(on));
setsockopt(fd, IPPROTO_IPV6, IPV6_RECVDSTOPTS, &on, sizeof(on));
setsockopt(fd, IPPROTO_IPV6, IPV6_RECVTCLASS, &on, sizeof(on));
When any of these options are enabled, the corresponding data is
returned as control information by recvmsg(), as one or more
ancillary data objects.
This document does not define how to receive the optional information
on a TCP socket. See Section 4.1 for more details.
Two different mechanisms exist for sending this optional information:
1. Using setsockopt to specify the option content for a socket.
These are known "sticky" options since they affect all transmitted
packets on the socket until either a new setsockopt is done or the
options are overridden using ancillary data.
2. Using ancillary data to specify the option content for a single
datagram. This only applies to datagram and raw sockets; not to
TCP sockets.
The three socket option parameters and the three cmsghdr fields that
describe the options/ancillary data objects are summarized as:
opt level/ optname/ optval/
cmsg_level cmsg_type cmsg_data[]
------------ ------------ ------------------------
IPPROTO_IPV6 IPV6_PKTINFO in6_pktinfo structure
IPPROTO_IPV6 IPV6_HOPLIMIT int
IPPROTO_IPV6 IPV6_NEXTHOP socket address structure
IPPROTO_IPV6 IPV6_RTHDR ip6_rthdr structure
IPPROTO_IPV6 IPV6_HOPOPTS ip6_hbh structure
IPPROTO_IPV6 IPV6_DSTOPTS ip6_dest structure
IPPROTO_IPV6 IPV6_RTHDRDSTOPTS ip6_dest structure
IPPROTO_IPV6 IPV6_TCLASS int
(Note: IPV6_HOPLIMIT can be used as ancillary data items only)
All these options are described in detail in Section 6, 7, 8 and 9.
All the constants beginning with IPV6_ are defined as a result of
including <netinet/in.h>.
Note: We intentionally use the same constant for the cmsg_level
member as is used as the second argument to getsockopt() and
setsockopt() (what is called the "level"), and the same constant for
the cmsg_type member as is used as the third argument to getsockopt()
and setsockopt() (what is called the "option name").
Issuing getsockopt() for the above options will return the sticky
option value i.e., the value set with setsockopt(). If no sticky
option value has been set getsockopt() will return the following
values:
- For the IPV6_PKTINFO option, it will return an in6_pktinfo
structure with ipi6_addr being in6addr_any and ipi6_ifindex being
zero.
- For the IPV6_TCLASS option, it will return the kernel default
value.
- For other options, it will indicate the lack of the option value
with optlen being zero.
The application does not explicitly need to access the data
structures for the Routing header, Hop-by-Hop options header, and
Destination options header, since the API to these features is
through a set of inet6_rth_XXX() and inet6_opt_XXX() functions that
we define in Section 7 and Section 10. Those functions simplify the
interface to these features instead of requiring the application to
know the intimate details of the extension header formats.
When specifying extension headers, this API assumes the header
ordering and the number of occurrences of each header as described in
[RFC-2460]. More details about the ordering issue will be discussed
in Section 12.
4.1. TCP Implications
It is not possible to use ancillary data to transmit the above
options for TCP since there is not a one-to-one mapping between send
operations and the TCP segments being transmitted. Instead an
application can use setsockopt to specify them as sticky options.
When the application uses setsockopt to specify the above options it
is expected that TCP will start using the new information when
sending segments. However, TCP may or may not use the new
information when retransmitting segments that were originally sent
when the old sticky options were in effect.
It is unclear how a TCP application can use received information
(such as extension headers) due to the lack of mapping between
received TCP segments and receive operations. In particular, the
received information could not be used for access control purposes
like on UDP and raw sockets.
This specification therefore does not define how to get the received
information on TCP sockets. The result of the IPV6_RECVxxx options
on a TCP socket is undefined as well.
4.2. UDP and Raw Socket Implications
The receive behavior for UDP and raw sockets is quite
straightforward. After the application has enabled an IPV6_RECVxxx
socket option it will receive ancillary data items for every
recvmsg() call containing the requested information. However, if the
information is not present in the packet the ancillary data item will
not be included. For example, if the application enables
IPV6_RECVRTHDR and a received datagram does not contain a Routing
header there will not be an IPV6_RTHDR ancillary data item. Note
that due to buffering in the socket implementation there might be
some packets queued when an IPV6_RECVxxx option is enabled and they
might not have the ancillary data information.
For sending the application has the choice between using sticky
options and ancillary data. The application can also use both having
the sticky options specify the "default" and using ancillary data to
override the default options.
When an ancillary data item is specified in a call to sendmsg(), the
item will override an existing sticky option of the same name (if
previously specified). For example, if the application has set
IPV6_RTHDR using a sticky option and later passes IPV6_RTHDR as
ancillary data this will override the IPV6_RTHDR sticky option and
the routing header of the outgoing packet will be from the ancillary
data item, not from the sticky option. Note, however, that other
sticky options than IPV6_RTHDR will not be affected by the IPV6_RTHDR
ancillary data item; the overriding mechanism only works for the same
type of sticky options and ancillary data items.
(Note: the overriding rule is different from the one in RFC2292. In
RFC2292, an ancillary data item overrode all sticky options
previously defined. This was reasonable, because sticky options
could only be specified as a set by a single socket option. However,
in this API, each option is separated so that it can be specified as
a single sticky option. Additionally, there are much more ancillary
data items and sticky options than in RFC2292, including ancillary-
only one. Thus, it should be natural for application programmers to
separate the overriding rule as well.)
An application can also temporarily disable a particular sticky