#include <sys/socket.h> #include <netinet/in.h>, #include <netinet/ip6.h>
s = socket(AF_INET6, SOCK_RAW, proto);
t = t_open ("/dev/rawip6", O_RDWR);
The IPv6 protocol is the next generation of the internetwork datagram delivery protocol of the Internet protocol family. Programs may use IPv6 through higher-level protocols such as the Transmission Control Protocol (TCP) or the User Datagram Protocol (UDP), or may interface directly to IPv6. See tcp(7P) and udp(7P). Direct access may be by means of the socket interface, using a “raw socket,” or by means of the Transport Level Interface (TLI). The protocol options and IPv6 extension headers defined in the IPv6 specification may be set in outgoing datagrams.
The STREAMS driver /dev/rawip6 is the TLI transport provider that provides raw access to IPv6.
Raw IPv6 sockets are connectionless and are normally used with the sendto() and recvfrom() calls (see send(3SOCKET) and recv(3SOCKET)), although the connect(3SOCKET) call may also be used to fix the destination for future datagrams. In this case, the read(2) or recv(3SOCKET) and write(2) or send(3SOCKET) calls may be used. Ancillary data may also be sent or received over raw IPv6 sockets using the sendmsg(3SOCKET) and recvmsg(3SOCKET) system calls.
Unlike raw IP, IPv6 applications do not include a complete IPv6 header when sending; there is no IPv6 analog to the IP IP_HDRINCL socket option. IPv6 header values may be specified or received as ancillary data to a sendmsg(3SOCKET) or recvmsg(3SOCKET) system call, or may be specified as "sticky" options on a per-socket basis by using the setsockopt(3SOCKET) system call. Such sticky options are applied to all outbound packets unless overridden by ancillary data. If any ancillary data is specified in a sendmsg(3SOCKET) call, all sticky options not explicitly overridden revert to default values for that datagram only; the sticky options persist as set for subsequent datagrams.
Since sendmsg(3SOCKET) is not supported for SOCK_STREAM upper level protocols such as TCP, ancillary data is unsupported for TCP. Sticky options, however, are supported.
Since sendmsg(3SOCKET) is supported for SOCK_DGRAM upper level protocols, both ancillary data and sticky options are supported for UDP, ICMP6, and raw IPv6 sockets.
The socket options supported at the IPv6 level are:
Limit reception transmission of packets to this interface. Takes an integer as an argument; the integer is the selected interace index.
Boolean. Allow/disallow sending with a zero source address.
Default hop limit for unicast datagrams. This option takes an integer as an argument. Its value becomes the new default value for ip6_hops that IPv6 will use on outgoing unicast datagrams sent from that socket. The initial default is 60.
Specify the integer offset in bytes into the user data of the checksum location. Does not apply to the ICMP6 protocol. Note: checksums are required for all IPv6 datagrams; this is different from IP, in which datagram checksums were optional. IPv6 will compute the ULP checksum if the value in the checksum field is zero.
Enable or obtain IPsec security settings for this socket. For more details on the protection services of IPsec, see ipsec(7P).
The following options are boolean switches controlling the reception of ancillary data:
Enable/disable receipt of the index of the interface the packet arrived on, and of the inbound packet's destination address.
Enable/disable receipt of the inbound packet's current hoplimit.
Enable/disable receipt of the inbound packet's IPv6 hop-by-hop extension header.
Enable/disable receipt of the inbound packet's IPv6 destination options extension header.
Enable/disable receipt of the inbound packet's IPv6 routing header.
Enable/disable receipt of the inbound packet's intermediate-hops options extension header.
Set the source address and/or interface out which the packet(s) will be sent. Takes a struct ip6_pktinfo as the parameter.
Set the initial hoplimit for outbound datagrams. Takes an integer as the parameter. Note: This option sets the hoplimit only for ancillary data or sticky options and does not change the default hoplimit for the socket; see IPV6_UNICAST_HOPS and IPV6_MULTICAST_HOPS to change the socket's default hoplimit.
Specify the IPv6 address of the first hop, which must be a neighbor of the sending host. Takes a struct sockaddr_in6 as the parameter. When this option specifies the same address as the destination IPv6 address of the datagram, this is equivalent to the existing SO_DONTROUTE option.
Specify one or more hop-by-hop options. Variable length. Takes a complete IPv6 hop-by-hop options extension header as the parameter.
Specify one or more destination options. Variable length. Takes a complete IPv6 destination options extension header as the parameter.
Specify the IPv6 routing header. Variable length. Takes a complete IPv6 routing header as the parameter. Currently, only type 0 routing headers are supported.
Specify one or more destination options for all intermediate hops. May be configured, but will not be applied unless an IPv6 routing header is also configured. Variable length. Takes a complete IPv6 destination options extension header as the parameter.
The following options affect the socket's multicast behavior:
Join a multicast group. Takes a struct ipv6_mreq as the parameter; the structure contains a multicast address and an interface index.
Leave a multicast group. Takes a struct ipv6_mreq as the parameter; the structure contains a multicast address and an interface index.
The outgoing interface for multicast packets. This option takes an integer as an argument; the integer is the interface index of the selected interface.
Default hop limit for multicast datagrams. This option takes an integer as an argument. Its value becomes the new default value for ip6_hops that IPv6 will use on outgoing multicast datagrams sent from that socket. The initial default is 1.
Loopback for multicast datagrams. Normally multicast datagrams are delivered to members on the sending host. Setting the unsigned character argument to 0 will cause the opposite behavior.
The multicast socket options can be used with any datagram socket type in the IPv6 family.
At the socket level, the socket option SO_DONTROUTE may be applied. This option forces datagrams being sent to bypass routing and forwarding by forcing the IPv6 hoplimit field to 1, meaning that the packet will not be forwarded by routers.
Raw IPv6 datagrams can also be sent and received using the TLI connectionless primitives.
Datagrams flow through the IPv6 layer in two directions: from the network up to user processes and from user processes down to the network. Using this orientation, IPv6 is layered above the network interface drivers and below the transport protocols such as UDP and TCP. The Internet Control Message Protocol (ICMPv6) for the Internet Protocol Version 6 (IPv6) is logically a part of IPv6. See icmp6(7P).
Unlike IP, IPv6 provides no checksum of the IPv6 header. Also unlike IP, upper level protocol checksums are required. IPv6 will compute the ULP/data portion checksum if the checksum field contains a zero (see IPV6_CHECKSUM option above).
IPv6 extension headers in received datagrams are processed in the IPv6 layer according to the protocol specification. Currently recognized IPv6 extension headers include hop-by-hop options header, destination options header, routing header (currently, only type 0 routing headers are supported), and fragment header.
The IPv6 layer will normally act as a router (forwarding datagrams that are not addressed to it, among other things) when the machine has two or more IPv6 interfaces that are up. This behavior can be overridden by using ndd(1M) to set the /dev/ip6 variable, ip6_forwarding. The value 0 means do not forward; the value 1 means forward. The initialization scripts (see /etc/init.d/inetinit) set this value at boot time based on the number of "up" interfaces and whether or not the neighbor discovery protocol daemon configuration file /etc/inet/ndpd.conf exists. The default value is zero; ip6_forwarding is set to 1 only if more than one interface has been configured for IPv6 and if /etc/inet/ndpd.conf exists.
Additionally, finer grained forwarding can be configured in IPv6. Each interface will create an ifname:ip6_forwarding /dev/ip6 variable that can be modified using ndd(1M). If a per-interface :ip6_forwarding variable is set to 0, packets will neither be forwarded from this interface to others, nor forwarded to this interface. Setting the ip6_forwarding variable will toggle all of the per-interface :ip6_forwarding variables to the setting of ip6_forwarding.
The IPv6 layer will send an ICMP6 message back to the source host in many cases when it receives a datagram that can not be handled. A "time exceeded" ICMP6 message will be sent if the ip6_hops field in the IPv6 header drops to zero in the process of forwarding a datagram. A "destination unreachable" message will be sent by a router or by the originating host if a datagram can not be sent on because there is no route to the final destination; it will be sent by a router when it encounters a firewall prohibition; it will be sent by a destination node when the transport protocol (that is, TCP) has no listener. A "packet too big" message will be sent by a router if the packet is larger than the MTU of the outgoing link (this is used for Path MTU Discovery). A "parameter problem" message will be sent if there is a problem with a field in the IPv6 header or any of the IPv6 extension headers such that the packet cannot be fully processed.
The IPv6 layer supports fragmentation and reassembly. Datagrams are fragmented on output if the datagram is larger than the maximum transmission unit (MTU) of the network interface. Fragments of received datagrams are dropped from the reassembly queues if the complete datagram is not reconstructed within a short time period.
Errors in sending discovered at the network interface driver layer are passed by IPv6 back up to the user process.
ndd(1M), read(2), write(2), bind(3SOCKET), connect(3SOCKET), getsockopt(3SOCKET), recv(3SOCKET), recvmsg(3SOCKET), send(3SOCKET), sendmsg(3SOCKET), setsockopt(3SOCKET), defaultrouter(4), icmp6(7P), if_tcp(7P), ipsec(7P), inet6(7P), routing(7P), tcp(7P), udp(7P)
Deering, S. and Hinden, B. RFC 2460, Internet Protocol, Version 6 (IPv6) Specification. The Internet Society. December, 1998.
Stevens, W., and Thomas, M. RFC 2292, Advanced Sockets API for IPv6. Network Working Group. February 1998.
A socket operation may fail with one of the following errors returned:
A bind() operation was attempted with a “reserved” port number and the effective user ID of the process was not the privileged user.
A bind() operation was attempted on a socket with a network address/port pair that has already been bound to another socket.
A bind() operation was attempted for an address that is not configured on this machine.
A sendmsg() operation with a non-NULL msg_accrights was attempted.
A getsockopt() or setsockopt() operation with an unknown socket option name was given.
A getsockopt() or setsockopt() operation was attempted with the IPv6 option field improperly formed; an option field was shorter than the minimum value or longer than the option buffer provided; the value in the option field was invalid.
A connect() operation was attempted on a socket on which a connect() operation had already been performed, and the socket could not be successfully disconnected before making the new connection.
A sendto() or sendmsg() operation specifying an address to which the message should be sent was attempted on a socket on which a connect() operation had already been performed.
A send(), sendto(), or sendmsg() operation was attempted to send a datagram that was too large for an interface, but was not allowed to be fragmented (such as broadcasts).
An attempt was made to establish a connection via connect(), or to send a datagram by means of sendto() or sendmsg(), where there was no matching entry in the routing table; or if an ICMP “destination unreachable” message was received.
A send() or write() operation, or a sendto() or sendmsg() operation not specifying an address to which the message should be sent, was attempted on a socket on which a connect() operation had not already been performed.
The system ran out of memory for fragmentation buffers or other internal data structures.
The system was unable to allocate memory for an IPv6 socket option or other internal data structures.
An IP socket option was attempted on an IPv6 socket, or an IPv6 socket option was attempted on an IP socket.
Applications using the sockets API must use the Advanced Sockets API for IPv6 (RFC 2292) to see elements of the inbound packet's IPv6 header or extension headers.