この文書はRFC3542の日本語訳(和訳)です。 この文書の翻訳内容の正確さは保障できないため、 正確な知識や情報を求める方は原文を参照してください。 翻訳者はこの文書によって読者が被り得る如何なる損害の責任をも負いません。 この翻訳内容に誤りがある場合、訂正版の公開や、 誤りの指摘は適切です。 この文書の配布は元のRFC同様に無制限です。


Network Working Group                                         W. Stevens
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
IPv6のための高等ソケットアプリケーションプログラムインターフェース(API)

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, RFC 3493.  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.
   この文書は別の仕様書、RFC3493の補足として、「高等」IPv6ア
   プリケーションを支援するためのソケットアプリケーションプログラムイン
   ターフェース(API)を用意します。期待されるアプリケーションには
   Ping、Traceroute、ルーティングデーモンなどを含み、これらは典型的にI
   Pv6あるいはICMPv6ヘッダーフィールドにアクセスするために生ソ
   ケットを使います。この文書はIPv6で生ソケットを使うアプリケーショ
   ンに対して移植性があるインタフェースを提案します。あるアプリケーショ
   ンがアクセスする必要があるIPv6の他の機能があります:(出インタ
   フェース指定と入インタフェース決定時の)インタフェース識別子とIPv
   6拡張子ヘッダとパス最大転送単位(MTU)情報。この文書はこれらの機
   能へもAPIアクセスを供給します。さらに、ある「r」コマンドのライブ
   ラリの拡張インタフェースが定義されます。拡張はIPv6対応でない既存
   の実装により良い逆方向互換性を供給するでしょう。


Table of Contents
目次

   1.  Introduction
   1.  はじめに
   2.  Common Structures and Definitions
   2.  共通の構造体と定義
        2.1.  The ip6_hdr Structure
        2.1.  ip6_hdr構造体
             2.1.1.  IPv6 Next Header Values
             2.1.1.  IPv6次ヘッダ値
             2.1.2.  IPv6 Extension Headers
             2.1.2.  IPv6拡張ヘッダ
             2.1.3.  IPv6 Options
             2.1.3.  IPv6オプション
        2.2.  The icmp6_hdr Structure
        2.2.  icmp6_hdr構造体
             2.2.1.  ICMPv6 Type and Code Values
             2.2.1.  ICMPv6タイプとコード値
             2.2.2.  ICMPv6 Neighbor Discovery Definitions
             2.2.2.  ICMPv6近隣探索タイプとコード値
             2.2.3.  Multicast Listener Discovery Definitions
             2.2.3.  マルチキャスト受信者探索定義
             2.2.4.  ICMPv6 Router Renumbering Definitions
             2.2.4.  ICMPv6ルータリナンバリング定義
        2.3.  Address Testing Macros
        2.3.  アドレステストマクロ
        2.4.  Protocols File
        2.4.  プロトコルファイル
   3.  IPv6 Raw Sockets
   3.  IPv6生ソケット
        3.1.  Checksums
        3.1.  チェックサム
        3.2.  ICMPv6 Type Filtering
        3.2.  ICMPv6タイプフィルタリング
        3.3.  ICMPv6 Verification of Received Packets
        3.3.  受信パケットのICMPv6検証
   4.  Access to IPv6 and Extension Headers
   4.  IPv6と拡張ヘッダのアクセス
        4.1.  TCP Implications
        4.1.  TCPとの関係
        4.2.  UDP and Raw Socket Implications
        4.2.  UDPと生ソケット意味
   5.  Extensions to Socket Ancillary Data
   5.  ソケット補助的なデータへの拡張
        5.1.  CMSG_NXTHDR
        5.1.  CMSG_NXTHDR
        5.2.  CMSG_SPACE
        5.2.  CMSG_SPACE
        5.3.  CMSG_LEN
        5.3.  CMSG_LEN
   6.  Packet Information
   6.  パケット情報
        6.1.  Specifying/Receiving the Interface
        6.1.  インタフェース指定/受信
        6.2.  Specifying/Receiving Source/Destination Address
        6.2.  ソース/宛先アドレスの指定/受信
        6.3.  Specifying/Receiving the Hop Limit
        6.3.  ホップ限界の指定/受信
        6.4.  Specifying the Next Hop Address
        6.4.  次の転送先アドレスの指定
        6.5.  Specifying/Receiving the Traffic Class value
        6.5.  トラフィッククラス値の指定/受信
        6.6.  Additional Errors with sendmsg() and setsockopt()
        6.6.  sendmsg()とsetsockopt()の追加エラー
        6.7.  Summary of Outgoing Interface Selection
        6.7.  出インタフェース選択のまとめ
   7.  Routing Header Option
   7.  ルーティングヘッダーオプション
        7.1.  inet6_rth_space
        7.1.  inet6_rth_space
        7.2.  inet6_rth_init
        7.2.  inet6_rth_init
        7.3.  inet6_rth_add
        7.3.  inet6_rth_add
        7.4.  inet6_rth_reverse
        7.4.  inet6_rth_reverse
        7.5.  inet6_rth_segments
        7.5.  inet6_rth_segments
        7.6.  inet6_rth_getaddr
        7.6.  inet6_rth_getaddr
   8.  Hop-By-Hop Options
   8.  ホップ毎オプション
        8.1.  Receiving Hop-by-Hop Options
        8.1.  ホップ毎オプションの受信
        8.2.  Sending Hop-by-Hop Options
        8.2.  ホップ毎オプションの送信
   9.  Destination Options
   9.  宛先オプション
        9.1.  Receiving Destination Options
        9.1.  宛先オプション受信
        9.2.  Sending Destination Options
        9.2.  宛先オプション送信
   10.  Hop-by-Hop and Destination Options Processing
   10.  ホップ毎オプションと宛先オプション処理
        10.1.  inet6_opt_init
        10.1.  inet6_opt_init
        10.2.  inet6_opt_append
        10.2.  inet6_opt_append
        10.3.  inet6_opt_finish
        10.3.  inet6_opt_finish
        10.4.  inet6_opt_set_val
        10.4.  inet6_opt_set_val
        10.5.  inet6_opt_next
        10.5.  inet6_opt_next
        10.6.  inet6_opt_find
        10.6.  inet6_opt_find
        10.7.  inet6_opt_get_val
        10.7.  inet6_opt_get_val
   11.  Additional Advanced API Functions
   11.  追加高等API関数
        11.1.  Sending with the Minimum MTU
        11.1.  最小MTUでの送信
        11.2.  Sending without Fragmentation
        11.2.  分割なしの送信
        11.3.  Path MTU Discovery and UDP
        11.3.  パスMTU探索とUDP
        11.4.  Determining the Current Path MTU
        11.4.  現在のパスMTUの決定
   12.  Ordering of Ancillary Data and IPv6 Extension Headers
   12.  補助的なデータとIPv6拡張ヘッダの順序
   13.  IPv6-Specific Options with IPv4-Mapped IPv6 Addresses
   13.  IPv4マップIPv6アドレスのIPv6固有オプション
   14.  Extended interfaces for rresvport, rcmd and rexec
   14.  rresvportとrcmdとrexecののインタフェース拡張
        14.1.  rresvport_af
        14.1.  rresvport_af
        14.2.  rcmd_af
        14.2.  rcmd_af
        14.3.  rexec_af
        14.3.  rexec_af
   15.  Summary of New Definitions
   15.  新しい定義の要約
   16.  Security Considerations
   16.  セキュリティの考慮
   17.  Changes from RFC 2292
   17.  RFC2292からの変更
   18.  References
   18.  参考文献
   19.  Acknowledgments
   19.  謝辞
   20.  Appendix A: Ancillary Data Overview
   20.  付録A:補助的データの概要
        20.1.  The msghdr Structure
        20.1.  msghdr構造体
        20.2.  The cmsghdr Structure
        20.2.  cmsghdr構造体
        20.3.  Ancillary Data Object Macros
        20.3.  補助的なデータオブジェクトマクロ
        20.3.1.  CMSG_FIRSTHDR
        20.3.1.  CMSG_FIRSTHDR
        20.3.2.  CMSG_NXTHDR
        20.3.2.  CMSG_NXTHDR
        20.3.3.  CMSG_DATA
        20.3.3.  CMSG_DATA
        20.3.4.  CMSG_SPACE
        20.3.4.  CMSG_SPACE
        20.3.5.  CMSG_LEN
        20.3.5.  CMSG_LEN
   21.  Appendix B: Examples Using the inet6_rth_XXX() Functions
   21.  付録B:inet6_rth_XXX()関数を使う例
        21.1.  Sending a Routing Header
        21.1.  ルーティングヘッダ送信
        21.2.  Receiving Routing Headers
        21.2.  ルーティングヘッダ受信
   22.  Appendix C: Examples Using the inet6_opt_XXX() Functions
   22.  付録C:inet6_opt_XXX()関数を使う例
        22.1.  Building Options
        22.1.  オプション構築
        22.2.  Parsing Received Options
        22.2.  受信オプションの解析
   23. Authors' Addresses
   23. 著者のアドレス
   24. Full Copyright Statement
   24. 著作権表示全文


1.  Introduction
1.  はじめに

   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.
   別の仕様書[RFC-3493]がIPバージョン6をサポートするためのソケットA
   PIに対する変更を含みます。これらの変更はTCPとUDPベースのアプ
   リケーションのためです。この文書はIPv6の追加機能を利用するアプリ
   ケーションに必要とされるあるソケットAPIの「高等」機能を定義します。

   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.
   今日、IPv4生ソケットを使っているアプリケーションのポータビリティ
   は非常に高いです、しかしこれは主にほとんどのIPv4実装が共通の起源
   (バークレーソースコード)を持つか、あるいは少なくともバークレーヘッ
   ダファイルから始まったからです。これは例えばPingとTracerouteのような
   プログラムがソケットAPIをサポートする多くのホストの上で最小の努力
   でコンパイルすることを許します。しかしながら、IPv6で実装者の共通
   のソースコードがなく、異なった実装間での異なる可能性が高いです。生の
   IPv6ソケットを使うアプリケーションの間でポータビリティが全くなく
   なるのを避けるために、いくらかの標準化が必要です。

   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.
   [RFC-3493]で扱われない基本的なIPv6仕様の機能があります:ルーティ
   ングヘッダとホップ毎オプションと宛先オプションの送信と受信、出インタ
   フェース指定、入インタフェース決定、パスMTU情報制御。

   This document updates and replaces RFC 2292.  This revision is based
   on implementation experience of RFC 2292, 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].
   この文書はRFC2292を更新し置き換えます。この修正はRFC229
   2の実装経験に基づき、IPv6展開を通して有用であることがわかったあ
   る追加の拡張です。しかしながら、この文書のさらなる仕事がまだ必要かも
   しれないことに注意してください。API仕様書が成熟して、実装間で動く
   ようになると、基本的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).
   1. アプリケーションが生IPv6ソケットを使うのに必要な基本的な定
      数と構造体の定義。これはIPv6とICMPv6ヘッダーの構造体
      定義を含み、すべては定数に関連します(例えば、次のヘッダーフィー
      ルド値)。

   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.
   2. IPv6生ソケットの基本的な意味の定義。例えば、生ICMPv4ソ
      ケットがアプリケーションにICMPv4ヘッダチェックサムを計算し
      て登録するように要求します。けれどもIPv6とではこれは、ソース
      アドレスがICMPv6がチェックサム計算のために使う擬似ヘッダの
      一部なので、アプリケーションにソースアドレス選択を要求するでしょ
      う。生ICMPv6ソケットでカーネルが常にICMPヘッダチェック
      サムを計算し登録することが定義されるべきです。

   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.
   3. パケット情報:パケット毎に、アプリケーションが受信インターフェー
      ス、宛先アドレス、受信ホップ限界を得る方法。この能力を必要とする
      アプリケーションのクラスがあり、テクニックはポータブルであるべき
      です。

   4. Access to the optional Routing header, Hop-by-Hop options, and
      Destination options extension headers.
   4. 任意設定のルーティングヘッダとホップ毎オプションと宛先オプションの
      拡張ヘッダへのアクセス。

   5. Additional features required for improved IPv6 application
      portability.
   5. 改善されたIPv6アプリケーションポータビリティに必要な追加機能。

   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.
   拡張ヘッダ(ルーティングヘッダとホップ毎オプションと宛先オプション)
   へのアクセスに加えてパケット情報は、1990年に4.3BSDレノソケット
   APIで加えられた「補助的なデータ」フィールドを使って指定します。理
   由はこれらの補助的なデータフィールドがPosix標準[POSIX]の一部で、たい
   ていのベンダーが採用するべきであるからです。

   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).
   この文書のデータタイプはPosixフォーマットに従います:intN_tが正確にN
   ビットの符号付整数を意味し(例えば、int16_t )、uintN_tが正確にNビッ
   トの符号なしの整数を意味します(例えば、 uint32_t )。

   Note that we use the (unofficial) terminology ICMPv4, IGMPv4, and
   ARPv4 to avoid any confusion with the newer ICMPv6 protocol.
   我々が新しいICMPv6プロトコルでの混乱を避けるために(非公式な)
   用語ICMPv4とIGMPv4とARPv4を使うことを注意を払ってく
   ださい。

2.  Common Structures and Definitions
2.  共通の構造体と定義

   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.
   多くの高等アプリケーションがIPv6ヘッダを調べ、ICMPv6ヘッダ
   の様々なフィールドを調べ、設定します。これらのプロトコルヘッダーの共
   通の構造と構造体のメンバーの共通定数の定義が必要です。

   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>.
   2つの新しいヘッダファイルが定義されます:<netinet/ip6.h>と
   <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
2.1.  ip6_hdr構造体

   The following structure is defined as a result of including
   <netinet/ip6.h>.  Note that this is a new header.
   <netinet/ip6.h>に次の構造体が定義されます。これが新しいヘッダである
   ことに注意してください。

      struct ip6_hdr {
        union {
          struct ip6_hdrctl {
            uint32_t ip6_un1_flow; /* 4 bits version, 8 bits TC, 20 bits
                                      flow-ID */
                                   /* 4ビットのバージョン、8ビットの
                                      TC,20ビットのフロー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 */
                                   /* 4ビットバージョン、上位4ビット
                                      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
2.1.1.  IPv6次ヘッダ値

   IPv6 defines many new values for the Next Header field.  The
   following constants are defined as a result of including
   <netinet/in.h>.
   IPv6は次ヘッダーフィールドの多くの新しい値を定義します。
   <netinet/in.h>に以下の定数が定義されます。

      #define IPPROTO_HOPOPTS   0   /* IPv6 Hop-by-Hop options */
                                    /* IPv6ホップ毎オプション */
      #define IPPROTO_IPV6     41   /* IPv6 header */
                                    /* IPv6ヘッダ */
      #define IPPROTO_ROUTING  43   /* IPv6 Routing header */
                                    /* IPv6ルーチングヘッダ */
      #define IPPROTO_FRAGMENT 44   /* IPv6 fragment header */
                                    /* IPv6分割ヘッダ */
      #define IPPROTO_ESP      50   /* encapsulating security payload */
                                    /* カプセル化セキュリティペイロード */
      #define IPPROTO_AH       51   /* authentication header */
                                    /* 認証ヘッダ */
      #define IPPROTO_ICMPV6   58   /* ICMPv6 */
                                    /* ICMPv6 */
      #define IPPROTO_NONE     59   /* IPv6 no next header */
                                    /* IPv6次ヘッダなし */
      #define IPPROTO_DSTOPTS  60   /* IPv6 Destination options */
                                    /* IPv6宛先オプション */

   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.
   バークレーIPv4実装が同じくIPPROTO_IPを0と定義します。IPPROTO_IP
   がIPv4ソケットでだけ使われ、IPPROTO_HOPOPTSがIPv6ソケットでだ
   け使われるので、これは問題でありません。

2.1.2.  IPv6 Extension Headers
2.1.2.  IPv6拡張ヘッダ

   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>.
   6つの拡張ヘッダがIPv6のために定義されます。ここでこの文書の範囲
   外である認証ヘッダと暗号化セキュリティペイロードを除く全ての構造体を
   定義します。<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 */
                                  /* 8オクテット単位の長さ */
          /* 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 */
                                  /* 8オクテット単位の長さ */
          /* followed by options */
          /* オプションが続く */
      };

      /* Routing header */
      /* ルーチングヘッダ */
      struct ip6_rthdr {
        uint8_t  ip6r_nxt;        /* next header */
                                  /* 次ヘッダ */
        uint8_t  ip6r_len;        /* length in units of 8 octets */
                                  /* 8オクテット単位の長さ */
        uint8_t  ip6r_type;       /* routing type */
                                  /* ルーチングタイプ */
        uint8_t  ip6r_segleft;    /* segments left */
                                  /* 残りのセグメント */
          /* followed by routing type specific data */
          /* ルーチングタイプ特有データが続く */
      };

      /* Type 0 Routing header */
      /* タイプ0ルーチングヘッダ */
      struct ip6_rthdr0 {
        uint8_t  ip6r0_nxt;       /* next header */
                                  /* 次ヘッダ */
        uint8_t  ip6r0_len;       /* length in units of 8 octets */
                                  /* 8オクテット単位の長さ */
        uint8_t  ip6r0_type;      /* always zero */
                                  /* 常に0 */
        uint8_t  ip6r0_segleft;   /* segments left */
                                  /* 残りのセグメント */
        uint32_t ip6r0_reserved;  /* reserved field */
                                  /* 予約フィールド */
          /* followed by up to 127 struct in6_addr */
          /* 最大127の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 */
                                          /* ip6f_offlgのマスク */
      #define IP6F_RESERVED_MASK  0x0006  /* reserved bits in
                                             ip6f_offlg */
                                          /* 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 */
                                          /* ip6f_offlgのマスク */
      #define IP6F_RESERVED_MASK  0x0600  /* reserved bits in
                                             ip6f_offlg */
                                          /* ip6f_offlgの予約ビット */
      #define IP6F_MORE_FRAG      0x0100  /* more-fragments flag */
                                       /* 後続フラグ */
      #endif

2.1.3.  IPv6 Options
2.1.3.  IPv6オプション

   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のために定義されます、そして我々はそれ
   らのいくつかのために下記の構造体とマクロ定義を定義します。以下の構造
   体が<netinet/ip6.h>で定義されます。

      /* IPv6 options */
      /* IPv6オプション */
      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.
       * オプションタイプの上位3ビットは、未知のオプションを処理する時、
       * オプション内容が途中で変化するか否かの動作を定義します。
       */
      #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 */
      /* NSAPアドレスオプション */
      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 */
          /* NSAPソースアドレスが続く */
          /* 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
2.2.  icmp6_hdr構造体

   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.
   ICMPv6ヘッダはPingとTracerouteとルータ探索デーモンと近隣探索デー
   モンを含む多数のIPv6アプリケーションによって必要とされます。構造
   体が<netinet/icmp6.h>で定義されます。これが新しいヘッダであることに注
   意してください。

      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
2.2.1.  ICMPv6タイプとコード値

   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>.
   ICMPv6の共通構造体に加えて、ICMPv6タイプとコードフィー
   ルドの共通定義が必要です。次の定数は<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 */
                                              /* 転送中にホップ限界が0になった */
      #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 */
                                              /* 認識できないIPv6オプション */

   The five ICMP message types defined by IPv6 neighbor discovery (133-
   137) are defined in the next section.
   IPv6近隣探索(133−137)で定義された5つのICMPメッセー
   ジタイプは次の章で定義されます。

2.2.2.  ICMPv6 Neighbor Discovery Definitions
2.2.2.  ICMPv6近隣探索タイプとコード値

   The following structures and definitions are defined as a result of
   including <netinet/icmp6.h>.
   次に構造体と定義は<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 */
                                  /* 8オクテット単位 */
          /* 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 */
          /* IPヘッダとデータが続く */
      };

      struct nd_opt_mtu {            /* MTU option */
                                     /* MTUオプション */
        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.
   我々はnd_na_flags_reservedフラグがip6f_offlgに関して我々が論じたのと
   同じバイト順の問題を持つことを指摘します。

2.2.3.  Multicast Listener Discovery Definitions
2.2.3.  マルチキャスト受信者探索定義

   The following structures and definitions are defined as a result of
   including <netinet/icmp6.h>.
   次に構造体と定義は<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
2.2.4.  ICMPv6ルータリナンバリング定義

   The following structures and definitions are defined as a result of
   including <netinet/icmp6.h>.
   次に構造体と定義は<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 */
      /* PCOコード値 */
      #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
2.3.  アドレステストマクロ

   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>.
   基本的API([RFC-3493])はある特定の性質についてIPv6アドレスをテ
   ストするマクロを定義します。このAPIはアドレステストマクロを追加し
   て定義を拡張します、定義は<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
2.4.  プロトコルファイル

   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
   多くのホストが種々なIPプロトコルの名前とプロトコル番号を含むファイ
   ル/etc/protocolsを供給します(例えばICMPで1である、IPv4ヘッ
   ダのプロトコルフィールドのプロトコル値)。あるプログラムがsocket()関
   数の3番目の引数のプロトコル値を得るためにgetprotobyname()関数を呼び
   ます。例えば、Pingプログラムは形式のコードを含んでいます。

      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.
   getprotoXXX()関数を呼び出すアプリケーションのポータビリティを供給する
   ため新しいIPv6プロトコルのためにこのファイルで共通名が必要です。

   We define the following protocol names with the values shown.  These
   are taken under http://www.iana.org/numbers.html.
   我々は次のプロトコル名と値を定義します。これらは
   http://www.iana.org/numbers.htmlから引用されます。

      hopopt           0    # hop-by-hop options for ipv6
                            # IPv6ホップ毎オプション
      ipv6            41    # ipv6
                            # IPv6ヘッダ
      ipv6-route      43    # routing header for ipv6
                            # IPv6ルーチングヘッダ
      ipv6-frag       44    # fragment header for ipv6
                            # IPv6分割ヘッダ
      esp             50    # encapsulating security payload for ipv6
                            # カプセル化セキュリティペイロード
      ah              51    # authentication header for ipv6
                            # 認証ヘッダ
      ipv6-icmp       58    # icmp for ipv6
                            # ICMPv6
      ipv6-nonxt      59    # no next header for ipv6
                            # IPv6次ヘッダなし
      ipv6-opts       60    # destination options for ipv6
                            # IPv6宛先オプション

3.  IPv6 Raw Sockets
3.  IPv6生ソケット

   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).
   生ソケットがトランスポートレイヤ(TCPあるいはUDP)を回避します。
   IPv4で生ソケットがICMPv4やIGMPv4にアクセスして、カー
   ネルが処理しないプロトコルフィールドを含むIPv4データグラムを読み
   書きするために使われます。後者の例が、IPv4プロトコルフィールド8
   9を使う、OSPFルーティングデーモンです。IPv6で生ソケットがカー
   ネルが処理しない次のヘッダーフィールドを含むIPv6データグラムを読
   み書きするためにICMPv6で使われるでしょう。後者の例がIPv6の
   OSPFとRSVP(プロトコルフィールド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.
   すべての生ソケットにから送るデータはネットワークバイト順で、生ソケッ
   トから受け取ったすべてのデータはネットワークバイト順でしょう。これは
   IPv4生ソケットがバイト順を指定せず、あるIPヘッダフィールドにホ
   ストバイト順を使うのと異なっています。

   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.
   もう1つのIPv4生ソケットとの違いは、完全なパケット(すなわち、拡
   張子ヘッダを持っているIPv6パケット)がIPv6生ソケットAPIを
   使って送受信できないということです。その代わりに、6章で記述されるよ
   うに、補助的なデータオブジェクトが拡張子ヘッダを転送するために使われ
   ます。もしアプリケーションが完全なIPv6パケットにアクセスを必要と
   したなら、何か他の、データリンクインタフェースBPFやDLPIのよう
   な、テクニックが使われなくてはなりません。

   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.
   フローラベルを除き、アプリケーションが変えることを望むすべての(バー
   ジョン番号以外の全ての)IPv6ヘッダフィールドは出力アプリケーショ
   ンが補助的なデータやソケットオプションを使って修正できます。フローラ
   ベルを除く(バージョン番号と次ヘッダフィールド以外の)すべての受信I
   Pv6ヘッダフィールドとアプリケーションが望むすべての拡張子ヘッダの
   フィールドは入力の補助的なデータとしてアプリケーションに利用可能です。
   そのためIPv4のIP_HDRINCLソケットオプションに類似しているソケット
   オプションが必要なく、受信アプリケーションはペイロード、すなわち、I
   Pv6ヘッダとすべての拡張子ヘッダの後のデータ、を受け取るでしょう。

   This API does not define access to the flow label field, because
   today there is no standard usage of the field.
   このAPIはフローラベルフィールドへのアクセスを定義しません、なぜな
   ら現時点で、フィールドの標準使用法がありませんから。

   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.
   生ソケットに書き込む時、もしその大きさがパスMTUを超えるなら、カー
   ネルは自動的にパケットを分解し、必要な分割ヘッダーを挿入するでしょう。
   カーネルは受信した破片を組み立てるので、生ソケットの読み込みはヘッダ
   分解が見えません。

   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.
   我々が「ICMPv6生ソケット」と言う時、我々は3つの引数AF_INET6と
   SOCK_RAWと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).
   たいていのIPv4実装は、値が255であるIPPROTO_RAWをsocket()の第3
   引数として生成したソケットを、アプリケーションがIPv4ヘッダを含む
   完全なパケットを送ることを意味するように、特別に扱います。(メモ:こ
   の機能はヴァン・ヤコブソンによって1988年にIPv4に加えられ、
   IP_HDRINCLソケットオプションが追加される前に完全なIPヘッダをアプリ
   ケーションが渡すことを許しました)。我々はIPPROTO_RAWがIPv6生ソ
   ケットで特別な意味を持っていないことを指摘します(そしてIANAは現
   在、次のヘッダフィールドの値255を保留します)。

3.1.  Checksums
3.1.  チェックサム

   The kernel will calculate and insert the ICMPv6 checksum for ICMPv6
   raw sockets, since this checksum is mandatory.
   ICMPv6チェックサムは必須なので、カーネルはICMPv6生ソケッ
   トでICMPv6チェックサムを計算し自動挿入します。

   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.
   他の生IPv6ソケット(3番目の引数をIPPROTO_ICMPV6以外に設定して生
   成した生IPv6ソケット)で、(1)出力チェックサムの計算と設定、
   (2)入力で受信チェックサムの検証とチェックサムにエラーがある場合の
   廃棄のためには、アプリケーションは新しいIPV6_CHECKSUMソケットオプショ
   ンを設定しなければなりません。このオプションはアプリケーションが送信
   パケット上でソースアドレス選択を行わなければならないのを阻止します。
   チェックサムは[RFC-2460]の8.1章で定義されたIPv6疑似ヘッダを含む
   でしょう。この新しいソケットオプションはユーザデータ内でチェックサム
   が位置している場所の整数オフセットを指定します。

      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.
   デフォルトで、このソケットオプションは動作しません。同じくオフセット
   を−1に設定するとオプションは動作しません。動作しないとは(1)カー
   ネルが出力パケットのチェックサムの計算も設定もしない(2)カーネルは
   受信パケットのチェックサムを検証しない、事を意味します。

   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.
   このオプションはチェックサムアルゴリズムとして、16ビットの1の補数
   の合計の1の補数の使用と、チェックサムフィールドが16ビットの境界上
   に整列する事を仮定します。そのため正の奇数値をオフセットとして指定す
   ることは無効で、setsockopt()がこのようなオフセットの計算で失敗するで
   しょう。

   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.
   IPV6_CHECKSUMをICMPv6ソケットに設定する試みが失敗するでしょう。
   同じく、非生IPv6ソケットに対してIPV6_CHECKSUMを設定するか得る試み
   が失敗するでしょう。

   (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.)
   (ノート:ICMPv6ソケットでチェックサムが常にカーネルによって計
   算されるので、アプリケーションはこのAPIを使って(多分テストの目的
   で)正しくないチェックサムのICMPv6パケットを生成することが可能
   ではありません)。

3.2.  ICMPv6 Type Filtering
3.2.  ICMPv6タイプフィルタリング

   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.
   ICMPv4生ソケットがカーネルの受信したほとんどのICMPv4メッ
   セージを受け取ります。(「全部」ではなく「大部分」と言っているのは、
   バークレー由来のカーネルがエコー要求やタイムスタンプ要求やアドレスマ
   スク要求を生ソケットで渡さないからです。その代わりにこれらの3つのメッ
   セージはカーネルが完全に処理します。)しかしICMPv6はICMPv
   4の上位機能で、IGMPv4とARPv4の機能を含んでいます。これは
   ICMPv6生ソケットが潜在的にICMPv4生ソケットで受信するより
   はるかに多くのメッセージを受信できることを意味します:ICMPv4に
   類似しているICMPメッセージ、近隣要請や近隣広告、3つのマルチキャ
   スト受信者探索メッセージ。

   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.
   たいていのICMPv6生ソケットを使っているアプリケーションがICM
   Pv6メッセージタイプの一部だけを気にします。カーネルからユーザーへ
   無関係のICMPv6メッセージの転送は大きなコストがかかります。それ
   故にこのAPIはICMPv6タイプフィールドによってICMPv6メッ
   セージをフィルターする方法を含みます。

   Each ICMPv6 raw socket has an associated filter whose datatype is
   defined as
   ICMPv6生ソケットが以下のデータタイプの関連づけフィルターを持っ
   ています。

      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>.
   この構造体とさらにマクロと変数がこの章の後で定義され<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.
   現在のフィルターの取得と設定は、IPPROTO_ICMPV6レベルでオプション名を
   ICMP6_FILTERにしてgetsockopt()とsetsockopt()を使います。

   Six macros operate on an icmp6_filter structure:
   6つのマクロがicmp6_filter構造体を操作します:

      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.
   最後の4つのマクロの最初の引数(整数)はICMPv6メッセージタイプ
   で、0以上と255以下です。すべての6つのマクロへのポインタ引数は、
   最初の4つのマクロでは修正の、最後の2つのマクロでは調査のフィルタへ
   のポインタです。

   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.
   最初の2つのマクロSETPASSALLとSETBLOCKALLはすべてのICMPv6メッ
   セージがアプリケーションに渡されるか、すべてのICMPv6メッセージ
   がアプリケーションに渡されないかを明示します。

   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).
   次の2つのマクロSETPASSとSETBLOCKは所定のICMPv6タイプメッセージ
   がアプリケーションに渡されるか渡されない(ふさがれる)ことを明示しま
   す。

   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.
   最終の2つのマクロWILLPASSとWILLBLOCKは2番目の引数で示したフィルター
   で指定されたメッセージタイプがアプリケーションに渡されるかどうかによっ
   て真か偽を返します。

   When an ICMPv6 raw socket is created, it will by default pass all
   ICMPv6 message types to the application.
   ICMPv6生ソケットが作られる時、デフォルトでアプリケーションにす
   べてのICMPv6メッセージタイプを渡すでしょう。

   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().
   フィルタ構造体が宣言され、次にすべてのメッセージタイプを阻止する様に
   初期化されます。フィルタ構造体はルータ広告メッセージをアプリケーショ
   ンに渡すため変更され、フィルタは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.
   インストールするフィルタをクリアするために、アプリケーションは長さゼ
   ロのICMP6_FILTERでsetsockoptを実行できます。フィルタがインストールさ
   れなかった時、getsockopt()はカーネルデフォルトフィルタを返すでしょう。

   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.
   icmp6_filter構造体はがソケットAPIのselect()関数で使うfd_setデータ
   タイプに類似しています。icmp6_filter構造体は不透明なデータタイプで、
   アプリケーションはどのように実装されるか気にするべきではありません。
   このデータタイプを使うアプリケーションはこのタイプの変数を割り当て、
   この変数へのポインタをgetsockopt()やsetsockopt()に渡し、このタイプの
   変数の操作に今定義した4つのマクロを使用します。

   Nevertheless, it is worth showing a simple implementation of this
   datatype and the six macros.
   にもかかわらず、このデータタイプの単純な実装と6つのマクロを示す値が
   あります。

      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.)
   (ノート:これらのサンプル定義は実装が変えることを望むかもしれない2
   つの限界を持ちます。最初の4つのマクロは最初の引数を2回評価します。
   2番目の2つのマクロはmemset()関数のために<string.h>ヘッダのインクルー
   ドを必要とします。)

3.3.  ICMPv6 Verification of Received Packets
3.3.  受信パケットのICMPv6検証

   The protocol stack will verify the ICMPv6 checksum and discard any
   packets with invalid checksums.
   プロトコルスタックはICMPv6チェックサムを検証し、無効なチェック
   サムのパケットを捨てるでしょう。

   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.
   実装がICMPv6メッセージ内容の追加の検証を実行して、そして誤りパ
   ケットを捨てるかもしれません。しかしながら、移植可能なアプリケーショ
   ンはこのような検証が行われたと想定してはなりません。

   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).
   もしICMPタイプをプロトコルスタックが知らないなら、プロトコルスタッ
   クは自動的にパケットを捨てるべきではありません。受信ICMPパケット
   の拡張性のためにどんな(情報やエラー)タイプでも(タイプ値とチェック
   サム検査のICMP6_FILTERフィルタの適用をして)アプリケーションに渡され
   なくてはなりません。

4.  Access to IPv6 and Extension Headers
4.  IPv6と拡張ヘッダのアクセス

   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:
   アプリケーションが、IPv6ヘッダと拡張ヘッダの内容を受け取ることが
   可能なのと同様に、送信する時にIPv6ヘッダと拡張ヘッダを制御可能で
   ある必要があります。これはsetsockoptと補助的なデータの両方で使われる
   ソケットオプションタイプを定義することによってできます。補助的なデー
   タが付録Aで論じられます。次の任意設定の情報がアプリケーションとカー
   ネルの間で交換できます:

   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:
   最初に、UDPあるいは生ソケット上で(設定だけが可能な次の転送先アド
   レス以外の)このオプション情報を受取りためには、アプリケーションは対
   応するフラグをオンにするためにsetsockopt()を呼ばなくてはなりません:

      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.
   これらのオプションのいずれかが使用可能である時、対応するデータは、
   1つ以上の補助的なデータオブジェクトとして、 recvmsg()の制御情報とし
   て返されます。

   This document does not define how to receive the optional information
   on a TCP socket.  See Section 4.1 for more details.
   この文書はどのようにTCPソケットのオプション情報を受け取るべきか定
   義しません。詳細は4.1章を見てください。

   Two different mechanisms exist for sending this optional information:
   このオプション情報を送ることに対し、2つの異なるメカニズムが存在します:

   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.
   1. ソケットのオプション内容を指定するためにsetsockoptを使います。これ
      らは、新しいsetsockoptがされるかオプションが補助的なデータを使って
      上書きされるまで、ソケットの上のすべての伝達されるパケットに影響を
      与えるので、既知の「付随」オプションです。

   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.
   2. ひとつのデータグラムのオプション内容を指定する補助的なデータを使い
      ます。これはただTCPソケットではなく、データグラムと生ソケットに
      だけ当てはります。

   The three socket option parameters and the three cmsghdr fields that
   describe the options/ancillary data objects are summarized as:
   オプション/補助的なデータオブジェクトを記述する3つのソケットオプショ
   ンパラメータと3つのcmsghdrフィールドの要約:

      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)
   (メモ:IPV6_HOPLIMITが補助的なデータ項目のみに用いることができます)。

   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>.
   これらすべてのオプションは6章と7章と8章と9章で詳細で記述されます。
   IPV6_から始まっているすべての定数は<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").
   ノート:我々は意図的に、getsockopt()とsetsockopt()の("level"と呼ばれ
   る)2番目の引数に使うcmsg_levelメンバと、getsockopt()とsetsockopt()
   の("option name"と呼ばれる)3番目の引数に使うcmsg_typeメンバで、に
   同じ定数を使います。

   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:
   上記のオプションのためにgetsockopt()を実行すると付随オプション値、す
   なわちsetsockopt()で設定した値を返すでしょう。もし付随オプション値が
   なければ、getsockopt()が次の値を返すでしょう:

   -  For the IPV6_PKTINFO option, it will return an in6_pktinfo
      structure with ipi6_addr being in6addr_any and ipi6_ifindex being
      zero.
   -  IPV6_PKTINFOオプションに対し、in6addr_anyとipi6_ifindexがゼロであ
      るin6_pktinfo構造体を返すでしょう。

   -  For the IPV6_TCLASS option, it will return the kernel default
      value.
   -  IPV6_TCLASSオプションに対し、カーネルデフォルト値を返すでしょう。

   -  For other options, it will indicate the lack of the option value
      with optlen being zero.
   -  他のオプションに対し、optlenがゼロの、オプション値なしを示すでしょ
      う。

   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.
   これらの機能へのAPIが7章と10章で定義するinet6_rth_XXX()と
   inet6_opt_XXX()関数の設定を通しているので、アプリケーションは明示的に
   ルーティングヘッダとホップ毎オプションヘッダと宛先オプションヘッダの
   データ構造にアクセスする必要がありません。これらの関数は、アプリケー
   ションが拡張ヘッダフォーマットの詳細な細部を知るように要求しないよう
   に、これらの機能へのインタフェースを単純化します。

   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.
   拡張ヘッダを指定する時、このAPIは[RFC-2460]で記述されるように、ヘッ
   ダ順序とそれぞれのヘッダの発生数を想定します。順序の問題のより多くの
   細部が12章で論じられるでしょう。

4.1.  TCP Implications
4.1.  TCPとの関係

   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.
   送信オペレーションとTCPパケットの伝達に1対1の対応がないので、T
   CPで上記のオプションを伝達するための補助的なデータを使うことは可能
   ではありません。その代わりにアプリケーションは付随オプションを明示す
   るためにsetsockoptを使うことができます。アプリケーションが上記のオプ
   ションを指定するためにsetsockoptを使う時、TCPがパケット送信に新し
   い情報を使い始めると思われます。しかしながら、TCPは古い付随オプショ
   ンが有効なときに送ったパケットを再送時に、新しい情報を使っても使わな
   くてもよいです。

   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.
   受信したTCPパケットと受信オペレーションの間の対応がないので、(拡
   張ヘッダのような)受信情報をTCPアプリケーションがどのように受けと
   ることができるかは不明確です。特に、受信情報は、UDPや生ソケットと
   違い、アクセス制御の目的に使うことができません。

   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.
   従ってこの仕様書はどのようにTCPソケットで受信情報を得るべきか定義
   しません。TCPソケット上のIPV6_RECVxxxオプションの結果は同様に不確
   定です。

4.2.  UDP and Raw Socket Implications
4.2.  UDPと生ソケット意味

   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.
   UDPと生ソケットの受信動作は非常に簡単です。アプリケーションが
   IPV6_RECVxxxソケットオプションを使用可能にした後、アプリケーションは
   すべてのrecvmsg()呼び出しで求められた情報を含む補助的なデータ項目を受
   け取るでしょう。しかし、もし情報がパケットで存在していないなら、補助
   的なデータ項目は含まれないでしょう。例えば、もしアプリケーションが
   IPV6_RECVRTHDRを使用可能にし、そして受信データグラムがルーティングヘッ
   ダを含んでいないなら、補助的なデータ項目のIPV6_RECVRTHDRがないでしょ
   う。ソケット実装でのバッファのため、IPV6_RECVxxx オプションが使用可能
   でパケットが補助的なデータ情報を持たない時、いくつかのパケットが待ち
   行列に入れられるかもしれません。

   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.
   補助的なデータ項目がsendmsg()呼出で指定される時、(もし前に指定された
   なら)項目は同じ名前の既存の付随オプションを上書きするでしょう。例え
   ば、もしアプリケーションがIPV6_RTHDRに付随オプションを使い、そして後
   に補助的なデータとしてIPV6_RTHDRを渡すなら、これはIPV6_RTHDR付随オプ
   ションより優先するでしょう、そして出パケットのルーティングヘッダは、
   付随オプションからではなく、補助的なデータ項目からのでしょう。しかし
   ながら、他のIPV6_RTHDRでない付随オプションは補助的なデータ項目
   IPV6_RTHDRの影響を受けない事に注意してください;上書きメカニズムがた
   だ同じタイプの付随オプションと補助的なデータ項目に対してだけ働きます。

   (Note: the overriding rule is different from the one in RFC 2292.  In
   RFC 2292, 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 RFC 2292, including ancillary-
   only one.  Thus, it should be natural for application programmers to
   separate the overriding rule as well.)
   (ノート:上書き規則はRFC2292と異なっています。RFC2292では、
   補助的なデータ項目がすべての前に定義された付随オプションを上書きしました。
   付随オプションがただひとつのソケットオプションと明示されるので、これは合
   理的でした。しかし、このAPIで、それぞれのオプションがひとつの付随オプ
   ションとして明示できるように、切り離されます。さらに、RFC2292で補
   助的なデータが1つなのと比べて、より多くの補助的なデータ項目と付随オプショ
   ンがあります。それで、アプリケーションプログラマーが上書き規則を切り離す
   ことは自然であるべきです。)

   An application can also temporarily disable a particular sticky
   option by specifying a corresponding ancillary data item that could
   disable the sticky option when being used as an argument for a socket
   option.  For example, if the application has set IPV6_HOPOPTS as a
   sticky option and later passes IPV6_HOPOPTS with a zero length as an
   ancillary data item, the packet will not have a Hop-by-Hop options
   header.
   付随オプションを止める対応する補助的なデータ項目をソケットオプション
   の引数として指定することによって、アプリケーションが一時的に特定の付
   随オプションを止めることができます。例えば、もしアプリケーションが付
   随オプションとしてIPV6_HOPOPTSを設定し、そして補助的なデータ項目とし
   て長さゼロのIPV6_HOPOPTSを渡すなら、パケットはホップ毎オプションヘッ
   ダを持たないでしょう。

5.  Extensions to Socket Ancillary Data
5.  ソケット補助的なデータへの拡張

   This specification uses ancillary data as defined in Posix with some
   compatible extensions, which are described in the following
   subsections.  Section 20 will provide a detailed overview of
   ancillary data and related structures and macros, including the
   extensions.
   この仕様書は、ある互換性がある拡張でPosixで定義される補助的なデー
   タを使い、そして以下に記述されます。20章が補助的なデータと関連した
   構造体とマクロの、拡張を含む詳細な概観を供給するでしょう。

5.1.  CMSG_NXTHDR
5.1.  CMSG_NXTHDR

      struct cmsghdr *CMSG_NXTHDR(const struct msghdr *mhdr,
                                  const struct cmsghdr *cmsg);

   CMSG_NXTHDR() returns a pointer to the cmsghdr structure describing
   the next ancillary data object.  Mhdr is a pointer to a msghdr
   structure and cmsg is a pointer to a cmsghdr structure.  If there is
   not another ancillary data object, the return value is NULL.
   CMSG_NXTHDR()は次の補助的なデータオブジェクトを記述しているcmsghdr構
   造体へのポインタを返します。Mhdrはmsghdr構造体へのポインタで、cmsgは
   cmsghdr構造体へのポインタです。もし他の補助的なデータオブジェクトがな
   いなら、返りの値はNULLです。

   The following behavior of this macro is new to this API: if the value
   of the cmsg pointer is NULL, a pointer to the cmsghdr structure
   describing the first ancillary data object is returned.  That is,
   CMSG_NXTHDR(mhdr, NULL) is equivalent to CMSG_FIRSTHDR(mhdr).  If
   there are no ancillary data objects, the return value is NULL.
   次のこのマクロの動作はこのAPIで新規です:もしcmsgポインタ値がNULL
   なら、最初の補助的なデータオブジェクトを記述しているcmsghdr構造体への
   ポインタが返されます。すなわち、CMSG_NXTHDR(mhdr, NULL)は
   CMSG_FIRSTHDR(mhdr)と等価です。もし補助的なデータオブジェクトがないな
   ら、返りの値はNULLです。

5.2.  CMSG_SPACE
5.2.  CMSG_SPACE

   socklen_t CMSG_SPACE(socklen_t length);

   This macro is new with this API.  Given the length of an ancillary
   data object, CMSG_SPACE() returns an upper bound on the space
   required by the object and its cmsghdr structure, including any
   padding needed to satisfy alignment requirements.  This macro can be
   used, for example, when allocating space dynamically for the
   ancillary data.  This macro should not be used to initialize the
   cmsg_len member of a cmsghdr structure; instead use the CMSG_LEN()
   macro.
   このマクロはこのAPIで新規です。補助的なデータオブジェクトの長さが
   与えられているとして、CMSG_SPACE()は、整列条件を満たすパディングを含
   め、オブジェクトとそのcmsghdr構造体に必要なスペースの上限を返します。
   このマクロは、例えば、補助的なデータのために動的にスペースを割り当て
   るために使うことができます。このマクロはcmsghdr構造体のcmsg_lenメン
   バーを初期化するために使われるべきでありません;代わりにCMSG_LEN()マ
   クロを使います。

5.3.  CMSG_LEN
5.3.  CMSG_LEN

   socklen_t CMSG_LEN(socklen_t length);

   This macro is new with this API.  Given the length of an ancillary
   data object, CMSG_LEN() returns the value to store in the cmsg_len
   member of the cmsghdr structure, taking into account any padding
   needed to satisfy alignment requirements.
   このマクロはこのAPIで新規です。補助的なデータオブジェクトの長さが
   与えられているとしてCMSG_LEN()は、整列条件を満たすために必要なパディ
   ングも考慮に入れてcmsghdr構造体のcmsg_lenメンバーに設定すべき値を返し
   ます。

   Note the difference between CMSG_SPACE() and CMSG_LEN(), shown also
   in the figure in Section 20.2: the former accounts for any required
   padding at the end of the ancillary data object and the latter is the
   actual length to store in the cmsg_len member of the ancillary data
   object.
   CMSG_SPACE()とCMSG_LEN()の違いについて20.2章の図を見てください:
   前者の合計は補助的なデータオブジェクトの終わりにパディングが必要で、
   後者は補助的なデータオブジェクトのcmsg_lenメンバーに設定すべき実際の
   長さです。

6.  Packet Information
6.  パケット情報

   There are five pieces of information that an application can specify
   for an outgoing packet using ancillary data:
   補助的なデータを使って、出パケットのためにアプリケーションが指定でき
   る5つの情報があります:

      1.  the source IPv6 address,
          ソースIPv6アドレス、
      2.  the outgoing interface index,
          出インタフェースインデックス、
      3.  the outgoing hop limit,
          出ホップ限界、
      4.  the next hop address, and
          次の転送先アドレス、
      5.  the outgoing traffic class value.
          出トラヒッククラス値

   Four similar pieces of information can be returned for a received
   packet as ancillary data:
   類似の4つの情報が補助的なデータとして受信パケットで返されることがで
   きます:

      1.  the destination IPv6 address,
          宛先IPv6アドレス、
      2.  the arriving interface index,
          到着インタフェースインデックス、
      3.  the arriving hop limit, and
          到着ホップ限界、
      4.  the arriving traffic class value.
          入トラヒッククラス値

   The first two pieces of information are contained in an in6_pktinfo
   structure that is set with setsockopt() or sent as ancillary data
   with sendmsg() and received as ancillary data with recvmsg().  This
   structure is defined as a result of including <netinet/in.h>.
   情報の最初の2つは、setsockopt()で設定されるか、sendmsg()で送信し
   recvmsg()で受信できる補助的なデータとして、in6_pktinfo構造体に含まれ
   ます。この構造体は<netinet/in.h>ヘッダで定義されます。

      struct in6_pktinfo {
        struct in6_addr ipi6_addr;    /* src/dst IPv6 address */
                                      /* ソース/宛先IPv6アドレス */
        unsigned int    ipi6_ifindex; /* send/recv interface index */
                                      /* 送信/受信インターフェースインデックス */
      };

   In the socket option and cmsghdr level will be IPPROTO_IPV6, the type
   will be IPV6_PKTINFO, and the first byte of the option value and
   cmsg_data[] will be the first byte of the in6_pktinfo structure.  An
   application can clear any sticky IPV6_PKTINFO option by doing a
   "regular" setsockopt with ipi6_addr being in6addr_any and
   ipi6_ifindex being zero.
   ソケットオプションとcmsghdrで、レベルはIPPROTO_IPV6で、タイプは
   IPV6_PKTINFOで、オプション値の最初のバイトとcmsg_data[]はin6_pktinfo
   構造体の最初のバイトであるでしょう。アプリケーションがipi6_addrが
   in6addr_anyで、ipi6_ifindexがゼロである「通常」のsetsockoptによって、
   付随IPV6_PKTINFOオプションをクリアすることができます。

   This information is returned as ancillary data by recvmsg() only if
   the application has enabled the IPV6_RECVPKTINFO socket option:
   この情報は、アプリケーションがIPV6_RECVPKTINFOソケットオプションを使
   用可能にした場合に限り、recvmsg()が補助的なデータとして返します:

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on));

   (Note: The hop limit is not contained in the in6_pktinfo structure
   for the following reason.  Some UDP servers want to respond to client
   requests by sending their reply out the same interface on which the
   request was received and with the source IPv6 address of the reply
   equal to the destination IPv6 address of the request.  To do this the
   application can enable just the IPV6_RECVPKTINFO socket option and
   then use the received control information from recvmsg() as the
   outgoing control information for sendmsg().  The application need not
   examine or modify the in6_pktinfo structure at all.  But if the hop
   limit were contained in this structure, the application would have to
   parse the received control information and change the hop limit
   member, since the received hop limit is not the desired value for an
   outgoing packet.)
   (ノート:ホップ限界は次の理由のためにin6_pktinfo構造体に含まれません。
   あるUDPサーバが要求を受信したのと同じインターフェースから、要求の
   宛先IPv6アドレスと等しいソースアドレスで、応答を送りたいと望みま
   す。これをするために、アプリケーションはIPV6_RECVPKTINFOソケットオプ
   ションを利用可能にし、次にrecvmsg()から受信した制御情報をsendmsg()の
   ための出制御情報として用いることができます。アプリケーションはまった
   くin6_pktinfo構造体を調査したり修正したりする必要がありません。けれど
   ももしホップ限界がこの構造体にあれば、アプリケーションは受信制御情報
   を解析し、受信ホップ限界が出パケットに望ましい値ではない場合、ホップ
   限界メンバーを変えなければならないでしょう。)

6.1.  Specifying/Receiving the Interface
6.1.  インタフェース指定/受信

   Interfaces on an IPv6 node are identified by a small positive
   integer, as described in Section 4 of [RFC-3493].  That document also
   describes a function to map an interface name to its interface index,
   a function to map an interface index to its interface name, and a
   function to return all the interface names and indexes.  Notice from
   this document that no interface is ever assigned an index of 0.
   IPv6ノードのインタフェースが[RFC-3493]の4章で記述されるように、
   小さい正の整数によって識別されます。その文書はインタフェース名をその
   インタフェースインデックスに変換する関数と、インタフェースインデック
   スをインタフェース名に変換する関数と、すべてのインタフェース名とイン
   デックスを返す関数を記述します。この文書からインタフェースにインデッ
   クス0が割り当てられないことに注意してください。

   When specifying the outgoing interface, if the ipi6_ifindex value is
   0, the kernel will choose the outgoing interface.
   出インタフェースを指定する時、もしipi6_ifindex値が0であるなら、カー
   ネルは出インタフェースを選択するでしょう。

   The ordering among various options that can specify the outgoing
   interface, including IPV6_PKTINFO, is defined in Section 6.7.
   出インタフェースを指定することができる種々なオプションの間の順序は、
   IPV6_PKTINFOを含めて、6.7章で定義されます。

   When the IPV6_RECVPKTINFO socket option is enabled, the received
   interface index is always returned as the ipi6_ifindex member of the
   in6_pktinfo structure.
   IPV6_RECVPKTINFOソケットオプションが使用可能である時、受信インタフェース
   インデックスは常にin6_pktinfo構造体のipi6_ifindexメンバーとして返さ
   れます。

6.2.  Specifying/Receiving Source/Destination Address
6.2.  ソース/宛先アドレスの指定/受信

   The source IPv6 address can be specified by calling bind() before
   each output operation, but supplying the source address together with
   the data requires less overhead (i.e., fewer system calls) and
   requires less state to be stored and protected in a multithreaded
   application.
   ソースIPv6アドレスは各出力オペレーション前にbind()を呼ぶことで指
   定できますが、データと共にソースアドレスを供給するのは必要なオーバー
   ヘッドが少なく(すなわち、システムコールが少ない)、マルチスレッドの
   アプリケーションで記憶と保護の必要な状態が少ないです。

   When specifying the source IPv6 address as ancillary data, if the
   ipi6_addr member of the in6_pktinfo structure is the unspecified
   address (IN6ADDR_ANY_INIT or in6addr_any), then (a) if an address is
   currently bound to the socket, it is used as the source address, or
   (b) if no address is currently bound to the socket, the kernel will
   choose the source address.  If the ipi6_addr member is not the
   unspecified address, but the socket has already bound a source
   address, then the ipi6_addr value overrides the already-bound source
   address for this output operation only.
   ソースIPv6アドレスを補助的なデータとして明示する時、もし
   in6_pktinfo構造体のipi6_addrメンバーが特定されていないアドレス
   (IN6ADDR_ANY_INITかin6addr_any)であるなら、(a)もしアドレスを現在の
   ソケットにバインドしていれば、それはソースアドレスとして使われ、(b)も
   しアドレスを現在ソケットにバインドしていないなら、カーネルはソースア
   ドレスを選択するでしょう。もしipi6_addrメンバーが特定されていないアド
   レスではないが、ソケットにすでにソースアドレスをバインドしているなら、
   ipi6_addr値はこの出力オペレーションのみで、すでにバインドされたソース
   アドレスを上書きします。

   The kernel must verify that the requested source address is indeed a
   unicast address assigned to the node.  When the address is a scoped
   one, there may be ambiguity about its scope zone.  This is
   particularly the case for link-local addresses.  In such a case, the
   kernel must first determine the appropriate scope zone based on the
   zone of the destination address or the outgoing interface (if known),
   then qualify the address.  This also means that it is not feasible to
   specify the source address for a non-binding socket by the
   IPV6_PKTINFO sticky option, unless the outgoing interface is also
   specified.  The application should simply use bind() for such
   purposes.
   カーネルは要求されたソースアドレスがノードに割り当てられたソースアド
   レスである事を確かめなければなりません。アドレスに範囲がある時、その
   範囲にあいまい性があるかもしれません。これは特にリンクローカルアドレ
   スの場合です。このような場合、カーネルは宛先アドレスあるいは出インタ
   フェース(もし既知なら)に基づいて最初に適切な範囲を決定して、それか
   らアドレスを修飾しなくてはなりません。これは同じく、外向的なインタ
   フェースが同じく指定されないなら、IPV6_PKTINFO付随オプションでバイン
   ドされていないソケットのソースアドレスを指定することが、実行可能では
   ないことを意味します。アプリケーションはこのような目的で単純にbind()
   を使うべきです。

   IPV6_PKTINFO can also be used as a sticky option for specifying the
   socket's default source address.  However, the ipi6_addr member must
   be the unspecified address for TCP sockets, because it is not
   possible to dynamically change the source address of a TCP
   connection.  When the IPV6_PKTINFO option is specified for a TCP
   socket with a non-unspecified address, the call will fail.  This
   restriction should be applied even before the socket binds a specific
   address.
   IPV6_PKTINFOが同じくソケットのデフォルトソースアドレスを指定するため
   付随オプションとして用いることができます。しかし、動的にTCP接続の
   ソースアドレスを変えることは可能ではないので、ipi6_addrメンバーはTC
   Pソケットで特定されていないアドレスに違いありません、。IPV6_PKTINFO
   オプションで特定のアドレスをTCPソケットに指定する時、呼び出しは失
   敗するでしょう。この制限は、ソケットが特定のアドレスをバインドする前
   でも、適用されるべきです。

   When the in6_pktinfo structure is returned as ancillary data by
   recvmsg(), the ipi6_addr member contains the destination IPv6 address
   from the received packet.
   recvmsg()が補助的なデータとしてin6_pktinfo構造体を返す時、ipi6_addr
   メンバーは受信パケットの宛先IPv6アドレスを含んでいます。

6.3.  Specifying/Receiving the Hop Limit
6.3.  ホップ限界の指定/受信

   The outgoing hop limit is normally specified with either the
   IPV6_UNICAST_HOPS socket option or the IPV6_MULTICAST_HOPS socket
   option, both of which are described in [RFC-3493].  Specifying the
   hop limit as ancillary data lets the application override either the
   kernel's default or a previously specified value, for either a
   unicast destination or a multicast destination, for a single output
   operation.  Returning the received hop limit is useful for IPv6
   applications that need to verify that the received hop limit is 255
   (e.g., that the packet has not been forwarded).
   出ホップ限界は通常、IPV6_UNICAST_HOPSソケットオプションか、
   IPV6_MULTICAST_HOPSソケットオプションで指定され、どちらも[RFC-3493]で
   指定されます。ホップ限界を補助的なデータとして明示することで、アプリ
   ケーションは、1回の出力オペレーションでの、ユニキャスト宛先かマルチ
   キャスト宛先での、カーネルのデフォルトか前に指定された値を上書きしま
   す。受信ホップ限界を返すことは、受信ホップ限界が255である(つまり
   パケットが転送されていない)ことを確かめる必要があるIPv6アプリケー
   ションのような、プログラムに役立ちます。

   The received hop limit is returned as ancillary data by recvmsg()
   only if the application has enabled the IPV6_RECVHOPLIMIT socket
   option:
   受信ホップ限界は、アプリケーションがIPV6_RECVHOPLIMITソケットオプショ
   ンを可能にした場合に限り、recvmsg()で補助的なデータとして返されます:

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on, sizeof(on));

   In the cmsghdr structure containing this ancillary data, the
   cmsg_level member will be IPPROTO_IPV6, the cmsg_type member will be
   IPV6_HOPLIMIT, and the first byte of cmsg_data[] will be the first
   byte of the integer hop limit.
   この補助的なデータを含むcmsghdr構造体で、cmsg_levelメンバーは
   IPPROTO_IPV6でしょうし、cmsg_typeメンバーはIPV6_HOPLIMITでしょうし、
   cmsg_data[]の最初のバイトは整数ホップ限界の最初のバイトでしょう。

   Nothing special need be done to specify the outgoing hop limit: just
   specify the control information as ancillary data for sendmsg().  As
   specified in [RFC-3493], the interpretation of the integer hop limit
   value is
   外向ホップ限界を指定するために特別なことは必要ありません:制御情報を
   sendmsg()の補助的なデータとして明示してください。[RFC-3493]で指定され
   るように、整数ホップ限界値の解釈は以下です。

      x < -1:        return an error of EINVAL
                     EINVALエラーを返す
      x == -1:       use kernel default
                     カーネルのデフォルトを使用
      0 <= x <= 255: use x
                     xを使用
      x >= 256:      return an error of EINVAL
                     EINVALエラーを返す

   This API defines IPV6_HOPLIMIT as an ancillary-only option, that is,
   the option name cannot be used as a socket option.  This is because
   [RFC-3493] has more fine-grained socket options; IPV6_UNICAST_HOPS
   and IPV6_MULTICAST_HOPS.
   このAPIはIPV6_HOPLIMITを補助的なデータのみのオプションと定義します、
   すなわち、オプション名はソケットオプションとして用いることができませ
   ん。これは[RFC-3493]がより細かいソケットオプション、IPV6_UNICAST_HOPS
   とIPV6_MULTICAST_HOPSを持っているからです。

6.4.  Specifying the Next Hop Address
6.4.  次の転送先アドレスの指定

   The IPV6_NEXTHOP ancillary data object specifies the next hop for the
   datagram as a socket address structure.  In the cmsghdr structure
   containing this ancillary data, the cmsg_level member will be
   IPPROTO_IPV6, the cmsg_type member will be IPV6_NEXTHOP, and the
   first byte of cmsg_data[] will be the first byte of the socket
   address structure.
   IPV6_NEXTHOP補助的なデータオブジェクトはデータグラムのための次の転送
   先をソケットアドレス構造として明示します。この補助的なデータを含んで
   いるcmsghdr構造体で、cmsg_levelメンバーはIPPROTO_IPV6でしょうし、
   cmsg_typeメンバーはIPV6_NEXTHOPでしょうし、cmsg_data[]の最初のバイト
   はソケットアドレス構造の最初のバイトでしょう。

   This is a privileged option.  (Note: It is implementation defined and
   beyond the scope of this document to define what "privileged" means.
   Unix systems use this term to mean the process must have an effective
   user ID of 0.)
   これは特権を与えられたオプションです。(ノート:「特権を与えられてい
   る」が何を意味するかの定義は、実装依存でこの文書の範囲を越えています。
   UNIXシステムは、プロセスが0の実効ユーザーIDを持っていなくては
   ならないことを意味するために、この用語を使います。)

   This API only defines the case where the socket address contains an
   IPv6 address (i.e., the sa_family member is AF_INET6).  And, in this
   case, the node identified by that address must be a neighbor of the
   sending host.  If that address equals the destination IPv6 address of
   the datagram, then this is equivalent to the existing SO_DONTROUTE
   socket option.
   このAPIはソケットアドレスがIPv6アドレスを含んでいる場合(すな
   わち、sa_familyメンバがAF_INET6である場合)を定義するだけです。そして、
   この場合、そのアドレスで指定されたノードは送信ホストの近隣に違いあり
   ません。もしそのアドレスがデータグラムの宛先IPv6アドレスと等しい
   なら、これは既存のSO_DONTROUTEソケットオプションと等しいです。

   This option does not have any meaning for multicast destinations.  In
   such a case, the specified next hop will be ignored.
   このオプションはマルチキャスト宛先では意味を持ちません。このような場
   合、指定された次の転送先は無視されるでしょう。

   When the outgoing interface is specified by IPV6_PKTINFO as well, the
   next hop specified by this option must be reachable via the specified
   interface.
   出インタフェースがIPV6_PKTINFOで指定される時、このオプションで指定さ
   れた次の転送先は指定されたインタフェースから到達可能に違いありません。

   In order to clear a sticky IPV6_NEXTHOP option the application must
   issue a setsockopt for IPV6_NEXTHOP with a zero length.
   付随IPV6_NEXTHOPオプションをクリアするために、アプリケーションは長さ
   ゼロでIPV6_NEXTHOPでsetsockoptを発行しなくてはなりません。

6.5.  Specifying/Receiving the Traffic Class value
6.5.  トラフィッククラス値の指定/受信

   The outgoing traffic class is normally set to 0.  Specifying the
   traffic class as ancillary data lets the application override either
   the kernel's default or a previously specified value, for either a
   unicast destination or a multicast destination, for a single output
   operation.  Returning the received traffic class is useful for
   programs such as a diffserv debugging tool and for user level ECN
   (explicit congestion notification) implementation.
   出トラフィッククラスは通常0が設定されます。トラフィッククラスを補助
   的なデータとして明示することで、ユニキャスト宛先あるいはマルチキャス
   ト宛先に対して、ひとつの出オペレーションで、アプリケーションはカーネ
   ルデフォルトや前に指定された値を上書きします。受信トラフィッククラス
   を返すことはdiffservをデバッグしているツールのようなプログラムとユー
   ザレベルECN(明示的混雑通知)実装に役立ちます。

   The received traffic class is returned as ancillary data by recvmsg()
   only if the application has enabled the IPV6_RECVTCLASS socket
   option:
   受信トラフィッククラスは、アプリケーションがIPV6_RECVTCLASSソケットオ
   プションを利用可能にした場合に限り、recvmsg()で補助的なデータとして返
   されます:

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_RECVTCLASS, &on, sizeof(on));

   In the cmsghdr structure containing this ancillary data, the
   cmsg_level member will be IPPROTO_IPV6, the cmsg_type member will be
   IPV6_TCLASS, and the first byte of cmsg_data[] will be the first byte
   of the integer traffic class.
   この補助的なデータを含んでいるcmsghdr構造体で、cmsg_levelメンバは
   IPPROTO_IPV6で、cmsg_typeメンバはIPV6_TCLASSで、cmsg_data[]の最初の
   バイトは整数トラフィッククラスの最初のバイトであるでしょう。

   To specify the outgoing traffic class value, just specify the control
   information as ancillary data for sendmsg() or using setsockopt().
   Just like the hop limit value, the interpretation of the integer
   traffic class value is
   出トラフィッククラス値を指定するために、sendmsg()やsetsockopt()の補
   助的なデータとして制御情報を明示してください。ホップ限界値と同じよう
   に、整数トラフィッククラス値の解釈は以下です。

      x < -1:        return an error of EINVAL
                     EINVALエラーを返す
      x == -1:       use kernel default
                     カーネルのデフォルトを使用
      0 <= x <= 255: use x
                     xを使用
      x >= 256:      return an error of EINVAL
                     EINVALエラーを返す

   In order to clear a sticky IPV6_TCLASS option the application can
   specify -1 as the value.
   付随IPV6_TCLASSオプションをクリアするために、アプリケーションは−1を
   値として明示できます。

   There are cases where the kernel needs to control the traffic class
   value and conflicts with the user-specified value on the outgoing
   traffic.  An example is an implementation of ECN in the kernel,
   setting 2 bits of the traffic class value.  In such cases, the kernel
   should override the user-specified value.  On the incoming traffic,
   the kernel may mask some of the bits in the traffic class field.
   カーネルがトラフィッククラス値を制御する必要がある場合があり、出トラ
   フィック上でユーザが指定した値と矛盾します。例えば、2ビットのトラ
   フィッククラス値をつけるカーネルのECNの実行です。このような場合、
   カーネルはユーザによって指定された値を優先するべきです。入トラフィッ
   ク上で、カーネルはトラフィッククラスフィールドの一部のビットをマスク
   するかもしれません。

6.6.  Additional Errors with sendmsg() and setsockopt()
6.6.  sendmsg()とsetsockopt()の追加エラー

   With the IPV6_PKTINFO socket option there are no additional errors
   possible with the call to recvmsg().  But when specifying the
   outgoing interface or the source address, additional errors are
   possible from sendmsg() or setsockopt().  Note that some
   implementations might only be able to return this type of errors for
   setsockopt().  The following are examples, but some of these may not
   be provided by some implementations, and some implementations may
   define additional errors:
   IPV6_PKTINFOソケットオプション付きのrecvmsg()呼び出しに追加のエラーが
   ありません。けれども出インタフェースあるいはソースアドレスを指定する
   時、sendmsg()やsetsockopt()で追加のエラーが可能です。ある実装が
   setsockopt()でだけこのエラータイプを返すことが可能かもしれないことに
   注意してください。以下は例です、しかしこれらのいくつかがある実装で供
   給されないかもしれず、ある実装が追加エラーを定義するかもしれません:

   ENXIO         The interface specified by ipi6_ifindex does not exist.
                 ipi6_ifindexで指定されたインタフェースは存在しません。

   ENETDOWN      The interface specified by ipi6_ifindex is not enabled
                 for IPv6 use.
                 ipi6_ifindexで指定されたインタフェースはIPv6が使用
                 可能ではありません。

   EADDRNOTAVAIL ipi6_ifindex specifies an interface but the address
                 ipi6_addr is not available for use on that interface.
                 ipi6_ifindexがインタフェースを指定しますが、ipi6_addrは
                 そのインタフェース上で利用可能ではありません。

   EHOSTUNREACH  No route to the destination exists over the interface
                 specified by ipi6_ifindex.
                 宛先への経路がipi6_ifindexで指定されたインタフェース上
                 に存在しません。

6.7.  Summary of Outgoing Interface Selection
6.7.  出インタフェース選択のまとめ

   This document and [RFC-3493] specify various methods that affect the
   selection of the packet's outgoing interface.  This subsection
   summarizes the ordering among those in order to ensure deterministic
   behavior.
   この文書と[RFC-3493]はパケットの出インタフェースの選択に影響を与える
   種々な方法を指定します。この章は決定的な行動を保証するためにそれらの
   間の順序を示します。

   For a given outgoing packet on a given socket, the outgoing interface
   is determined in the following order:
   あるソケットである出パケットの出インタフェースは次の順で決定されます:

   1. if an interface is specified in an IPV6_PKTINFO ancillary data
      item, the interface is used.
   1. もしIPV6_PKTINFO補助的データ項目でインタフェースが指定さるなら、そ
      のインタフェースが使われます。

   2. otherwise, if an interface is specified in an IPV6_PKTINFO sticky
      option, the interface is used.
   2. さもなければ、もしインタフェースがIPV6_PKTINFO付随オプションで指定
      されるなら、そのインタフェースが使われます。

   3. otherwise, if the destination address is a multicast address and
      the IPV6_MULTICAST_IF socket option is specified for the socket,
      the interface is used.
   3. さもなければ、もし宛先アドレスがマルチキャストアドレスであり、
      IPV6_MULTICAST_IFソケットオプションがソケットに指定されるなら、そ
      のインタフェースが使われます。

   4. otherwise, if an IPV6_NEXTHOP ancillary data item is specified,
      the interface to the next hop is used.
   4. さもなければ、もしIPV6_NEXTHOP補助的データ項目が指定されるなら、次
      の転送先へのインタフェースが使われます。

   5. otherwise, if an IPV6_NEXTHOP sticky option is specified, the
      interface to the next hop is used.
   5. さもなければ、もしIPV6_NEXTHOP付随オプションが指定されるなら、
      次の転送先へのインタフェースが使われます。

   6. otherwise, the outgoing interface should be determined in an
      implementation dependent manner.
   6. さもなければ、出インタフェースは実装に依存する方法で決定されるべ
      きです。

   The ordering above particularly means if the application specifies an
   interface by the IPV6_MULTICAST_IF socket option (described in [RFC-
   3493]) as well as specifying a different interface by the
   IPV6_PKTINFO sticky option, the latter will override the former for
   every multicast packet on the corresponding socket.  The reason for
   the ordering comes from expectation that the source address is
   specified as well and that the pair of the address and the outgoing
   interface should be preferred.
   上記の特定の順序は、もしアプリケーションが[RFC- 3493]で記述された)
   IPV6_MULTICAST_IFソケットオプションによってインタフェースを指定し 同
   様にIPV6_PKTINFO付随オプションによって異なるインタフェースを指定する
   なら、対応するソケットのすべてのマルチキャストパケットで、後者は前者
   を上書きする事を意味します。順序の理由はソースアドレスが指定され、そ
   して対のアドレスと出インタフェースが優先であるべきという期待から来ま
   す。

   In any case, the kernel must also verify that the source and
   destination addresses do not break their scope zones with regard to
   the outgoing interface.
   いずれの場合でも、カーネルはソースと宛先アドレスが出インターフェース
   に関してのゾーンがインタフェースの範囲を出ない確かめなくてはなりませ
   ん。

7.  Routing Header Option
7.  ルーティングヘッダーオプション

   Source routing in IPv6 is accomplished by specifying a Routing header
   as an extension header.  There can be different types of Routing
   headers, but IPv6 currently defines only the Type 0 Routing header
   [RFC-2460].  This type supports up to 127 intermediate nodes (limited
   by the length field in the extension header).  With this maximum
   number of intermediate nodes, a source, and a destination, there are
   128 hops.
   IPv6のソースルーティングはルーティングヘッダを拡張ヘッダとして明
   示することで達成されます。異なったタイプのルーティングヘッダがあり得
   ますが、IPv6は現在ただタイプ0ルーティングヘッダだけを定義します
   [RFC-2460]。このタイプは最高127の中間ノード(拡張ヘッダの長さフィー
   ルドで制約される)をサポートします。この最大値で中間ノードとソースと
   宛先で、最大128ホップです。

   Source routing with the IPv4 sockets API (the IP_OPTIONS socket
   option) requires the application to build the source route in the
   format that appears as the IPv4 header option, requiring intimate
   knowledge of the IPv4 options format.  This IPv6 API, however,
   defines six functions that the application calls to build and examine
   a Routing header, and the ability to use sticky options or ancillary
   data to communicate this information between the application and the
   kernel using the IPV6_RTHDR option.
   IPv4ソケットAPIのソースルーティング(IP_OPTIONSソケットオプショ
   ン)がアプリケーションにIPv4ヘッダオプションで現れるフォーマット
   でソースルートを作るように要求し、IPv4オプションフォーマットの詳
   細な知識を必要とします。このIPv6APIは、アプリケーションが高まっ
   て、そしてIPV6_RTHDRオプションを使ってアプリケーションとカーネル間で
   情報を伝達するために、ルーティングヘッダの構築や調査と、付随オプショ
   ンや補助的なデータを使う能力のための、6つの関数を定義します。
 
   Three functions build a Routing header:
   3つの関数がルーティングヘッダを生成します:

      inet6_rth_space()    - return #bytes required for Routing header
                           - 補助的なデータのために必要なバイト数を返す
      inet6_rth_init()     - initialize buffer data for Routing header
                           - ルーティングヘッダの補助的なデータを初期化
      inet6_rth_add()      - add one IPv6 address to the Routing header
                           - ルーティングヘッダにIPv6アドレスを追加

   Three functions deal with a returned Routing header:
   3つの関数が返されたルーティングヘディングを扱います:

      inet6_rth_reverse()  - reverse a Routing header
                           - ルーティングヘッダを反転
      inet6_rth_segments() - return #segments in a Routing header
                           - ルーティングヘッダのセグメント数を返す
      inet6_rth_getaddr()  - fetch one address from a Routing header
                           - ルーティングヘッダからアドレスを1つ取って来る

   The function prototypes for these functions are defined as a result
   of including <netinet/in.h>.
   これらの関数の関数プロトタイプは<netinet/in.h>で定義されます。

   To receive a Routing header the application must enable the
   IPV6_RECVRTHDR socket option:
   ルーティングヘッダを受け取るために、アプリケーションはIPV6_RECVRTHDRソ
   ケットオプションを利用可能にしなくてはなりません:

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_RECVRTHDR, &on, sizeof(on));

   Each received Routing header is returned as one ancillary data object
   described by a cmsghdr structure with cmsg_type set to IPV6_RTHDR.
   When multiple Routing headers are received, multiple ancillary data
   objects (with cmsg_type set to IPV6_RTHDR) will be returned to the
   application.
   それぞれの受信ルーティングヘッダがcmsg_typeにIPV6_RTHDRが設定された
   cmsghdr構造体で記述された補助的なデータオブジェクトがとして返されます。
   多数のルーティングヘッダを受信する時、多数の補助的なデータオブジェク
   ト(cmsg_type にIPV6_RTHDRが設定)がアプリケーションに返されるでしょ
   う。

   To send a Routing header the application specifies it either as
   ancillary data in a call to sendmsg() or using setsockopt().  For the
   sending side, this API assumes the number of occurrences of the
   Routing header as described in [RFC-2460].  That is, applications can
   only specify at most one outgoing Routing header.
   ルーティングヘッダを送るために、アプリケーションはsendmsg()呼び出しで
   補助的なデータを指定するか、setsockopt()を使います。[RFC-2460]で記述
   されるように、このAPIは送信側でルーティングヘッダの発生数を想定し
   ます。すなわち、アプリケーションがせいぜい1つの出ルーティングヘッダ
   を指定することができるだけです。

   The application can remove any sticky Routing header by calling
   setsockopt() for IPV6_RTHDR with a zero option length.
   アプリケーションは長さゼロのIPV6_RTHDRのsetsockopt()呼出をする事で付
   随ルーティングヘッダを除去できます。

   When using ancillary data a Routing header is passed between the
   application and the kernel as follows: The cmsg_level member has a
   value of IPPROTO_IPV6 and the cmsg_type member has a value of
   IPV6_RTHDR.  The contents of the cmsg_data[] member is implementation
   dependent and should not be accessed directly by the application, but
   should be accessed using the six functions that we are about to
   describe.
   補助的なデータを使う時、次のようにアプリケーションとカーネルの間でルー
   ティングヘッダを渡します:cmsg_levelメンバはIPPROTO_IPV6値です、
   cmsg_typeメンバはIPV6_RTHDR値です。cmsg_data[]メンバの中身は実装に依
   存し、直接アプリケーションがアクセスすべきでなく、我々が記述しようと
   している6つの関数を使ってアクセスされるべきです。

   The following constant is defined as a result of including the
   <netinet/in.h>:
   次の定数は<netinet/in.h>で定義されます:

      #define IPV6_RTHDR_TYPE_0    0 /* IPv6 Routing header type 0 */
                                     /* IPv6ルーティングヘッダータイプ0 */

   When a Routing header is specified, the destination address specified
   for connect(), sendto(), or sendmsg() is the final destination
   address of the datagram.  The Routing header then contains the
   addresses of all the intermediate nodes.
   ルーティングヘッダが指定される時、connect()かsendto()かsendmsg()のた
   めに指定された宛先アドレスがデータグラムの最終の宛先アドレスです。ルー
   ティングヘッダはすべての中間ノードのアドレスを含んでいます。

7.1.  inet6_rth_space
7.1.  inet6_rth_space

      socklen_t inet6_rth_space(int type, int segments);

   This function returns the number of bytes required to hold a Routing
   header of the specified type containing the specified number of
   segments (addresses).  For an IPv6 Type 0 Routing header, the number
   of segments must be between 0 and 127, inclusive.  The return value
   is just the space for the Routing header.  When the application uses
   ancillary data it must pass the returned length to CMSG_SPACE() to
   determine how much memory is needed for the ancillary data object
   (including the cmsghdr structure).
   この関数は、指定された数のセグメント(アドレス)を含む、指定されたタ
   イプのルーティングヘッダ、を維持する荷に必要なバイト数を返します。
   IPv6タイプ0ルーティングヘッダで、セグメント数は、0以上と127
   以下に違いありません。帰りの値はルーティングヘッダにちょうど必要なス
   ペースです。アプリケーションが補助的なデータを使う時、どれぐらいメモ
   リが(cmsghdr構造体を含めて)補助的なデータオブジェクトに必要とされる
   か決定するためにCMSG_SPACE()で返された長さを渡さなければなりません。

   If the return value is 0, then either the type of the Routing header
   is not supported by this implementation or the number of segments is
   invalid for this type of Routing header.
   もし返り値が0なら、ルーティングヘッダのタイプがこの実装でサポートさ
   れないか、セグメント数がこのタイプのルーティングヘッダで無効であるか
   のどちらかです。

   (Note: This function returns the size but does not allocate the space
   required for the ancillary data.  This allows an application to
   allocate a larger buffer, if other ancillary data objects are
   desired, since all the ancillary data objects must be specified to
   sendmsg() as a single msg_control buffer.)
   (ノート:この関数は大きさを返しますが、補助的なデータで必要なスペー
   スを割り当てません。すべての補助的なデータオブジェクトがひとつの
   msg_controlバッファとしてsendmsg()で指定されなければならないので、こ
   れはもし他の補助的なデータオブジェクトを望むアプリケーションがより大
   きいバッファの割り当てることを許します。)

7.2.  inet6_rth_init
7.2.  inet6_rth_init

      void *inet6_rth_init(void *bp, socklen_t bp_len, int type,
                           int segments);

   This function initializes the buffer pointed to by bp to contain a
   Routing header of the specified type and sets ip6r_len based on the
   segments parameter.  bp_len is only used to verify that the buffer is
   large enough.  The ip6r_segleft field is set to zero; inet6_rth_add()
   will increment it.
   この関数はbpでポイントしたバッファを、typeで示されたルーティングヘッ
   ダを含むように初期化し、セグメントパラメータに基づいてip6r_lenを設定
   します。bp_lenはバッファが十分に大きいことを確かめるためだけに使いま
   す。ip6r_segleftフィールドはゼロが設定されます;inet6_rth_add()がこれ
   を増加させます。

   When the application uses ancillary data the application must
   initialize any cmsghdr fields.
   アプリケーションが補助的なデータを使う時、アプリケーションはcmsghdr
   フィールドを初期化しなくてはなりません。

   The caller must allocate the buffer and its size can be determined by
   calling inet6_rth_space().
   呼び出し者はバッファを割り当てなくてはなりません、そしてその大きさは
   inet6_rth_space()を呼ぶことによって決定できます。

   Upon success the return value is the pointer to the buffer (bp), and
   this is then used as the first argument to the inet6_rth_add()
   function.  Upon an error the return value is NULL.
   成功した場合の帰り値はバッファ(bp)へのポインタで、これは
   inet6_rth_add()関数の最初の引数に使います。エラーの帰りの値はNULLです。

7.3.  inet6_rth_add
7.3.  inet6_rth_add

      int inet6_rth_add(void *bp, const struct in6_addr *addr);

   This function adds the IPv6 address pointed to by addr to the end of
   the Routing header being constructed.
   この関数はaddrで示されるIPv6アドレスを組み立てているルーティング
   ヘッダの終わりに追加します。

   If successful, the segleft member of the Routing Header is updated to
   account for the new address in the Routing header and the return
   value of the function is 0.  Upon an error the return value of the
   function is -1.
   もし成功たらルーティングヘッダのsegleftメンバはルーティングヘッダの新
   しいアドレスを追加するために更新され、関数の帰り値は0です。エラーの
   関数の帰りの値は-1です。

7.4.  inet6_rth_reverse
7.4.  inet6_rth_reverse

      int inet6_rth_reverse(const void *in, void *out);

   This function takes a Routing header extension header (pointed to by
   the first argument) and writes a new Routing header that sends
   datagrams along the reverse of that route.  The function reverses the
   order of the addresses and sets the segleft member in the new Routing
   header to the number of segments.  Both arguments are allowed to
   point to the same buffer (that is, the reversal can occur in place).
   この関数は(最初の引数のポインタで示される)ルーティングヘッダ拡張ヘッ
   ダを得て、そしてデータグラムを経路の反対に送る新しいルーティングヘッ
   ダを書きます。関数はアドレスの秩序を反転し、そして新しいルーティング
   ヘッダのsegleftメンバにセグメント数を設定します。両方の引数が同じバッ
   ファを示すことは許されます(すなわち、同じ場所で反転できます)。

   The return value of the function is 0 on success, or -1 upon an
   error.
   関数の帰り値は成功で0、エラーで-1です。

7.5.  inet6_rth_segments
7.5.  inet6_rth_segments

      int inet6_rth_segments(const void *bp);

   This function returns the number of segments (addresses) contained in
   the Routing header described by bp.  On success the return value is
   zero or greater.  The return value of the function is -1 upon an
   error.
   この関数はbpで記述されたルーティングヘッダのセグメント(アドレス)の
   数を返します。成功の返り値はゼロ以上です。関数の返り値はエラーで-1です。

7.6.  inet6_rth_getaddr
7.6.  inet6_rth_getaddr

      struct in6_addr *inet6_rth_getaddr(const void *bp, int index);

   This function returns a pointer to the IPv6 address specified by
   index (which must have a value between 0 and one less than the value
   returned by inet6_rth_segments()) in the Routing header described by
   bp.  An application should first call inet6_rth_segments() to obtain
   the number of segments in the Routing header.
   この関数はbpで記述されたルーティングヘッダのindex (0以上、
   inet6_rth_segments()の返す値引く1以下)で指定されたIPv6アドレス
   へのポインタを返します。アプリケーションがルーティングヘッダのセグメ
   ント数を得るために最初にinet6_rth_segments()を呼ぶべきです。

   Upon an error the return value of the function is NULL.
   関数のエラーの返り値はNULLです。

8.  Hop-By-Hop Options
8.  ホップ毎オプション

   A variable number of Hop-by-Hop options can appear in a single Hop-
   by-Hop options header.  Each option in the header is TLV-encoded with
   a type, length, and value.  This IPv6 API defines seven functions
   that the application calls to build and examine a Hop-by_Hop options
   header, and the ability to use sticky options or ancillary data to
   communicate this information between the application and the kernel.
   This uses the IPV6_HOPOPTS for a Hop-by-Hop options header.
   可変個のホップ毎オプションがひとつのホップ毎オプションヘッダに現われ
   ることができます。ヘッダの各オプションがタイプと長さと値でTLVでコー
   ドされています。このIPv6のAPIは、アプリケーションがホップ毎オ
   プションヘッダを構築や試験をする7つの関数を定義し、アプリケーション
   とカーネル間でこの情報を伝達するための付随オプションや補助的なデータ
   を使う能力を定義します。これはホップ毎オプションヘッダのIPV6_HOPOPTS
   を使います。

   Today several Hop-by-Hop options are defined for IPv6.  Two pad
   options, Pad1 and PadN, are for alignment purposes and are
   automatically inserted by the inet6_opt_XXX() routines and ignored by
   the inet6_opt_XXX() routines on the receive side.  This section of
   the API is therefore defined for other (and future) Hop-by-Hop
   options that an application may need to specify and receive.
   今日、いくつかのホップ毎オプションはIPv6のために定義されます。
   2パッドオプション、Pad1とPadNが整列の目的であり、そして自動的に
   inet6_opt_XXX()ルーチンによって挿入され、そして受信側で
   inet6_opt_XXX() ()ルーチンによって無視されます。従ってこのAPIの章
   はアプリケーションが指定して、そして受信する必要があるかもしれない他
   (そして未来の)ホップ毎オプションのために定義されます。

   Four functions build an options header:
   4つの関数がオプションヘッダを生成します:

      inet6_opt_init()     - initialize buffer data for options header
                           - オプションヘッダのバッファデータを初期化
      inet6_opt_append()   - add one TLV option to the options header
                           - オプションヘッダに1つのTLVオプションを追加
      inet6_opt_finish()   - finish adding TLV options to the options
                             header
                           - オプションヘッダにTLVオプションの追加を終了
      inet6_opt_set_val()  - add one component of the option content to
                             the option
                           - オプションにオプション内容の1つの要素を追加

      Three functions deal with a returned options header:
      返されたオプションヘッダを扱う3つの関数:

      inet6_opt_next()     - extract the next option from the options
                             header
                           - オプションヘッダから次のオプションを抽出
      inet6_opt_find()     - extract an option of a specified type from
                             the header
                           - ヘッダから指定されたタイプのオプションを抽出
      inet6_opt_get_val()  - retrieve one component of the option
                             content
                           - オプション内容の1つの構成要素を検索

   Individual Hop-by-Hop options (and Destination options, which are
   described in Section 9 and are very similar to the Hop-by-Hop
   options) may have specific alignment requirements.  For example, the
   4-byte Jumbo Payload length should appear on a 4-byte boundary, and
   IPv6 addresses are normally aligned on an 8-byte boundary.  These
   requirements and the terminology used with these options are
   discussed in Section 4.2 and Appendix B of [RFC-2460].  The alignment
   of first byte of each option is specified by two values, called x and
   y, written as "xn + y".  This states that the option must appear at
   an integer multiple of x bytes from the beginning of the options
   header (x can have the values 1, 2, 4, or 8), plus y bytes (y can
   have a value between 0 and 7, inclusive).  The Pad1 and PadN options
   are inserted as needed to maintain the required alignment.  The
   functions below need to know the alignment of the end of the option
   (which is always in the form "xn," where x can have the values 1, 2,
   4, or 8) and the total size of the data portion of the option.  These
   are passed as the "align" and "len" arguments to inet6_opt_append().
   個別のホップ毎オプション(そして9章で記述されホップ毎オプションに非
   常に類似している宛先オプション)は特定の整列条件を持つかもしれません。
   例えば、4バイトの巨大ペイロード長は4バイトの境界線に現われるべきで、
   IPv6アドレスが通常8バイトの境界上に整列します。これらのオプショ
   ンを使う条件と用語は4.2章と[RFC-2460]の付録Bで論じられます。各オプ
   ションの最初のバイトの整列はxとy呼ばれる2値で"xn + y"と書かれて指定
   されます。これはオプションがオプションヘッダの先頭からxの整数倍のバイ
   ト数(xの価は1か2か4か8です)、足すyバイト(yが0から7の間の値)
   に現われなくてはならないと述べます。Pad1とPadNオプションは、必要とさ
   れる整列を維持する必要があった時に差し込まれます。下記の関数はオプショ
   ンの終わりの整列条件(常に書式は"xn,"形式で、xが価1か2か4か8です)
   とオプションのデータ部の完全な大きさを知る必要があります。これらは
   inet6_opt_append()で"align"と"len"引数として渡されます。

   Multiple Hop-by-Hop options must be specified by the application by
   placing them in a single extension header.
   多数のホップ毎オプションはアプリケーションがひとつの拡張ヘッダに置く
   ことで指定されなくてはなりません。

   Finally, we note that use of some Hop-by-Hop options or some
   Destination options, might require special privilege.  That is,
   normal applications (without special privilege) might be forbidden
   from setting certain options in outgoing packets, and might never see
   certain options in received packets.
   最終的に、あるホップ毎オプションあるいはある宛先オプションの使用で特
   別な特権を必要とするかもしれません。すなわち、(特別な特権無しの)標
   準アプリケーションがある特定のオプションを出パケットに設定することを
   禁止されるかもしれず、そして決して受信パケットである特定のオプション
   を見ないかもしれません。

8.1.  Receiving Hop-by-Hop Options
8.1.  ホップ毎オプションの受信

   To receive a Hop-by-Hop options header the application must enable
   the IPV6_RECVHOPOPTS socket option:
   ホップ毎オプションヘッダを受信するために、アプリケーションは
   IPV6_RECVHOPOPTSソケットオプションを利用可能にしなくてはなりません:

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPOPTS, &on, sizeof(on));

   When using ancillary data a Hop-by-hop options header is passed
   between the application and the kernel as follows: The cmsg_level
   member will be IPPROTO_IPV6 and the cmsg_type member will be
   IPV6_HOPOPTS.  These options are then processed by calling the
   inet6_opt_next(), inet6_opt_find(), and inet6_opt_get_val()
   functions, described in Section 10.
   補助的なデータを使う時、ホップ毎オプションヘッダが次のようにアプリケー
   ションとカーネルの間で渡されます:cmsg_levelメンバはIPPROTO_IPV6であ
   るでしょう、そしてcmsg_typeメンバは IPV6_HOPOPTSであるでしょう。これ
   らのオプションは10章で記述されるinet6_opt_next()とinet6_opt_find()
   とinet6_opt_get_val()を呼ぶことによって処理されます。

8.2.  Sending Hop-by-Hop Options
8.2.  ホップ毎オプションの送信

   To send a Hop-by-Hop options header, the application specifies the
   header either as ancillary data in a call to sendmsg() or using
   setsockopt().
   ホップ毎オプションヘッダを送るために、アプリケーションはsendmsg()を呼
   び際の補助的なデータとして明示するか、setsockopt()を使います。

   The application can remove any sticky Hop-by-Hop options header by
   calling setsockopt() for IPV6_HOPOPTS with a zero option length.
   アプリケーションは長さゼロのIPV6_HOPOPTSでsetsockopt()を呼ぶことで、
   付随ホップ毎オプションヘッダを取り去ることができます。

   All the Hop-by-Hop options must be specified by a single ancillary
   data object.  The cmsg_level member is set to IPPROTO_IPV6 and the
   cmsg_type member is set to IPV6_HOPOPTS.  The option is normally
   constructed using the inet6_opt_init(), inet6_opt_append(),
   inet6_opt_finish(), and inet6_opt_set_val() functions, described in
   Section 10.
   すべてのホップ毎オプションは一つの補助的なデータオブジェクトによって
   指定されなくてはなりません。cmsg_levelメンバはIPPROTO_IPV6を設定し、
   cmsg_typeメンバはIPV6_HOPOPTSを設定します。オプションは通常10章で記
   述されるinet6_opt_init()とinet6_opt_append()とinet6_opt_finish()と
   inet6_opt_set_val()関数を使って組み立てられます。

   Additional errors may be possible from sendmsg() and setsockopt() if
   the specified option is in error.
   もし指定されたオプションが誤っているなら、sendmsg()とsetsockopt()で追
   加のエラーがあるかもしれません。

9.  Destination Options
9.  宛先オプション

   A variable number of Destination options can appear in one or more
   Destination options headers.  As defined in [RFC-2460], a Destination
   options header appearing before a Routing header is processed by the
   first destination plus any subsequent destinations specified in the
   Routing header, while a Destination options header that is not
   followed by a Routing header is processed only by the final
   destination.  As with the Hop-by-Hop options, each option in a
   Destination options header is TLV-encoded with a type, length, and
   value.
   複数個の宛先オプションが1つ以上の宛先オプションヘッダに現われること
   ができます。[RFC-2460]で定義されるように、ルーティングヘッダの前に現
   われる宛先オプションヘッダが最初の宛先とルーティングヘッダで指定する
   宛先で処理され、ルーティングヘッダが続かない宛先オプションヘッダが最
   終の宛先でだけ処理されます。ホップ毎オプションと同じように、各宛先オ
   プションヘッダのオプションがタイプと長さと値のTLVでコードさます。

9.1.  Receiving Destination Options
9.1.  宛先オプション受信

   To receive Destination options header the application must enable the
   IPV6_RECVDSTOPTS socket option:
   宛先オプションヘッダを受け取るために、アプリケーションは
   IPV6_RECVDSTOPTSソケットオプションを使用可能にしなくてはなりません:

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_RECVDSTOPTS, &on, sizeof(on));

   Each Destination options header is returned as one ancillary data
   object described by a cmsghdr structure with cmsg_level set to
   IPPROTO_IPV6 and cmsg_type set to IPV6_DSTOPTS.
   それぞれの宛先オプションヘッダが、cmsg_levelをIPPROTO_IPV6にcmsg_type
   をIPV6_DSTOPTSに設定したcmsghdr構造体で記述された補助的なデータオブ
   ジェクトとして返されます。

   These options are then processed by calling the inet6_opt_next(),
   inet6_opt_find(), and inet6_opt_get_value() functions.
   これらのオプションはinet6_opt_next()とinet6_opt_find()と
   inet6_opt_get_value()関数を呼ぶことによって処理されます。

9.2.  Sending Destination Options
9.2.  宛先オプション送信

   To send a Destination options header, the application specifies it
   either as ancillary data in a call to sendmsg() or using
   setsockopt().
   宛先オプションヘッダを送るために、アプリケーションはsendmsg()呼出で補
   助的なデータを明示するか、setsockopt()を使います。

   The application can remove any sticky Destination options header by
   calling setsockopt() for IPV6_RTHDRDSTOPTS/IPV6_DSTOPTS with a zero
   option length.
   アプリケーションは長さゼロでIPV6_RTHDRDSTOPTS/IPV6_DSTOPTSの
   setsockopt()呼出をする事で付随宛先オプションヘッダを除去できます。

   This API assumes the ordering about extension headers as described in
   [RFC-2460].  Thus, one set of Destination options can only appear
   before a Routing header, and one set can only appear after a Routing
   header (or in a packet with no Routing header).  Each set can consist
   of one or more options but each set is a single extension header.
   このAPIは[RFC-2460]で記述される拡張ヘッダの順序を想定します。それ
   で、宛先オプションがルーティングヘッダの前にただ1つだけ現われること
   ができ、そしてルーティングヘッダの後に(あるいはルーティングヘッダが
   ないパケットで)1つだけ現われることができます。各宛先オプションが1
   つ以上のオプションから成り立つことができますが、しかしそれぞれがひと
   つの拡張ヘッダです。

   Today all destination options that an application may want to specify
   can be put after (or without) a Routing header.  Thus, applications
   should usually need IPV6_DSTOPTS only and should avoid using
   IPV6_RTHDRDSTOPTS whenever possible.
   今日アプリケーションが指定することを望むかもしれないすべての宛先オプ
   ションはルーティングヘッダの後(あるいは無しで)置く事がことができま
   す。それで、アプリケーションが通常IPV6_DSTOPTSのみを必要とするべきで
   あり、可能な時はIPV6_RTHDRDSTOPTSを使うのを避けるべきです。

   When using ancillary data a Destination options header is passed
   between the application and the kernel as follows: The set preceding
   a Routing header are specified with the cmsg_level member set to
   IPPROTO_IPV6 and the cmsg_type member set to IPV6_RTHDRDSTOPTS.  Any
   setsockopt or ancillary data for IPV6_RTHDRDSTOPTS is silently
   ignored when sending packets unless a Routing header is also
   specified.  Note that the "Routing header" here means the one
   specified by this API.  Even when the kernel inserts a routing header
   in its internal routine (e.g., in a mobile IPv6 stack), the
   Destination options header specified by IPV6_RTHDRDSTOPTS will still
   be ignored unless the application explicitly specifies its own
   Routing header.
   補助的なデータを使う時、宛先オプションヘッダがアプリケーションとカー
   ネル間で以下の様に渡されます:ルーティングヘッダより前のヘッダは、
   cmsg_levelメンバにIPPROTO_IPV6を設定し、cmsg_typeメンバに
   IPV6_RTHDRDSTOPTSを設定して、指定されます。IPV6_RTHDRDSTOPTSの
   setsockoptや補助的なデータが、ルーティングヘッダが指定されないなら、
   パケットを送る時、静かに無視されます。「ルーティングヘッダ」はこのA
   PIで指定されたものを意味することに注意してください。カーネルがルー
   ティングヘッダをその内部のルーチンに挿入する時(例えば、モバイルIP
   v6スタックで)さえ、IPV6_RTHDRDSTOPTSで指定された宛先オプションヘッ
   ダは、アプリケーションが明示的にそれ自身のルーティングヘッダを指定し
   ないなら、無視されるでしょう。

   The set of Destination options after a Routing header, which are also
   used when no Routing header is present, are specified with the
   cmsg_level member is set to IPPROTO_IPV6 and the cmsg_type member is
   set to IPV6_DSTOPTS.
   ルーティングヘッダの後やルーティングヘッダが存在していない時の宛先オ
   プションは、cmsg_levelメンバをIPPROTO_IPV6に設定しcmsg_typeメンバを
   IPV6_DSTOPTSに設定することで指定します。

   The Destination options are normally constructed using the
   inet6_opt_init(), inet6_opt_append(), inet6_opt_finish(), and
   inet6_opt_set_val() functions, described in Section 10.
   宛先オプションは通常10章で記述されるinet6_opt_init()と
   inet6_opt_append()とinet6_opt_finish()とinet6_opt_set_val()関数をを
   使って組み立てられます。

   Additional errors may be possible from sendmsg() and setsockopt() if
   the specified option is in error.
   もし指定されたオプションが誤っているなら、追加のエラーがsendmsg()と
   setsockopt()が可能であるかもしれません。

10.  Hop-by-Hop and Destination Options Processing
10.  ホップ毎オプションと宛先オプション処理

   Building and parsing the Hop-by-Hop and Destination options is
   complicated for the reasons given earlier.  We therefore define a set
   of functions to help the application.  These functions assume the
   formatting rules specified in Appendix B in [RFC-2460] i.e., that the
   largest field is placed last in the option.
   ホップ毎オプションと宛先オプションを作って解析することは前に言った理
   由で複雑です。従って我々はアプリケーションに手を貸すために関数のセッ
   トを定義します。これらの関数が[RFC-2460]の付録Bで規則が指定したフォー
   マットを想定します、すなわち、最も大きいフィールドがオプションのフィー
   ルドの最後に置かれます。

   The function prototypes for these functions are defined as a result
   of including <netinet/in.h>.
   これらの関数の関数プロトタイプが<netinet/in.h>で定義されます。

   The first 3 functions (init, append, and finish) are used both to
   calculate the needed buffer size for the options, and to actually
   encode the options once the application has allocated a buffer for
   the header.  In order to only calculate the size the application must
   pass a NULL extbuf and a zero extlen to those functions.
   最初の3つの関数(initとappendとfinish)がオプションに必要なバッファ
   の大きさの計算と、アプリケーションがヘッダのバッファを割り当てたら、
   実際にオプションをコード化するために使われます。ただ大きさを計算する
   ためだけの場合、アプリケーションはこれらの関数にNULLのextbufとゼロ
   extlenを渡さなくてはなりません。


10.1.  inet6_opt_init
10.1.  inet6_opt_init

      int inet6_opt_init(void *extbuf, socklen_t extlen);

   This function returns the number of bytes needed for the empty
   extension header i.e., without any options.  If extbuf is not NULL it
   also initializes the extension header to have the correct length
   field.  In that case if the extlen value is not a positive (i.e.,
   non-zero) multiple of 8 the function fails and returns -1.
   空の拡張ヘッダ、すなわちオプションなしで、に必要とされるバイト数を関
   数は返します。もしextbufがNULLでないなら、正しい長さフィールドを持つ
   ために拡張子ヘッダを初期化します。このような場合もしextlen値が8の負
   でない整数ポジティブ(すなわち非ゼロ)倍数ではないなら、関数は失敗し
   て、-1を返します。

   (Note: since the return value on success is based on a "constant"
   parameter, i.e., the empty extension header, an implementation may
   return a constant value.  However, this specification does not
   require the value be constant, and leaves it as implementation
   dependent.  The application should not assume a particular constant
   value as a successful return value of this function.)
   (ノート:成功した返り値が「定数」パラメータ、すなわち空拡張ヘッダ、
   に基づきます、実装が定数値を返すかもしれません。しかしながら、この仕
   様は値が定数であることを要求せず、実装に依存するままにしておきます。
   アプリケーションはこの関数の成功の返り値として特定の定数値を想定する
   べきではありません。)

10.2.  inet6_opt_append
10.2.  inet6_opt_append

      int inet6_opt_append(void *extbuf, socklen_t extlen, int offset,
                           uint8_t type, socklen_t len, uint_t align,
                           void **databufp);
   訳注:RFC誤植情報によると、"uint_t"は"uint8_t"が正しいそうです。

   Offset should be the length returned by inet6_opt_init() or a
   previous inet6_opt_append().  This function returns the updated total
   length taking into account adding an option with length 'len' and
   alignment 'align'.  If extbuf is not NULL then, in addition to
   returning the length, the function inserts any needed pad option,
   initializes the option (setting the type and length fields) and
   returns a pointer to the location for the option content in databufp.
   If the option does not fit in the extension header buffer the
   function returns -1.
   Offsetはinet6_opt_init()か前のinet6_opt_append()が返す長さであるべき
   です。この関数は長さ「len」で整列「align」のオプションを加えた結果の
   更新された完全な長さを返します。もしextbufがNULLでないなら、長さを返
   す時に、関数は必要な穴埋めオプションを挿入し、オプションを初期化し
   (タイプと長さフィールドの設定)、databufpでオプション内容のための場
   所へのポインタを返します。もしオプションが拡張ヘッダーバッファに十分
   でないなら、関数は-1を返します。

   Type is the 8-bit option type.  Len is the length of the option data
   (i.e., excluding the option type and option length fields).
   typeは8ビットのオプションタイプです。lenはオプションデータの長さ
   (オプションタイプとオプション長フィールドを除く)です。

   Once inet6_opt_append() has been called the application can use the
   databuf directly, or use inet6_opt_set_val() to specify the content
   of the option.
   inet6_opt_append()が呼ばれたら、アプリケーションは直接databuf を使う
   か、あるいはオプションの内容を指定するためにinet6_opt_set_val()を使う
   ことができます。

   The option type must have a value from 2 to 255, inclusive.  (0 and 1
   are reserved for the Pad1 and PadN options, respectively.)
   オプションタイプは、2以上から255以下の値を持っていなくてはなりま
   せん。(0と1がそれぞれPad1とPadNオプションのために確保されます。)

   The option data length must have a value between 0 and 255,
   inclusive, and is the length of the option data that follows.
   オプションデータ長さは、0以上と255以下の値で、そして次に続くオプ
   ションデータの長さです。

   The align parameter must have a value of 1, 2, 4, or 8.  The align
   value can not exceed the value of len.
   alignパラメータは1か2か4か8の価値を持ちます。
   align値はlenの値を超えれません。

10.3.  inet6_opt_finish
10.3.  inet6_opt_finish

      int inet6_opt_finish(void *extbuf, socklen_t extlen, int offset);

   Offset should be the length returned by inet6_opt_init() or
   inet6_opt_append().  This function returns the updated total length
   taking into account the final padding of the extension header to make
   it a multiple of 8 bytes.  If extbuf is not NULL the function also
   initializes the option by inserting a Pad1 or PadN option of the
   proper length.
   Offsetがinet6_opt_init()かinet6_opt_append()によって返される長さであ
   るべきです。この関数は8バイトの倍数にするための拡張ヘッダの最終の穴
   埋めを考慮に入れて更新された全体の長さを返します。もしextbufがNULLで
   ないなら、関数は適切な長さのPad1かPadNオプションを差し込むことによっ
   てオプションを初期化します。

   If the necessary pad does not fit in the extension header buffer the
   function returns -1.
   もし必要な穴埋め拡張ヘッダバッファに入らないなら関数は-1を返します。

10.4.  inet6_opt_set_val
10.4.  inet6_opt_set_val

      int inet6_opt_set_val(void *databuf, int offset, void *val,
                            socklen_t vallen);

   Databuf should be a pointer returned by inet6_opt_append().  This
   function inserts data items of various sizes in the data portion of
   the option.  Val should point to the data to be inserted.  Offset
   specifies where in the data portion of the option the value should be
   inserted; the first byte after the option type and length is accessed
   by specifying an offset of zero.
   databufはinet6_opt_append()によって返されるポインタであるべきです。こ
   の関数は様々な大きさのデータ項目をオプションデータ部に挿入します。val
   は差し込まれるデータのポインタです。offsetは値が差し込まれるべきオプ
   ションのデータ部の場所を明示します;オプションタイプと長さの後の最初
   のバイトはゼロのオフセットを指定することによってアクセスされます。

   The caller should ensure that each field is aligned on its natural
   boundaries as described in Appendix B of [RFC-2460], but the function
   must not rely on the caller's behavior.  Even when the alignment
   requirement is not satisfied, inet6_opt_set_val should just copy the
   data as required.
   呼び出し人はそれぞれのフィールドが[RFC-2460]の付録Bで記述されるよう
   に、自然の境界線に並べられることを保証するべきです、しかし関数は呼び
   出し人の行動に依存してはなりません。整列条件が満たされない時でも、
   inet6_opt_set_valが要求されるようにデータをコピーするべきです。

   The function returns the offset for the next field (i.e., offset +
   vallen) which can be used when composing option content with multiple
   fields.
   関数は、多数のフィールドのオプションの内容を構成する時に使うことがで
   きる次のフィールドのオフセット(すなわち、offset + vallen)を返します。

10.5.  inet6_opt_next
10.5.  inet6_opt_next

      int inet6_opt_next(void *extbuf, socklen_t extlen, int offset,
                         uint8_t *typep, socklen_t *lenp,
                         void **databufp);

   This function parses received option extension headers returning the
   next option.  Extbuf and extlen specifies the extension header.
   Offset should either be zero (for the first option) or the length
   returned by a previous call to inet6_opt_next() or inet6_opt_find().
   It specifies the position where to continue scanning the extension
   buffer.  The next option is returned by updating typep, lenp, and
   databufp.  Typep stores the option type, lenp stores the length of
   the option data (i.e., excluding the option type and option length
   fields), and databufp points the data field of the option.  This
   function returns the updated "previous" length computed by advancing
   past the option that was returned.  This returned "previous" length
   can then be passed to subsequent calls to inet6_opt_next().  This
   function does not return any PAD1 or PADN options.  When there are no
   more options or if the option extension header is malformed the
   return value is -1.
   この関数は受信オプション拡張ヘッダを解析し、次のオプションを返します。
   extbufとextlenは拡張ヘッダを指定します。オフセットが、ゼロ(最初のオ
   プションで)か前inet6_opt_next()で返された長さであるべきです。これは
   拡張バッファを調べる位置を指定します。次のオプションはtypepとlenpと
   databufpを更新して返されます。Typepはオプションタイプを記憶し、lenpが
   (オプションタイプとオプション長さフィールドを除く)オプションデータ
   長を記憶し、databufpがオプションのデータフィールドを示します。この関
   数は返されたオプションを過ぎて進むことによって計算された更新された
   「前の」長さを返します。この返された「前の」長さは、続く
   inet6_opt_next()の呼出で返すことができます。この関数はPAD1やPADNオプ
   ションを返しません。これ以上のオプションがない時、あるいはもしオプ
   ション拡張ヘッダが誤っているなら、返り値は-1です。

10.6.  inet6_opt_find
10.6.  inet6_opt_find

      int inet6_opt_find(void *extbuf, socklen_t extlen, int offset,
                         uint8_t type, socklen_t *lenp,
                         void **databufp);

   This function is similar to the previously described inet6_opt_next()
   function, except this function lets the caller specify the option
   type to be searched for, instead of always returning the next option
   in the extension header.
   この関数は、拡張ヘッダの次のオプションを返す代わりに、呼び出し人が捜
   索されるべきオプションタイプを指定するのを除き、前に記述された
   inet6_opt_next()関数に類似しています。

   If an option of the specified type is located, the function returns
   the updated "previous" total length computed by advancing past the
   option that was returned and past any options that didn't match the
   type.  This returned "previous" length can then be passed to
   subsequent calls to inet6_opt_find() for finding the next occurrence
   of the same option type.
   もし指定されたタイプのオプションがないなら、関数は返されたオプション
   を越えて、一致しなかった全てのオプションを過ぎて、計算した更新された
   「前の」全体の長さを返します。この返された「前の」長さは次の同じオプ
   ションタイプを見つけるためinet6_opt_find()への次の呼出で使えます。

   If an option of the specified type is not located, the return value
   is -1.  If the option extension header is malformed, the return value
   is -1.
   もし指定されたタイプのオプションがなければ返り値は-1です。もしオプショ
   ン拡張ヘッダが誤っているなら返り値は-1です。

10.7.  inet6_opt_get_val
10.7.  inet6_opt_get_val

      int inet6_opt_get_val(void *databuf, int offset, void *val,
                            socklen_t vallen);

   Databuf should be a pointer returned by inet6_opt_next() or
   inet6_opt_find().  This function extracts data items of various sizes
   in the data portion of the option.  Val should point to the
   destination for the extracted data.  Offset specifies from where in
   the data portion of the option the value should be extracted; the
   first byte after the option type and length is accessed by specifying
   an offset of zero.
   databufは inet6_opt_next()やinet6_opt_find()の返すポインタであるべき
   です。この関数はオプションのデータ部の様々な大きさのデータ項目を抜き
   出します。valは抜き出したデータの行き先を指し示すべきです。offsetがオ
   プションのデータ部の抜き出す位置を指定します;オプションタイプと長さ
   の後の最初のバイトはゼロのオフセットを指定することによってアクセスさ
   れます。

   It is expected that each field is aligned on its natural boundaries
   as described in Appendix B of [RFC-2460], but the function must not
   rely on the alignment.
   それぞれのフィールドが[RFC-2460]の付録Bで記述されるように、その自然
   な境界線上に並べられると思われますが、関数は整列に依存してはなりませ
   ん。

   The function returns the offset for the next field (i.e., offset +
   vallen) which can be used when extracting option content with
   multiple fields.
   関数は多数のフィールドからオプション内容を抜き出す時、使うことができ
   る次のフィールドのオフセット(すなわち、オフセット+vallen)を返します。

11.  Additional Advanced API Functions
11.  追加高等API関数

11.1.  Sending with the Minimum MTU
11.1.  最小MTUでの送信

   Unicast applications should usually let the kernel perform path MTU
   discovery [RFC-1981], as long as the kernel supports it, and should
   not care about the path MTU.  Some applications, however, might not
   want to incur the overhead of path MTU discovery, especially if the
   applications only send a single datagram to a destination.  A
   potential example is a DNS server.
   ユニキャストアプリケーションは、カーネルがサポートする限り、通常カー
   ネルにパスMTU探索[RFC-1981]を実行させるべきで、パスMTUを気にす
   るべきではありません。しかし、あるアプリケーションが、特にもしアプリ
   ケーションがただ目的地にひとつのデータグラムを送ることだけをするなら、
   パスMTU探索のコストを望まないかもしれません。可能性がある例はDN
   Sサーバです。

   [RFC-1981] describes how path MTU discovery works for multicast
   destinations.  From practice in using IPv4 multicast, however, many
   careless applications that send large multicast packets on the wire
   have caused implosion of ICMPv4 error messages.  The situation can be
   worse when there is a filtering node that blocks the ICMPv4 messages.
   Though the filtering issue applies to unicast as well, the impact is
   much larger in the multicast cases.
   [RFC-1981]はどのようにパスMTU探索がマルチキャスト宛先で動作するか
   記述します。IPv4マルチキャストを使う経験で、大きいマルチキャスト
   パケットをワイヤ上に送る多くの不注意なアプリケーションがICMPv4
   エラーメッセージの爆発を起こしました。この状態は、ICMPv4メッセー
   ジを妨げるフィルタノードがある時により悪なり得ます。フィルタ問題が同
   様にユニキャストに当てはまるけれども、影響はマルチキャストの場合によ
   り大きいです。

   Thus, applications sending multicast traffic should explicitly enable
   path MTU discovery only when they understand that the benefit of
   possibly larger MTU usage outweighs the possible impact of MTU
   discovery for active sources across the delivery tree(s).  This
   default behavior is based on the today's practice with IPv4 multicast
   and path MTU discovery.  The behavior may change in the future once
   it is found that path MTU discovery effectively works with actual
   multicast applications and network configurations.
   それで、マルチキャストトラフィックを送るアプリケーションが、ただより
   大きいMTUを使う利益が配達木の先のアクティブなソースのMTU探索の
   影響よりも重要であると理解する時だけ、明示的にパスMTU探索を可能に
   するべきです。このデフォルト行動は、今日のIPv4マルチキャストとパ
   スMTU探索の経験に基づいています。パスMTU探索が実際のマルチキャ
   ストアプリケーションとネットワーク設定で効率的に作動することは気付か
   れるなら、動作が将来変化するかもしれません。

   This specification defines a mechanism to avoid path MTU discovery by
   sending at the minimum IPv6 MTU [RFC-2460].  If the packet is larger
   than the minimum MTU and this feature has been enabled the IP layer
   will fragment to the minimum MTU.  To control the policy about path
   MTU discovery, applications can use the IPV6_USE_MIN_MTU socket
   option.
   この仕様書は最小IPv6MTU[RFC-2460]を送りパスMTU探索を避ける
   メカニズムを定義します。もしパケットが最小MTUより大きく、そしてこ
   の機能が利用可能なら、IPレイヤは最小MTUに分割するでしょう。パス
   MTU探索のポリシを制御するために、アプリケーションはIPV6_USE_MIN_MTU
   ソケットオプションを使うことができます。

   As described above, the default policy should depend on whether the
   destination is unicast or multicast.  For unicast destinations path
   MTU discovery should be performed by default.  For multicast
   destinations path MTU discovery should be disabled by default.  This
   option thus takes the following three types of integer arguments:
   上記のように、デフォルトポリシは宛先がユニキャストかマルチキャストか
   によるべきです。ユニキャスト宛先のパスMTU探索がデフォルトで行われ
   るべきです。マルチキャスト宛先のパスMTU探索はデフォルトで行わない
   べきです。このオプションはそれで次の3つのタイプの整数引数をとります:

   -1: perform path MTU discovery for unicast destinations but do not
       perform it for multicast destinations.  Packets to multicast
       destinations are therefore sent with the minimum MTU.
   -1: ユニキャスト宛先でパスMTU探索を行ってください、しかしマルチキャ
       スト宛先で行わないでください。従ってマルチキャスト宛先へのパケット
       が最小MTUで送られます。

   0: always perform path MTU discovery.
   0: 常にパスMTU探索を行ってください。

   1: always disable path MTU discovery and send packets at the minimum
       MTU.
   1: 常にパスMTU探索をせず、そしてパケットを最小MTUで送ってください。

   The default value of this option is -1.  Values other than -1, 0, and
   1 are invalid, and an error EINVAL will be returned for those values.
   このオプションのデフォルト値は-1です。-1と0と1以外の値は無効で、それ
   らの値でエラーEINVALが返されるでしょう。

   As an example, if a unicast application intentionally wants to
   disable path MTU discovery, it will add the following lines:
   例えば、もしユニキャストアプリケーションが意図的にパスMTU探索を止
   めることを望むなら、次の行を加えるでしょう:。

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_USE_MIN_MTU, &on, sizeof(on));

   Note that this API intentionally excludes the case where the
   application wants to perform path MTU discovery for multicast but to
   disable it for unicast.  This is because such usage is not feasible
   considering a scale of performance issues around whether to do path
   MTU discovery or not.  When path MTU discovery makes sense to a
   destination but not to a different destination, regardless of whether
   the destination is unicast or multicast, applications either need to
   toggle the option between sending such packets on the same socket, or
   use different sockets for the two classes of destinations.
   このAPIが意図的にアプリケーションがマルチキャストのパスMTU探索
   を行うが、ユニキャストで行わないことを望む場合を除くことに注意してく
   ださい。これはMTU探索をするべきかどうかに関するパフォーマンス問題
   のスケールを考えると、このような使用法がありそうもないからです。パス
   MTU探索がある宛先に意味があり、他の宛先に意味がない時、宛先がユニ
   キャストかマルチキャストかにかかわらず、アプリケーションがこのような
   パケットを同じソケットの上で送る時にオプションをつけたり消したりする
   か、宛先の2つのクラスに異なったソケットを使う必要があります。

   This option can also be sent as ancillary data.  In the cmsghdr
   structure containing this ancillary data, the cmsg_level member will
   be IPPROTO_IPV6, the cmsg_type member will be IPV6_USE_MIN_MTU, and
   the first byte of cmsg_data[] will be the first byte of the integer.
   このオプションは補助的なデータとして送ることができます。この補助的な
   データを含んでいるcmsghdr構造体で、cmsg_levelメンバはIPPROTO_IPV6で、
   cmsg_typeメンバはIPV6_USE_MIN_MTUで、cmsg_data[]の最初のバイトは整数
   の最初のバイトであるでしょう。

11.2.  Sending without Fragmentation
11.2.  分割なしの送信

   In order to provide for easy porting of existing UDP and raw socket
   applications IPv6 implementations will, when originating packets,
   automatically insert a fragment header in the packet if the packet is
   too big for the path MTU.
   既存のUDPと生ソケットアプリケーションを容易に移植可能にするらめに、
   IPv6実装はパケット送信時にもしパケットがパスMTUに対して大きす
   ぎるのならば、自動的に分割ヘッダをパケットに挿入します。

   Some applications might not want this behavior.  An example is
   traceroute which might want to discover the actual path MTU.
   あるアプリケーションがこの行動を欲しないかもしれません。例えば、実際
   のパスMTUを発見することを望むかもしれない、tracerouteです。

   This specification defines a mechanism to turn off the automatic
   inserting of a fragment header for UDP and raw sockets.  This can be
   enabled using the IPV6_DONTFRAG socket option.
   この仕様書はUDPと生ソケットで分割ヘッダを自動的に挿入することを止
   めるメカニズムを定義します。これはIPV6_DONTFRAGソケットオプションを
   使って使用可能です。

      int on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_DONTFRAG, &on, sizeof(on));

   By default, this socket option is disabled.  Setting the value to 0
   also disables the option i.e., reverts to the default behavior of
   automatic inserting.  This option can also be sent as ancillary data.
   In the cmsghdr structure containing this ancillary data, the
   cmsg_level member will be IPPROTO_IPV6, the cmsg_type member will be
   IPV6_DONTFRAG, and the first byte of cmsg_data[] will be the first
   byte of the integer.  This API only specifies the use of this option
   for UDP and raw sockets, and does not define the usage for TCP
   sockets.
   デフォルトでこのソケットオプションは使用不可です。同じく値に0を設定
   することはオプションを止めます、すなわち、自動的な差し込むデフォルト
   行動に逆戻りします。このオプションは同じく補助的なデータとして送るこ
   とができます。この補助的なデータを含んでいるcmsghdr構造体で、
   cmsg_levelメンバはIPPROTO_IPV6で、cmsg_typeメンバはIPV6_DONTFRAGで
   cmsg_data[]の最初のバイトは整数の最初のバイトであるでしょう。このAP
   IはUDPと生ソケットのこのオプションの用途を指定するだけであり、そ
   してTCPソケットでの使用法を定義しません。

   When the data size is larger than the MTU of the outgoing interface,
   the packet will be discarded.  Applications can know the result by
   enabling the IPV6_RECVPATHMTU option described below and receiving
   the corresponding ancillary data items.  An additional error EMSGSIZE
   may also be returned in some implementations.  Note, however, that
   some other implementations might not be able to return this
   additional error when sending a message.
   データ大きさが出インタフェースのMTUより大きい時、パケットは捨てら
   れるでしょう。アプリケーションが下に記述されたIPV6_RECVPATHMTUオプショ
   ンを使用可能にし、そして対応する補助的なデータ項目を受け取ることによっ
   て結果を知ることができます。追加のエラーEMSGSIZEが同じくある実装で返
   されるかもしれません。しかしながら、何か他の実装がメッセージを送る時、
   この追加のエラーを返すことが可能ではないかもしれないことに注意してく
   ださい。

11.3.  Path MTU Discovery and UDP
11.3.  パスMTU探索とUDP

   UDP and raw socket applications need to be able to  determine the
   "maximum send transport-message size" (Section 5.1 of [RFC-1981]) to
   a given destination so that those applications can participate in
   path MTU discovery.  This lets those applications send smaller
   datagrams to the destination, avoiding fragmentation.
   UDPと生ソケットアプリケーションが、それらのアプリケーションがパス
   MTU探索に参加することができるように、与えられた宛先の「最大送信転
   送メッセージサイズ」([RFC-1981]の5.1章)を決定することが可能である
   必要があります。これは、分割を避け、アプリケーションが目的地により小
   さいデータグラムを送らせます。

   This is accomplished using a new ancillary data item (IPV6_PATHMTU)
   which is delivered to recvmsg() without any actual data.  The
   application can enable the receipt of IPV6_PATHMTU ancillary data
   items by setting the IPV6_RECVPATHMTU socket option.
   これは実際のデータなしでrecvmsg()に配達される新しい補助的なデータ項目
   (IPV6_PATHMTU )を使って達成されています。アプリケーションは
   IPV6_RECVPATHMTUソケットオプションを設定することによってIPV6_PATHMTU
   補助的なデータ項目の受信を可能にすることができます。

      int  on = 1;
      setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPATHMTU, &on, sizeof(on));

   By default, this socket option is disabled.  Setting the value to 0
   also disables the option.  This API only specifies the use of this
   option for UDP and raw sockets, and does not define the usage for TCP
   sockets.
   デフォルトで、このソケットオプションは停止です。同じく値を0に設定す
   ることではオプションは停止です。このAPIはただUDPと生ソケットの
   オプションの用途を指定するだけで、TCPソケットの使用法を定義しませ
   ん。

   When the application is sending packets too big for the path MTU
   recvmsg() will return zero (indicating no data) but there will be a
   cmsghdr with cmsg_type set to IPV6_PATHMTU, and cmsg_len will
   indicate that cmsg_data is sizeof(struct ip6_mtuinfo) bytes long.
   This can happen when the sending node receives a corresponding ICMPv6
   packet too big error, or when the packet is sent from a socket with
   the IPV6_DONTFRAG option being on and the packet size is larger than
   the MTU of the outgoing interface.  This indication is considered as
   an ancillary data item for a separate (empty) message.  Thus, when
   there are buffered messages (i.e., messages that the application has
   not received yet) on the socket the application will first receive
   the buffered messages and then receive the indication.
   アプリケーションがパスMTUに比べて大きいパケットを送るとき、
   recvmsg()はゼロを返します(データを示さない)、しかしcmsg_typeが
   IPV6_PATHMTUに設定され、cmsg_lenがcmsg_dataがsizeof(struct ip6_mtuinfo)
   バイトである事を示すcmsghdrがあるでしょう。これは、送信ノードが対応す
   るあまりにも大きいパケットICMPv6エラーを受信したか、ソケットか
   らIPV6_DONTFRAGオプション付きで送ったパケットがありパケットサイズが出
   インターフェースのMTUより大きいときに起こります。この表示は別の
   (空)メッセージの補助的なデータ項目として考えられます。それで、ソケッ
   ト上にバッファに入れられたメッセージ(すなわち、アプリケーションがま
   だ受信していないメッセージ)がある時がある時、アプリケーションは最初
   にバッファに入れられたメッセージを受け取って、そして次に表示を受け取
   るでしょう。

   The first byte of cmsg_data[] will point to a struct ip6_mtuinfo
   carrying the path MTU to use together with the IPv6 destination
   address.
   cmsg_data[]の最初のバイトは、IPv6宛先アドレスと使うべきパスMTU
   を運んでいるip6_mtuinfo構造体を示すでしょう。

      struct ip6_mtuinfo {
        struct sockaddr_in6 ip6m_addr; /* dst address including
                                          zone ID */
        uint32_t            ip6m_mtu;  /* path MTU in host byte order */
      };

   This cmsghdr will be passed to every socket that sets the
   IPV6_RECVPATHMTU socket option, even if the socket is non-connected.
   Note that this also means an application that sets the option may
   receive an IPV6_MTU ancillary data item for each ICMP too big error
   the node receives, including such ICMP errors caused by other
   applications on the node.  Thus, an application that wants to perform
   the path MTU discovery by itself needs to keep history of
   destinations that it has actually sent to and to compare the address
   returned in the ip6_mtuinfo structure to the history.  An
   implementation may choose not to delivery data to a connected socket
   that has a foreign address that is different than the address
   specified in the ip6m_addr structure.
   たとえソケットが接続されていないとしても、IPV6_RECVPATHMTUソケットオ
   プションをつけるすべてのソケットで、このcmsghdrは渡されるでしょう。こ
   れがオプションを設定するアプリケーションは、他のアプリケーションによっ
   てノードが受取るICMPエラーを含めて、ノードが受ける各ICMP大き
   すぎエラーに対してIPV6_MTU補助的なデータ項目を受け取るかもしれないこ
   とに注意してください。それで、パスMTU探索を行うことを望むアプリケー
   ションは実際に要求した宛先の履歴を保持し、ip6_mtuinfo構造体で返された
   アドレスを履歴と比較する必要があります。実装がip6m_addr構造体で指定さ
   れたアドレスと異なる外のアドレスを持つ接続されたソケットにデータを配
   達しない選択をするかもしれません。

   When an application sends a packet with a routing header, the final
   destination stored in the ip6m_addr member does not necessarily
   contain complete information of the entire path.
   アプリケーションがルーティングヘッダでパケットを送る時、ip6m_addrメン
   バで保管された最終宛先は必ずしも全部のパスの完全な情報を含んでいませ
   ん。

11.4.  Determining the Current Path MTU
11.4.  現在のパスMTUの決定

   Some applications might need to determine the current path MTU e.g.,
   applications using IPV6_RECVPATHMTU might want to pick a good
   starting value.
   あるアプリケーションが現在のパスMTUを決定する必要があるかもしれま
   せん、例えば、IPV6_RECVPATHMTUを使っているアプリケーションが良い初期
   値を選ぶことを望むかもしれません。

   This specification defines a get-only socket option to retrieve the
   current path MTU value for the destination of a given connected
   socket.  If the IP layer does not have a cached path MTU value it
   will return the interface MTU for the interface that will be used
   when sending to the destination address.
   この仕様書は与えられた接続されたソケットの宛先の現在のパスMTU値を
   得る、取得のみのソケットオプションを定義します。もしIPレイヤがキャッ
   シュしたパスMTU値を持っていないなら、宛先アドレスに送るときに使う
   であろうインタフェースのインタフェースMTUを返すでしょう。

   This information is retrieved using the IPV6_PATHMTU socket option.
   This option takes a pointer to the ip6_mtuinfo structure as the
   fourth argument, and the size of the structure should be passed as a
   value-result parameter in the fifth argument.
   この情報はIPV6_PATHMTUソケットオプションを使って得られます。このオプ
   ションは4番目の引数としてip6_mtuinfo構造体へのポインタをとり、そして
   構造体の大きさは5番目の引数の値結果パラメータとして渡されるべきです。

      struct ip6_mtuinfo mtuinfo;
      socklen_t infolen = sizeof(mtuinfo);

      getsockopt(fd, IPPROTO_IPV6, IPV6_PATHMTU, &mtuinfo, &infolen);

   When the call succeeds, the path MTU value is stored in the ip6m_mtu
   member of the ip6_mtuinfo structure.  Since the socket is connected,
   the ip6m_addr member is meaningless and should not be referred to by
   the application.
   呼び出しが成功する時、パスMTU値はip6_mtuinfo構造体のip6m_mtuメンバ
   にしまっておかれます。ソケットが接続されているので、ip6m_addrメンバは
   無意味で、そしてアプリケーションが参照すべきではありません。

   This option can only be used for a connected socket, because a non-
   connected socket does not have the information of the destination and
   there is no way to pass the destination via getsockopt().  When
   getsockopt() for this option is issued on a non-connected socket, the
   call will fail.  Despite this limitation, this option is still useful
   from a practical point of view, because applications that care about
   the path MTU tend to send a lot of packets to a single destination
   and to connect the socket to the destination for performance reasons.
   If the application needs to get the MTU value in a more generic way,
   it should use a more generic interface, such as routing sockets
   [TCPIPILLUST].
   このオプションは接続されたソケットにだけ使うことができます、なぜなら
   接続していないソケットは宛先情報を持たず、getsockopt()で宛先を渡す方
   法がないからです。このオプションのgetsockopt()が接続されていないソケッ
   ト上で行われるとき、呼出は失敗するでしょう。この限界にもかかわらず、
   このオプションは実務的な見地からまだ有用です、なぜならパスMTUを気
   にするアプリケーションがひとつの宛先に多くのパケットを送り、そして性
   能上の理由でソケットを宛先に接続する傾向がありますから。もしアプリケー
   ションがより一般的な方法でMTU値を得る必要があるなら、ルーティング
   ソケット[TCPIPILLUST]のようなより一般的なインタフェースを使うべきです。

12.  Ordering of Ancillary Data and IPv6 Extension Headers
12.  補助的なデータとIPv6拡張ヘッダの順序

   Three IPv6 extension headers can be specified by the application and
   returned to the application using ancillary data with sendmsg() and
   recvmsg(): the Routing header, Hop-by-Hop options header, and
   Destination options header.  When multiple ancillary data objects are
   transferred via recvmsg() and these objects represent any of these
   three extension headers, their placement in the control buffer is
   directly tied to their location in the corresponding IPv6 datagram.
   For example, when the application has enabled the IPV6_RECVRTHDR and
   IPV6_RECVDSTOPTS options and later receives an IPv6 packet with
   extension headers in the following order:
   sendmsg()とrecvmsg()で補助的なデータを使って、3つのIPv6拡張子ヘッ
   ダをアプリケーションが指定でき、アプリケーションに戻ります:ルーティ
   ングヘッダ、ホップ毎オプションヘッダ、宛先オプションヘッダ。多数の補
   助的なデータオブジェクトがrecvmsg()によって転送され、そしてこれらのオ
   ブジェクトがこれらの3つの拡張ヘッダのどれかを表す時、それらの制御バッ
   ファでの位置は対応するIPv6データグラムでの位置に直接結び付けられ
   ます。例えば、アプリケーションがIPV6_RECVRTHDRとIPV6_RECVDSTOPTSオプ
   ションを使用可能にし、そして次の順序の拡張ヘッダのIPv6パケットを
   受け取る時:

      The IPv6 header                      IPv6ヘッダ
      A Hop-by-Hop options header          ホップ毎オプションヘッダ
      A Destination options header (1)     宛先オプションヘッダ(1)
      A Routing header                     ルーティングヘッダ
      An Authentication header             認証ヘッダ
      A Destination options header (2)     宛先オプションヘッダ(2)
      A UDP header and UDP data            UDPヘッダーとUDPデータ

   then the application will receive three ancillary data objects in the
   following order:
   アプリケーションは次の順序で3つの補助的なデータオブジェクトを受け取
   るでしょう:

      an object with cmsg_type set to IPV6_DSTOPTS, which represents
      the destination options header (1)
      cmsg_typeがIPV6_DSTOPTSのオブジェクト、宛先オプションヘッダ(1)
      を表す。
      an object with cmsg_type set to IPV6_RTHDR, which represents the
      Routing header
      cmsg_typeがIPV6_RTHDRのオブジェクト、ルーティングヘッダを表す。
      an object with cmsg_type set to IPV6_DSTOPTS, which represents the
      destination options header (2)
      cmsg_typeがIPV6_DSTOPTSのオブジェクト、宛先オプションヘッダ(2)
      を表す。

   This example follows the header ordering described in [RFC-2460], but
   the receiving side of this specification does not assume the
   ordering.  Applications may receive any numbers of objects in any
   order according to the ordering of the received IPv6 datagram.
   この例は[RFC-2460]で記述されたヘッダ順序に従います、しかしこの仕様書
   の受信側は順序を想定しません。アプリケーションが受信IPv6データグ
   ラムの順序に従い、様々な順序と数のオブジェクトを受け取るかもしれませ
   ん。

   For the sending side, however, this API imposes some ordering
   constraints according to [RFC-2460].  Applications using this API
   cannot make a packet with extension headers that do not follow the
   ordering.  Note, however, that this does not mean applications must
   always follow the restriction.  This is just a limitation in this API
   in order to give application programmers a guideline to construct
   headers in a practical manner.  Should an application need to make an
   outgoing packet in an arbitrary order about the extension headers,
   some other technique, such as the datalink interfaces BPF or DLPI,
   must be used.
   しかしながら、このAPIは送信側では[RFC-2460]に従って順序の制約を課
   します。このAPIを使うアプリケーションは順序に従わない拡張ヘッダの
   パケットを作ることができません。しかしながら、これがアプリケーション
   が常に制限に従う事を意味しないことに注意してください。これは現実的な
   方法でヘッダを組み立てるためにアプリケーションプログラマーにガイドラ
   インを与えるためのAPIの限界です。もしアプリケーションが拡張ヘッダ
   に任意の順序で外向パケットを作る必要があったなら、何か他の、データリ
   ンクインタフェースBPFやDLPIのような、テクニックが使われなくて
   はなりません。

   The followings are more details about the constraints:
   以下は制約についての詳細です:

   -  Each IPV6_xxx ancillary data object for a particular type of
      extension header can be specified at most once in a single control
      buffer.
   -  それぞれの特定のタイプの拡張ヘッダのためのIPV6_xxx補助的なデータオ
      ブジェクトは、ひとつの制御バッファで最大1つ指定できます。

   -  IPV6_xxx ancillary data objects can appear in any order in a
      control buffer, because there is no ambiguity of the ordering.
   -  順序にあいまい性がないので、IPV6_xxx補助的なデータオブジェクトが制
      御バッファで任意の順番で現われることができます。

   -  Each set of IPV6_xxx ancillary data objects and sticky options
      will be put in the outgoing packet along with the header ordering
      described in [RFC-2460].
   -  それぞれのIPV6_xxx補助的なデータオブジェクトと付随オプションのセッ
      トが[RFC-2460]で記述されたヘッダ順序で出パケットに入れられるでしょ
      う。

   -  An ancillary data object or a sticky option of IPV6_RTHDRDSTOPTS
      will affect the outgoing packet only when a Routing header is
      specified as an ancillary data object or a sticky option.
      Otherwise, the specified value for IPV6_RTHDRDSTOPTS will be
      ignored.
   -  補助的なデータオブジェクトあるいはIPV6_RTHDRDSTOPTSの付随オプショ
      ンが、ルーティングヘッダが補助的なデータオブジェクトあるいは付随
      オプションとして明示される時だけ、出パケットに影響を与えるでしょ
      う。さもなければ、 IPV6_RTHDRDSTOPTSで指定された値は無視されるで
      しょう。

   For example, when an application sends a UDP datagram with a control
   data buffer containing ancillary data objects in the following order:
   例えば、アプリケーションが、制御データバッファに次の順序で補助的なデー
   タオブジェクトを含めて、UDPデータグラムを送る時:

      an object with cmsg_type set to IPV6_DSTOPTS
      an object with cmsg_type set to IPV6_RTHDRDSTOPTS
      an object with cmsg_type set to IPV6_HOPOPTS

   and the sending socket does not have any sticky options, then the
   outgoing packet would be constructed as follows:
   そして送信しているソケットは付随オプションを持っていないなら、出パケッ
   トは次のように組み立てられるでしょう:

      The IPv6 header
      A Hop-by-Hop options header
      A Destination options header
      A UDP header and UDP data

   where the destination options header corresponds to the ancillary
   data object with the type IPV6_DSTOPTS.
   宛先オプションヘッダは、タイプIPV6_DSTOPTSの補助的なデータオブジェク
   トに対応します。

   Note that the constraints above do not necessarily mean that the
   outgoing packet sent on the wire always follows the header ordering
   specified in this API document.  The kernel may insert additional
   headers that break the ordering as a result.  For example, if the
   kernel supports Mobile IPv6, an additional destination options header
   may be inserted before an authentication header, even without a
   routing header.
   上記の制約は、ワイヤ上へ送るの出パケットが、このAPI文書で指定した
   ヘッダ順序に常に従う事を必要とする事を意味しません。カーネルは結果と
   して順序を壊す追加のヘッダを挿入するかもしれません。例えば、もしカー
   ネルがモバイルIPv6をサポートするなら、ルーティングヘッダがなくて
   も、追加の宛先オプションヘッダが認証ヘッダの前に挿入されるかもしれま
   せん。

   This API does not provide access to any other extension headers than
   the supported three types of headers.  In particular, no information
   is provided about the IP security headers on an incoming packet, nor
   can be specified for an outgoing packet.  This API is for
   applications that do not care about the existence of IP security
   headers.
   このAPIは、サポートされる3つのタイプのヘッダ以外の拡張ヘッダへの
   アクセスを供給しません。特に、入パケットのIPセキュリティヘッダの情
   報の供給や、出パケットでの指定がありません。このAPIはIPセキュリ
   ティヘッダの存在を気にしないアプリケーションのためです。

13.  IPv6-Specific Options with IPv4-Mapped IPv6 Addresses
13.  IPv4マップIPv6アドレスのIPv6固有オプション

   The various socket options and ancillary data specifications defined
   in this document apply only to true IPv6 sockets.  It is possible to
   create an IPv6 socket that actually sends and receives IPv4 packets,
   using IPv4-mapped IPv6 addresses, but the mapping of the options
   defined in this document to an IPv4 datagram is beyond the scope of
   this document.
   種々なソケットオプションとこの文書で定義された補助的なデータ仕様書は
   正真正銘のIPv6ソケットにだけ当てはまります。IPv4マップIPv
   6アドレスを使って、実際にはIPv4パケットを送信受信する、IPv6
   ソケットを作ることは可能です、しかしIPv4データグラムへのこの文書
   で定義されたオプションのマッピングはこの文書の対象外です。

   In general, attempting to specify an IPv6-only option, such as the
   Hop-by-Hop options, Destination options, or Routing header on an IPv6
   socket that is using IPv4-mapped IPv6 addresses, will probably result
   in an error.  Some implementations, however, may provide access to
   the packet information (source/destination address, send/receive
   interface, and hop limit) on an IPv6 socket that is using IPv4-mapped
   IPv6 addresses.
   一般に、ホップ毎オプションや宛先オプションやルーティングヘッダのよう
   な、IPv6だけのオプションを、IPv4マップIPv6アドレスを使っ
   ているIPv6ソケット上で指定しようとする試みは、恐らくエラーをもた
   らすでしょう。ある実装が、しかしながら、IPv4マップIPv6アドレ
   スを使っているIPv6ソケットで、パケット情報(ソース/宛先アドレス
   と送信/受信インタフェースとホップ限界)へのアクセスを供給するかもし
   れません。

14.  Extended interfaces for rresvport, rcmd and rexec
14.  rresvportとrcmdとrexecののインタフェース拡張

   Library functions that support the "r" commands hide the creation of
   a socket and the name resolution procedure from an application.  When
   the libraries return an AF_INET6 socket to an application that do not
   support the address family, the application may encounter an
   unexpected result when, e.g., calling getpeername() for the socket.
   In order to support AF_INET6 sockets for the "r" commands while
   keeping backward compatibility, this section defines some extensions
   to the libraries.
   「r」コマンドをサポートするライブラリ関数がアプリケーションからソケッ
   トの作成と名前解決手順を隠します。ライブラリがアドレスファミリをサポー
   トしないアプリケーションにAF_INET6ソケットを返す時、アプリケーション
   は、例えばソケットのgetpeername()を呼び出すとき、意外な結果に遭遇する
   かもしれません。逆方向互換性を維持して、「r」コマンドのためのAF_INET6
   ソケットをサポートするために、この章はあるライブラリへの拡張を定義し
   ます。

14.1.  rresvport_af
14.1.  rresvport_af

   The rresvport() function is used by the rcmd() function, and this
   function is in turn called by many of the "r" commands such as
   rlogin.  While new applications are not being written to use the
   rcmd() function, legacy applications such as rlogin will continue to
   use it and these will be ported to IPv6.
   rresvport()関数はrcmd()関数から使われ、そしてこの関数はrloginのような
   「r」コマンドの多くによって呼び出されます。新しいアプリケーションが
   rcmd()関数を使うよう書かれていなくても、rloginのような旧式アプリケー
   ションがこれを使い続けるでしょう、そしてこれらはIPv6に移植される
   でしょう。

   rresvport() creates an IPv4/TCP socket and binds a "reserved port" to
   the socket.  Instead of defining an IPv6 version of this function we
   define a new function that takes an address family as its argument.
   rresvport()がIPv4/TCPソケットを作り、ソケットへの「予約ポート」
   をバインドします。この関数のIPv6版を定義する代わりに、我々はアド
   レスファミリーを議論にとる新しい関数を定義します。

      #include <unistd.h>

      int  rresvport_af(int *port, int family);

   This function behaves the same as the existing rresvport() function,
   but instead of creating an AF_INET TCP socket, it can also create an
   AF_INET6 TCP socket.  The family argument is either AF_INET or
   AF_INET6, and a new error return is EAFNOSUPPORT if the address
   family is not supported.
   この関数の振舞いは既存のrresvport()関数と同様ですが、しかしAF_INET
   TCPソケットを作る代わりに、AF_INET6 TCPソケットを作ることができ
   ます。family引数はAF_INETやAF_INET6で、もしアドレスファミリーをサポー
   トしないなら、新しいエラーEAFNOSUPPORTが返り値です。

   (Note: There is little consensus on which header defines the
   rresvport() and rcmd() function prototypes.  4.4BSD defines it in
   <unistd.h>, others in <netdb.h>, and others don't define the function
   prototypes at all.)
   (ノート:どのヘッダがrresvport()とrcmd()関数プロトタイプを定義するか
   について、一致した意見がありません。4.4BSDが<unistd.h>で、他は
   <netdb.h>で、他は関数プロトタイプを定義しません)

14.2.  rcmd_af
14.2.  rcmd_af

   The existing rcmd() function can not transparently use AF_INET6
   sockets since an application would not be prepared to handle AF_INET6
   addresses returned by e.g., getpeername() on the file descriptor
   created by rcmd().  Thus a new function is needed.
   例えば、rcmd()によって作られたファイルディスクプリタ上でgetpeername()
   によって返されるAF_INET6アドレスを、アプリケーションが扱う用意ができ
   ないであろうから、既存のrcmd()関数は透過的にAF_INET6ソケットを使うこ
   とができません。それで新しい関数が必要とされます。

      int rcmd_af(char **ahost, unsigned short rport,
                  const char *locuser, const char *remuser,
                  const char *cmd, int *fd2p, int af)

   This function behaves the same as the existing rcmd() function, but
   instead of creating an AF_INET TCP socket, it can also create an
   AF_INET6 TCP socket.  The family argument is AF_INET, AF_INET6, or
   AF_UNSPEC.  When either AF_INET or AF_INET6 is specified, this
   function will create a socket of the specified address family.  When
   AF_UNSPEC is specified, it will try all possible address families
   until a connection can be established, and will return the associated
   socket of the connection.  A new error EAFNOSUPPORT will be returned
   if the address family is not supported.
   この関数の振舞いは既存のrcmd()関数と同様ですが、しかしAF_INET TCP
   ソケットを作る代わりに、AF_INET6 TCPソケットを作ることができます。
   family引数はAF_INETやAF_INET6やAF_UNSPECです。AF_INETかAF_INET6が指
   定される時、この関数は指定されたアドレスファミリのソケットを作るで
   しょう。AF_UNSPECが指定される時、これは接続が確立できるまで、すべての
   可能なアドレスファミリーを試み、そして接続に関連づけられたソケットを
   返すでしょう。もしアドレスファミリーをサポートしないなら、新しいエラー
   EAFNOSUPPORTが返り値です。

14.3.  rexec_af
14.3.  rexec_af

   The existing rexec() function can not transparently use AF_INET6
   sockets since an application would not be prepared to handle AF_INET6
   addresses returned by e.g., getpeername() on the file descriptor
   created by rexec().  Thus a new function is needed.
   アプリケーションがrexec()によって作られたファイルディスクプリタの上で、
   例えばgetpeername()によって返されるAF_INET6アドレスに対処する用意がで
   きないであろう時から、既存のrexec()関数は透過的にAF_INET6ソケットを使
   うことができません。それで新しい関数が必要とされます。

      int rexec_af(char **ahost, unsigned short rport, const char *name,
                   const char *pass, const char *cmd, int *fd2p, int af)

   This function behaves the same as the existing rexec() function, but
   instead of creating an AF_INET TCP socket, it can also create an
   AF_INET6 TCP socket.  The family argument is AF_INET, AF_INET6, or
   AF_UNSPEC.  When either AF_INET or AF_INET6 is specified, this
   function will create a socket of the specified address family.  When
   AF_UNSPEC is specified, it will try all possible address families
   until a connection can be established, and will return the associated
   socket of the connection.  A new error EAFNOSUPPORT will be returned
   if the address family is not supported.
   この関数は既存のrexec()関数同様に振る舞いますが、AF_INET TCPソケッ
   ト作る代わりに、AF_INET6 TCPソケットを作ることができます。family引
   数はAF_INETかAF_INET6かAF_UNSPECです。AF_INETやAF_INET6が指定される時、
   この関数は指定されたアドレスファミリのソケットを作るでしょう。
   AF_UNSPECが指定される時、接続が確立されることができるまで、すべての可
   能なアドレスファミリーを試みるでしょう、そして接続に関連づけられたソ
   ケットを返すでしょう。新しいエラーEAFNOSUPPORTが、もしアドレスファミ
   リーをサポートしない時に、返されるでしょう。

15.  Summary of New Definitions
15.  新しい定義の要約

   The following list summarizes the constants and structure,
   definitions discussed in this memo, sorted by header.
   次のリストはこの文書で論じた定数と構造体と定義をヘッダ順で要約します。

      <netinet/icmp6.h> ICMP6_DST_UNREACH
      <netinet/icmp6.h> ICMP6_DST_UNREACH_ADDR
      <netinet/icmp6.h> ICMP6_DST_UNREACH_ADMIN
      <netinet/icmp6.h> ICMP6_DST_UNREACH_BEYONDSCOPE
      <netinet/icmp6.h> ICMP6_DST_UNREACH_NOPORT
      <netinet/icmp6.h> ICMP6_DST_UNREACH_NOROUTE
      <netinet/icmp6.h> ICMP6_ECHO_REPLY
      <netinet/icmp6.h> ICMP6_ECHO_REQUEST
      <netinet/icmp6.h> ICMP6_INFOMSG_MASK
      <netinet/icmp6.h> ICMP6_PACKET_TOO_BIG
      <netinet/icmp6.h> ICMP6_PARAMPROB_HEADER
      <netinet/icmp6.h> ICMP6_PARAMPROB_NEXTHEADER
      <netinet/icmp6.h> ICMP6_PARAMPROB_OPTION
      <netinet/icmp6.h> ICMP6_PARAM_PROB
      <netinet/icmp6.h> ICMP6_ROUTER_RENUMBERING
      <netinet/icmp6.h> ICMP6_RR_FLAGS_FORCEAPPLY
      <netinet/icmp6.h> ICMP6_RR_FLAGS_PREVDONE
      <netinet/icmp6.h> ICMP6_RR_FLAGS_REQRESULT
      <netinet/icmp6.h> ICMP6_RR_FLAGS_SPECSITE
      <netinet/icmp6.h> ICMP6_RR_FLAGS_TEST
      <netinet/icmp6.h> ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME
      <netinet/icmp6.h> ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME
      <netinet/icmp6.h> ICMP6_RR_PCOUSE_RAFLAGS_AUTO
      <netinet/icmp6.h> ICMP6_RR_PCOUSE_RAFLAGS_ONLINK
      <netinet/icmp6.h> ICMP6_RR_RESULT_FLAGS_FORBIDDEN
      <netinet/icmp6.h> ICMP6_RR_RESULT_FLAGS_OOB
      <netinet/icmp6.h> ICMP6_TIME_EXCEEDED
      <netinet/icmp6.h> ICMP6_TIME_EXCEED_REASSEMBLY
      <netinet/icmp6.h> ICMP6_TIME_EXCEED_TRANSIT
      <netinet/icmp6.h> MLD_LISTENER_QUERY
      <netinet/icmp6.h> MLD_LISTENER_REDUCTION
      <netinet/icmp6.h> MLD_LISTENER_REPORT
      <netinet/icmp6.h> ND_NA_FLAG_OVERRIDE
      <netinet/icmp6.h> ND_NA_FLAG_ROUTER
      <netinet/icmp6.h> ND_NA_FLAG_SOLICITED
      <netinet/icmp6.h> ND_NEIGHBOR_ADVERT
      <netinet/icmp6.h> ND_NEIGHBOR_SOLICIT
      <netinet/icmp6.h> ND_OPT_MTU
      <netinet/icmp6.h> ND_OPT_PI_FLAG_AUTO
      <netinet/icmp6.h> ND_OPT_PI_FLAG_ONLINK
      <netinet/icmp6.h> ND_OPT_PREFIX_INFORMATION
      <netinet/icmp6.h> ND_OPT_REDIRECTED_HEADER
      <netinet/icmp6.h> ND_OPT_SOURCE_LINKADDR
      <netinet/icmp6.h> ND_OPT_TARGET_LINKADDR
      <netinet/icmp6.h> ND_RA_FLAG_MANAGED
      <netinet/icmp6.h> ND_RA_FLAG_OTHER
      <netinet/icmp6.h> ND_REDIRECT
      <netinet/icmp6.h> ND_ROUTER_ADVERT
      <netinet/icmp6.h> ND_ROUTER_SOLICIT

      <netinet/icmp6.h> struct icmp6_filter{};
      <netinet/icmp6.h> struct icmp6_hdr{};
      <netinet/icmp6.h> struct icmp6_router_renum{};
      <netinet/icmp6.h> struct mld_hdr{};
      <netinet/icmp6.h> struct nd_neighbor_advert{};
      <netinet/icmp6.h> struct nd_neighbor_solicit{};
      <netinet/icmp6.h> struct nd_opt_hdr{};
      <netinet/icmp6.h> struct nd_opt_mtu{};
      <netinet/icmp6.h> struct nd_opt_prefix_info{};
      <netinet/icmp6.h> struct nd_opt_rd_hdr{};
      <netinet/icmp6.h> struct nd_redirect{};
      <netinet/icmp6.h> struct nd_router_advert{};
      <netinet/icmp6.h> struct nd_router_solicit{};
      <netinet/icmp6.h> struct rr_pco_match{};
      <netinet/icmp6.h> struct rr_pco_use{};
      <netinet/icmp6.h> struct rr_result{};

      <netinet/in.h>    IPPROTO_AH
      <netinet/in.h>    IPPROTO_DSTOPTS
      <netinet/in.h>    IPPROTO_ESP
      <netinet/in.h>    IPPROTO_FRAGMENT
      <netinet/in.h>    IPPROTO_HOPOPTS
      <netinet/in.h>    IPPROTO_ICMPV6
      <netinet/in.h>    IPPROTO_IPV6
      <netinet/in.h>    IPPROTO_NONE
      <netinet/in.h>    IPPROTO_ROUTING
      <netinet/in.h>    IPV6_CHECKSUM
      <netinet/in.h>    IPV6_DONTFRAG
      <netinet/in.h>    IPV6_DSTOPTS
      <netinet/in.h>    IPV6_HOPLIMIT
      <netinet/in.h>    IPV6_HOPOPTS
      <netinet/in.h>    IPV6_NEXTHOP
      <netinet/in.h>    IPV6_PATHMTU
      <netinet/in.h>    IPV6_PKTINFO
      <netinet/in.h>    IPV6_RECVDSTOPTS
      <netinet/in.h>    IPV6_RECVHOPLIMIT
      <netinet/in.h>    IPV6_RECVHOPOPTS
      <netinet/in.h>    IPV6_RECVPKTINFO
      <netinet/in.h>    IPV6_RECVRTHDR
      <netinet/in.h>    IPV6_RECVTCLASS
      <netinet/in.h>    IPV6_RTHDR
      <netinet/in.h>    IPV6_RTHDRDSTOPTS
      <netinet/in.h>    IPV6_RTHDR_TYPE_0
      <netinet/in.h>    IPV6_RECVPATHMTU
      <netinet/in.h>    IPV6_TCLASS
      <netinet/in.h>    IPV6_USE_MIN_MTU
      <netinet/in.h>    struct in6_pktinfo{};
      <netinet/in.h>    struct ip6_mtuinfo{};

      <netinet/ip6.h>   IP6F_MORE_FRAG
      <netinet/ip6.h>   IP6F_OFF_MASK
      <netinet/ip6.h>   IP6F_RESERVED_MASK
      <netinet/ip6.h>   IP6OPT_JUMBO
      <netinet/ip6.h>   IP6OPT_JUMBO_LEN
      <netinet/ip6.h>   IP6OPT_MUTABLE
      <netinet/ip6.h>   IP6OPT_NSAP_ADDR
      <netinet/ip6.h>   IP6OPT_PAD1
      <netinet/ip6.h>   IP6OPT_PADN
      <netinet/ip6.h>   IP6OPT_ROUTER_ALERT
      <netinet/ip6.h>   IP6OPT_TUNNEL_LIMIT
      <netinet/ip6.h>   IP6OPT_TYPE_DISCARD
      <netinet/ip6.h>   IP6OPT_TYPE_FORCEICMP
      <netinet/ip6.h>   IP6OPT_TYPE_ICMP
      <netinet/ip6.h>   IP6OPT_TYPE_SKIP
      <netinet/ip6.h>   IP6_ALERT_AN
      <netinet/ip6.h>   IP6_ALERT_MLD
      <netinet/ip6.h>   IP6_ALERT_RSVP
      <netinet/ip6.h>   struct ip6_dest{};
      <netinet/ip6.h>   struct ip6_frag{};
      <netinet/ip6.h>   struct ip6_hbh{};
      <netinet/ip6.h>   struct ip6_hdr{};
      <netinet/ip6.h>   struct ip6_opt{};
      <netinet/ip6.h>   struct ip6_opt_jumbo{};
      <netinet/ip6.h>   struct ip6_opt_nsap{};
      <netinet/ip6.h>   struct ip6_opt_router{};
      <netinet/ip6.h>   struct ip6_opt_tunnel{};
      <netinet/ip6.h>   struct ip6_rthdr{};
      <netinet/ip6.h>   struct ip6_rthdr0{};

   The following list summarizes the function and macro prototypes
   discussed in this memo, sorted by header.
   次のリストはこの文書で論じた関数とマクロプロトタイプをヘッダ順で要約
   します。

      <netinet/icmp6.h> void ICMP6_FILTER_SETBLOCK(int, struct
                                               icmp6_filter *);
      <netinet/icmp6.h> void
                        ICMP6_FILTER_SETBLOCKALL(struct icmp6_filter *);
      <netinet/icmp6.h> void
                        ICMP6_FILTER_SETPASS(int,
                                             struct icmp6_filter *);
      <netinet/icmp6.h> void
                        ICMP6_FILTER_SETPASSALL(struct icmp6_filter *);
      <netinet/icmp6.h> int  ICMP6_FILTER_WILLBLOCK(int,
                                           const struct icmp6_filter *);
      <netinet/icmp6.h> int  ICMP6_FILTER_WILLPASS(int,
                                           const struct icmp6_filter *);

      <netinet/in.h>    int IN6_ARE_ADDR_EQUAL(const struct in6_addr *,
                                           const struct in6_addr *);

      <netinet/in.h>    int inet6_opt_append(void *, socklen_t, int,
                                             uint8_t, socklen_t, uint_t,
                                             void **);
   訳注:RFC誤植情報によると、"uint_t"は"uint8_t"が正しいそうです。
      <netinet/in.h>    int inet6_opt_get_val(void *, int, void *,
                                              socklen_t);
      <netinet/in.h>    int inet6_opt_find(void *, socklen_t,
                                           int, uint8_t ,
                                           socklen_t *, void **);
      <netinet/in.h>    int inet6_opt_finish(void *, socklen_t, int);
      <netinet/in.h>    int inet6_opt_init(void *, socklen_t);
      <netinet/in.h>    int inet6_opt_next(void *, socklen_t,
                                           int, uint8_t *,
                                           socklen_t *, void **);
      <netinet/in.h>    int inet6_opt_set_val(void *, int,
                                              void *, socklen_t);

      <netinet/in.h>    int inet6_rth_add(void *,
                                          const struct in6_addr *);
      <netinet/in.h>    struct in6_addr inet6_rth_getaddr(const void *,
                                                          int);
      <netinet/in.h>    void *inet6_rth_init(void *, socklen_t,
                                             int, int);
      <netinet/in.h>    int inet6_rth_reverse(const void *, void *);
      <netinet/in.h>    int inet6_rth_segments(const void *);
      <netinet/in.h>    soccklen_t inet6_rth_space(int, int);

      <netinet/ip6.h>   int  IP6OPT_TYPE(uint8_t);

      <sys/socket.h>    socklen_t CMSG_LEN(socklen_t);
      <sys/socket.h>    socklen_t CMSG_SPACE(socklen_t);

      <unistd.h>        int rresvport_af(int *, int);
      <unistd.h>        int rcmd_af(char **, unsigned short,
                                    const char *, const char *,
                                    const char *, int *, int);
      <unistd.h>        int rexec_af(char **, unsigned short,
                                     const char *, const char *,
                                     const char *, int *, int);

16.  Security Considerations
16.  セキュリティの考慮

   The setting of certain Hop-by-Hop options and Destination options may
   be restricted to privileged processes.  Similarly some Hop-by-Hop
   options and Destination options may not be returned to non-privileged
   applications.
   ある特定のホップ毎オプションと宛先オプションの設定は特権を与えられた
   プロセスに制限されるかもしれません。同様にあるのホップ毎オプションと
   宛先オプションが特権を与えられていないアプリケーションに返されないか
   もしれません。

   The ability to specify an arbitrary source address using IPV6_PKTINFO
   must be prevented; at least for non-privileged processes.
   IPV6_PKTINFOを使って任意のソースアドレスを指定する能力は、少なくとも
   特権を与えられていないプロセスで妨げられなくてはなりません。


17.  Changes from RFC 2292
17.  RFC2292からの変更

   Significant changes that affect the compatibility to RFC 2292:
   RFC2292と互換性に影響を与える重要な変更:

   -  Removed the IPV6_PKTOPTIONS socket option by allowing sticky
      options to be set with individual setsockopt() calls.
   -  個別のsetsockopt()呼び出しで付随オプションの設定を許すことで
      IPV6_PKTOPTIONSソケットオプションを除きました。

   -  Removed the ability to be able to specify Hop-by-Hop and
      Destination options using multiple ancillary data items.  The
      application, using the inet6_opt_xxx() routines (see below), is
      responsible for formatting the whole extension header.
   -  多数の補助的なデータ項目を使って、ホップ毎と宛先オプションを指定
      することが可能である能力を取り除きました。アプリケーションは
      inet6_opt_xxx()ルーチン (下記)を使い、拡張ヘッダ全体の形を決める
      責任があります。

   -  Removed the support for the loose/strict Routing header since that
      has been removed from the IPv6 specification.
   -  IPv6仕様書から取り除かれたので、ルーズ/厳格ルーティングヘッダ
      に対するサポートを取り去りました。

   -  Loosened the constraints for jumbo payload option that this option
      was always hidden from applications.
   -  このオプションが常にアプリケーションから隠されるというジャンボペイ
      ロードオプションの制約を緩めました。

   -  Disabled the use of the IPV6_HOPLIMIT sticky option.
   -  IPV6_HOPLIMIT付随オプションの使用を不可にしました。

   -  Removed ip6r0_addr field from the ip6_rthdr structure.
   -  ip6r0_addrフィールドをip6_rthdr構造体から取り除きました。

   -  Intentionally unspecified how to get received packet's information
      on TCP sockets.
   -  TCPソケットで受信パケットの情報を得る方法を意図的に特定しなくし
      ました。

   New features:
   新しい機能:

   -  Added IPV6_RTHDRDSTOPTS to specify a Destination Options header
      before the Routing header.
   -  ルーティングヘッダの前に宛先オプションヘッダを指定するために
      IPV6_RTHDRDSTOPTSを加えました。

   -  Added separate IPV6_RECVxxx options to enable the receipt of the
      corresponding ancillary data items.
   -  対応する補助的なデータ項目の受信を可能にする別のIPV6_RECVxxxオプ
      ションを加えました。

   -  Added inet6_rth_xxx() and inet6_opt_xxx() functions to deal with
      routing or IPv6 options headers.
   -  ルーティングあるいはIPv6オプションヘッダ加えるために、
      inet6_rth_xxx()とinet6_opt_xxx()関数を加えました。

   -  Added extensions of libraries for the "r" commands.
   -  「r」コマンドのためにライブラリの拡張を加えました。

   -  Introduced additional IPv6 option definitions such as IP6OPT_PAD1.
   -  IP6OPT_PAD1のような追加のIPv6オプション定義を導入しました。

   -  Added MLD and router renumbering definitions.
   -  MLDとルータリナンバリング定義を加えました。

   -  Added MTU-related socket options and ancillary data items.
   -  MTU関連のソケットオプションと補助的なデータ項目を加えました。

   -  Added options and ancillary data items to manipulate the traffic
      class field.
   -   トラフィッククラスフィールドを扱うためにオプションと補助的なデー
      タ項目を加えました。

   -  Changed the name of ICMPv6 unreachable code 2 to be "beyond scope
      of source address."  ICMP6_DST_UNREACH_NOTNEIGHBOR was removed
      with this change.
   -  ICMPv6到達不可コード2の名前を「ソースアドレスの範囲を越える」
      に変えました。ICMP6_DST_UNREACH_NOTNEIGHBORがこの変更で取り去られ
      ました。

   Clarifications:
   明確化:

   -  Added clarifications on extension headers ordering; for the
      sending side, assume the recommended ordering described in RFC
      2460.  For the receiving side, do not assume any ordering and pass
      all headers to the application in the received order.
   -  拡張ヘッダ順序の明確化を追加しました;送信側で、RFC2460で記
      述された推薦された注文を想定します。受信側で、順序を想定せず、そし
      て受信した順序でアプリケーションにすべてのヘッダを渡します。

   -  Added a summary about the interface selection rule.
   -  インタフェース選択規則に要約を加えました。

   -  Clarified the ordering between IPV6_MULTICAST_IF and the
      IPV6_PKTINFO sticky option for multicast packets.
   -  マルチキャストパケットで IPV6_MULTICAST_IFとIPV6_PKTINFO付随オプ
      ションの間の順序を明確にしました。

   -  Clarified how sticky options and the ICMPv6 filter are turned off
      and that getsockopt() of a sticky option returns what was set with
      setsockopt().
   -  どのように付随オプションとICMPv6フィルタが止められ、そして
      付随オプションのgetsockopt()の返りと、setsockopt()の設定を明白に
      しました。

   -  Clarified that IPV6_NEXTHOP should be ignored for a multicast
      destination, that it should not contradict with the specified
      outgoing interface, and that the next hop should be a sockaddr_in6
      structure.
   -  IPV6_NEXTHOPがマルチキャスト宛先で無視されるべきで、指定された出
      インタフェースと矛盾すべきでなく、そして次の転送先がsockaddr_in6
      構造体であるべきであることを明確にしました。

   -  Clarified corner cases of IPV6_CHECKSUM.
   -  IPV6_CHECKSUMの隅の場合を明確にしました。

   -  Aligned with the POSIX standard.
   -  POSIX標準と同じにそろえられました。

   Editorial changes:
   編集上の変更:

   -  Replaced MUST with must (since this is an informational document).
   -  (これが情報的な文書であるから)、MUSTをmustに変えました。

   -  Revised abstract to be more clear and concise, particularly
      concentrating on differences from RFC 2292.
   -  特にRFC2292からの相違に集中して、いっそう明確で簡潔に修正し
      た概要。

   -  Made the URL of assigned numbers less specific so that it would be
      more robust for future changes.
   -  未来の変更に対応できるように、特定していない割り当て番号URLを作
      りました。

   -  Updated the reference to the basic API.
   -  基本APIの参考文献を更新しました。

   -  Added a reference to the latest POSIX standard.
   -  最近のPOSIX標準を参考文献に加えました。

   -  Moved general specifications of ancillary data and CMSG macros to
      the appendix.
   -  補助的なデータとCMSGマクロの一般的な仕様を付録に動かしました。


18.  References
18.  参考文献

   [RFC-1981]    McCann, J., Deering, S. and J. Mogul, "Path MTU
                 Discovery for IP version 6", RFC 1981, August 1996.

   [RFC-2460]    Deering, S. and R. Hinden, "Internet Protocol, Version
                 6 (IPv6) Specification", RFC 2460, December 1998.

   [RFC-3493]    Gilligan, R., Thomson, S., Bound, J., McCann, J.  and
                 W. Stevens, "Basic Socket Interface Extensions for
                 IPv6", RFC 3493, March 2003.

   [POSIX]       IEEE Std. 1003.1-2001 Standard for Information
                 Technology -- Portable Operating System Interface
                 (POSIX). Open group Technical Standard: Base
                 Specifications, Issue 6, December 2001. ISO/IEC
                 9945:2002. http://www.opengroup.org/austin

   [TCPIPILLUST] Wright, G., Stevens, W., "TCP/IP Illustrated, Volume 2:
                 The Implementation", Addison Wesley, 1994.

19.  Acknowledgments
19.  謝辞

   Matt Thomas and Jim Bound have been working on the technical details
   in this document for over a year.  Keith Sklower is the original
   implementor of ancillary data in the BSD networking code.  Craig Metz
   provided lots of feedback, suggestions, and comments based on his
   implementing many of these features as the document was being
   written.  Mark Andrews first proposed the idea of the
   IPV6_USE_MIN_MTU option.  Jun-ichiro Hagino contributed text for the
   traffic class API from a document of his own.
   Matt ThomasとJim Boundは1以上年のこの文書で技術的な細部に取り組んで
   いました。Keith SklowerはBSDネットワーキングコードで補助的なデータ
   のオリジナルの実装者です。Craig Metzは、文書が書かれていたようにこれ
   らの機能の多くを実装することに基づいて行なわれた、たくさんのフィード
   バックと示唆とコメントを供給しました。Mark Andrewsは最初に
   IPV6_USE_MIN_MTUオプションの考えを提案しました。Jun-ichiro Haginoは彼
   自身の文書からトラフィッククラスAPIのテキストを提供しました。

   The following provided comments on earlier drafts: Pascal Anelli,
   Hamid Asayesh, Ran Atkinson, Karl Auerbach, Hamid Asayesh, Don
   Coolidge, Matt Crawford, Sam T. Denton, Richard Draves, Francis
   Dupont, Toerless Eckert, Lilian Fernandes, Bob Gilligan, Gerri
   Harter, Tim Hartrick, Bob Halley, Masaki Hirabaru, Michael Hunter,
   Yoshinobu Inoue, Mukesh Kacker, A. N. Kuznetsov, Sam Manthorpe, Pedro
   Marques, Jack McCann, der Mouse, John Moy, Lori Napoli, Thomas
   Narten, Atsushi Onoe, Steve Parker, Charles Perkins, Ken Powell, Tom
   Pusateri, Pedro Roque, Sameer Shah, Peter Sjodin, Stephen P.
   Spackman, Jinmei Tatuya, Karen Tracey, Sowmini Varadhan, Quaizar
   Vohra, Carl Williams, Steve Wise, Eric Wong, Farrell Woods, Kazu
   Yamamoto, Vladislav Yasevich, and Yoshifuji Hideaki.
   以下が前のドラフトにコメントを供給しました:Pascal Anelli,
   Hamid AsayeshとRan AtkinsonとKarl AuerbachとHamid AsayeshとDon
   CoolidgeとMatt CrawfordとSam T. DentonとRichard DravesとFrancis
   DupontとToerless EckertとLilian FernandesとBob GilliganとGerri
   HarterとTim HartrickとBob HalleyとMasaki HirabaruとMichael Hunterと
   Yoshinobu InoueとMukesh KackerとA. N. KuznetsovとSam ManthorpeとPedro
   MarquesとJack McCannとder MouseとJohn MoyとLori NapoliとThomas
   NartenとAtsushi OnoeとSteve ParkerとCharles PerkinsとKen PowellとTom
   PusateriとPedro RoqueとSameer ShahとPeter SjodinとStephen P.
   SpackmanとJinmei TatuyaとKaren TraceyとSowmini VaradhanとQuaizar
   VohraとCarl WilliamsとSteve WiseとEric WongとFarrell WoodsとKazu
   YamamotoとVladislav YasevichとYoshifuji Hideaki.

20.  Appendix A: Ancillary Data Overview
20.  付録A:補助的データの概要

   4.2BSD allowed file descriptors to be transferred between separate
   processes across a UNIX domain socket using the sendmsg() and
   recvmsg() functions.  Two members of the msghdr structure,
   msg_accrights and msg_accrightslen, were used to send and receive the
   descriptors.  When the OSI protocols were added to 4.3BSD Reno in
   1990 the names of these two fields in the msghdr structure were
   changed to msg_control and msg_controllen, because they were used by
   the OSI protocols for "control information", although the comments in
   the source code call this "ancillary data".
   4.2BSDがsendmsg()とrecvmsg()関数使ってUNIXドメインソケットを
   通しての異なるプロセス間でのファイルディスクプリタの転送を許しました。
   msghdr構造体のmsg_accrightsとmsg_accrightslenの2人のメンバがディスク
   プリタの送受信に使われました。1990年にOSIプロトコルが4.3BS
   DのRenoに加えられた時、ソースコードのコメントがこれを「補助的な
   データ」と呼んでいましたが、OSIプロトコルで「制御情報」に使うため、
   これらのmsghdr構造体の2つのフィールドの名前はmsg_controlと
   msg_controllenに変更されました。

   Other than the OSI protocols, the use of ancillary data has been
   rare.  In 4.4BSD, for example, the only use of ancillary data with
   IPv4 is to return the destination address of a received UDP datagram
   if the IP_RECVDSTADDR socket option is set.  With Unix domain sockets
   ancillary data is still used to send and receive descriptors.
   OSIプロトコル以外に、補助的なデータの使用はほとんどありませんでし
   た。4.4BSDで、例えば、唯一のIPv4の補助的なデータの使用は、も
   しIP_RECVDSTADDRソケットオプションが設定されているなら、受信UDPデー
   タグラムの宛先アドレスを返す事です。UNIXドメインソケットで補助的
   なデータがディスクプリタを送受信するためにまだ使われています。

   Nevertheless the ancillary data fields of the msghdr structure
   provide a clean way to pass information in addition to the data that
   is being read or written.  The inclusion of the msg_control and
   msg_controllen members of the msghdr structure along with the cmsghdr
   structure that is pointed to by the msg_control member is required by
   the Posix sockets API standard.
   しかしmsghdr構造体の補助的なデータフィールドは読み書きするデータ以外
   の情報を渡すクリーンな方法を供給します。msg_controlメンバーによって示
   されるcmsghdr構造体と共にmsghdr構造体のmsg_controlとmsg_controllenメ
   ンバの包含はPosixソケットAPI標準で必要とされます。

20.1.  The msghdr Structure
20.1.  msghdr構造体

   The msghdr structure is used by the recvmsg() and sendmsg()
   functions.  Its Posix definition is:
   msghdr構造体はrecvmsg()とsendmsg()関数で使われます。Posixの定義
   は以下です:

      struct msghdr {
        void      *msg_name;        /* ptr to socket address
                                       structure */
                                    /* ソケットアドレス構造体へのポインタ */
        socklen_t  msg_namelen;     /* size of socket address
                                       structure */
                                    /* ソケットアドレス構造体の大きさ */
        struct iovec  *msg_iov;     /* scatter/gather array */
                                    /* scatter/gather配列 */
        int        msg_iovlen;      /* # elements in msg_iov */
                                    /* msg_iovの#要素 */
        void      *msg_control;     /* ancillary data */
                                    /* 補助的なデータ */
        socklen_t  msg_controllen;  /* ancillary data buffer length */
                                    /* 補助的なデータバッファ長 */
        int        msg_flags;       /* flags on received message */
                                    /* 受信メッセージのフラグ */
      };

   The structure is declared as a result of including <sys/socket.h>.
   構造体は<sys/socket.h>で宣言されます。

   (Note: Before Posix the two "void *" pointers were typically "char
   *", and the two socklen_t members were typically integers.  Earlier
   drafts of Posix had the two socklen_t members as size_t, but it then
   changed these to socklen_t to simplify binary portability for 64-bit
   implementations and to align Posix with X/Open's Networking Services,
   Issue 5.  The change in msg_control to a "void *" pointer affects any
   code that increments this pointer.)
   (ノート:Posix以前では2つの"void *"ポインタは一般に"char *"で、
   2つのsocklen_tメンバは一般に整数でした。Posixの古いドラフトでは
   2つのsocklen_tメンバがsize_tでしたが、64ビット実装のバイナリポータ
   ビリティを単純化して、PosixをX/Openのネットワーキングサービスの
   5号とあわせるためsocklen_tに変わりなした。msg_controlの"void *"ポイ
   ンタへの変更はこのポインタを加算するコードに影響を与えます。)

   Most Berkeley-derived implementations limit the amount of ancillary
   data in a call to sendmsg() to no more than 108 bytes (an mbuf).
   This API requires a minimum of 10240 bytes of ancillary data, but it
   is recommended that the amount be limited only by the buffer space
   reserved by the socket (which can be modified by the SO_SNDBUF socket
   option).  (Note: This magic number 10240 was picked as a value that
   should always be large enough.  108 bytes is clearly too small as the
   maximum size of a Routing header is 2048 bytes.)
   たいていのバークレー系実装でsendmsg()呼び出しの補助的なデータの量を
   108バイト(mbuf)以下に制限します。このAPIは最小10240バイ
   トの補助的なデータを必要としますが、データ量制限が(SO_SNDBUFソケット
   オプションで修正できる)ソケットの予約バッファ空間にだけ依存すること
   を勧めます。(ノート:このマジックナンバー10240は常に十分多きな
   値として選ばれました。108バイトは、ルーティングヘッダの最大サイズ
   が2048バイトであるので、明らかにあまりにも小さいです。)

20.2.  The cmsghdr Structure
20.2.  cmsghdr構造体

   The cmsghdr structure describes ancillary data objects transferred by
   recvmsg() and sendmsg().  Its Posix definition is:
   cmsghdr構造体はrecvmsg()とsendmsg()で転送される補助的なデータオブジェ
   クトを記述します。Posixの定義は以下です:

      struct cmsghdr {
        socklen_t  cmsg_len;   /* #bytes, including this header */
                               /* このヘッダを含むバイト数 */
        int        cmsg_level; /* originating protocol */
                               /* 起動プロトコル */
        int        cmsg_type;  /* protocol-specific type */
                               /* プロトコル特有タイプ */
                   /* followed by unsigned char cmsg_data[]; */
                   /* unsigned char cmsg_data[];が続く */
      };

   This structure is declared as a result of including <sys/socket.h>.
   この構造体は<sys/socket.h>で宣言されます。

   (Note: Before Posix the cmsg_len member was an integer, and not a
   socklen_t.  See the Note in the previous section for why socklen_t is
   used here.)
   (メモ:Posix以前に、cmsg_lenメンバはsocklen_tではなく、整数で
   した。socklen_tがここで使われる理由は前章のメモを見てください。)

   As shown in this definition, normally there is no member with the
   name cmsg_data[].  Instead, the data portion is accessed using the
   CMSG_xxx() macros, as described in Section 20.3.  Nevertheless, it is
   common to refer to the cmsg_data[] member.
   この定義に示されるように、通常、名前cmsg_data[]にメンバーがありません。
   その代わりに、20.3章で記述するように、データ部はCMSG_xxx()マクロを
   使ってアクセスします。しかし、cmsg_data[]メンバーを参照するのが普通で
   す。

   When ancillary data is sent or received, any number of ancillary data
   objects can be specified by the msg_control and msg_controllen
   members of the msghdr structure, because each object is preceded by a
   cmsghdr structure defining the object's length (the cmsg_len member).
   Historically Berkeley-derived implementations have passed only one
   object at a time, but this API allows multiple objects to be passed
   in a single call to sendmsg() or recvmsg().  The following example
   shows two ancillary data objects in a control buffer.
   補助的なデータを送らる受信する時、それぞれのオブジェクトの前にオブ
   ジェクト長さ(cmsg_lenメンバー)を定義するcmsghdr構造体があるので、
   任意の数の補助的なデータオブジェクトがmsg_controlと、msghdr構造体の
   msg_controllenメンバーによって指定できます。歴史的にバークレー系の実
   装がただ1つのオブジェクトを渡していましたが、このAPIはひとつの呼
   び出しで多数のオブジェクトをsendmsg()やrecvmsg()へ渡すことを許します。
   次の例は制御バッファバッファに入れる2つの補助的なデータを示します。

|<--------------------------- msg_controllen ------------------------->|
|                                 OR                                   |
|<--------------------------- msg_controllen ---------------------->|
|                                                                      |
|<----- ancillary data object ----->|<---- ancillary data object ----->|
|<------ min CMSG_SPACE() --------->|<----- min CMSG_SPACE() --------->|
|                                   |                                  |
|<---------- cmsg_len ---------->|  |<-------- cmsg_len ----------->|  |
|<--------- CMSG_LEN() --------->|  |<------- CMSG_LEN() ---------->|  |
|                                |  |                               |  |
+-----+-----+-----+--+-----------+--+-----+-----+-----+--+----------+--+
|cmsg_|cmsg_|cmsg_|XX|   cmsg_   |XX|cmsg_|cmsg_|cmsg_|XX|  cmsg_   |XX|
|len  |level|type |XX|   data[]  |XX|len  |level|type |XX|  data[]  |XX|
+-----+-----+-----+--+-----------+--+-----+-----+-----+--+----------+--+
^
|
msg_control
points here

   The fields shown as "XX" are possible padding, between the cmsghdr
   structure and the data, and between the data and the next cmsghdr
   structure, if required by the implementation.  While sending an
   application may or may not include padding at the end of last
   ancillary data in msg_controllen and implementations must accept both
   as valid.  On receiving a portable application must provide space for
   padding at the end of the last ancillary data as implementations may
   copy out the padding at the end of the control message buffer and
   include it in the received msg_controllen.  When recvmsg() is called
   if msg_controllen is too small for all the ancillary data items
   including any trailing padding after the last item an implementation
   may set MSG_CTRUNC.
   "XX"と示したフィールドは、もし実装が必要なら、cmsghdr構造体とデータの
   間、データと次のcmsghdr構造体の間に可能なパディングです。送信する際に、
   アプリケーションがmsg_controllenの最後の補助的なデータの終わりにパ
   ディングを含めたり含めなかったりします、そして実装が両方を正しいと認
   めなくてはなりません。実装が制御メッセージバッファの終わりにパディン
   グを設定し、受信msg_controllenにこれを含めるかもしれないから、移植性
   があるアプリケーションは受信時に最後の補助的なデータの終わりにパディ
   ングにスペースを提供しなくてはなりません。recvmsg()が呼ばれたときに、
   もしmsg_controllenが最後の項目の後のパディングを含むすべての補助的な
   データ項目には小さすぎるなら、実装がMSG_CTRUNCを設定するかもしれませ
   ん。

20.3.  Ancillary Data Object Macros
20.3.  補助的なデータオブジェクトマクロ

   To aid in the manipulation of ancillary data objects, three macros
   from 4.4BSD are defined by Posix: CMSG_DATA(), CMSG_NXTHDR(), and
   CMSG_FIRSTHDR().  Before describing these macros, we show the
   following example of how they might be used with a call to recvmsg().
   補助的なデータオブジェクトの取り扱いの支援のため、4.4BSDからの3つ
   のマクロがPosixによって定義されます: CMSG_DATA()、CMSG_NXTHDR()、
   CMSG_FIRSTHDR()。これらのマクロを記述する前に、recvmsg()呼び出しでど
   のように使うかの手本を見せます。

      struct msghdr   msg;
      struct cmsghdr  *cmsgptr;

      /* fill in msg */
      /* msgを埋める */

      /* call recvmsg() */
      /* recvmsg()を呼ぶ */

      for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL;
           cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
          if (cmsgptr->cmsg_len == 0) {
              /* Error handling */
           break;
          }
          if (cmsgptr->cmsg_level == ... &&
              cmsgptr->cmsg_type == ... ) {
              u_char  *ptr;

              ptr = CMSG_DATA(cmsgptr);
              /* process data pointed to by ptr */
              /* ptrでポイントされたデータの処理 */
          }
      }

   We now describe the three Posix macros, followed by two more that are
   new with this API: CMSG_SPACE() and CMSG_LEN().  All these macros are
   defined as a result of including <sys/socket.h>.
   我々は3つのPosixマクロを記述します、次の2つはこのAPIで新規
   です:CMSG_SPACE()とCMSG_LEN()。全てのマクロは<sys/socket.h>で定義さ
   れます。

20.3.1.  CMSG_FIRSTHDR
20.3.1.  CMSG_FIRSTHDR

      struct cmsghdr *CMSG_FIRSTHDR(const struct msghdr *mhdr);

   CMSG_FIRSTHDR() returns a pointer to the first cmsghdr structure in
   the msghdr structure pointed to by mhdr.  The macro returns NULL if
   there is no ancillary data pointed to by the msghdr structure (that
   is, if either msg_control is NULL or if msg_controllen is less than
   the size of a cmsghdr structure).
   CMSG_FIRSTHDR()はmhdrの指し示すmsghdr構造体の最初のcmsghdr構造体への
   ポインタを返します。もしmsghdr構造体に補助的なデータがないなら(すな
   わち、msg_controlがNULLか、msg_controllenがcmsghdr構造体のサイズより
   小さいなら)マクロはNULLを返します。

   One possible implementation could be
   1つの可能な実装が以下です

      #define CMSG_FIRSTHDR(mhdr) \
          ( (mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? \
            (struct cmsghdr *)(mhdr)->msg_control : \
            (struct cmsghdr *)NULL )

   (Note: Most existing implementations do not test the value of
   msg_controllen, and just return the value of msg_control.  The value
   of msg_controllen must be tested, because if the application asks
   recvmsg() to return ancillary data, by setting msg_control to point
   to the application's buffer and setting msg_controllen to the length
   of this buffer, the kernel indicates that no ancillary data is
   available by setting msg_controllen to 0 on return.  It is also
   easier to put this test into this macro, than making the application
   perform the test.)
   (ノート:たいていの既存の実装がmsg_controllenの値をテストせず、
   msg_controlの値を返します。msg_controllenの値はテストされなくてはなり
   ません、なぜならもしアプリケーションがrecvmsg()に補助的なデータを返す
   ように依頼するなら、msg_controlにアプリケーションのバッファを設定し
   msg_controllenにこのバッファの長を設定し、カーネルは補助的なデータが
   利用可能ではないことをmsg_controllenを0に設定する事で示すからです。
   アプリケーションにテストを行わせるよりこのテストをマクロの中に置くの
   がより容易です。)

20.3.2.  CMSG_NXTHDR
20.3.2.  CMSG_NXTHDR

   As described in Section 5.1, CMSG_NXTHDR has been extended to handle
   a NULL 2nd argument to mean "get the first header".  This provides an
   alternative way of coding the processing loop shown earlier:
   5.1章で記述されるように、CMSG_NXTHDRは「最初のヘッダの受信」を意味
   するためにNULLの第2引数を処理するように拡張されました。これは以前に
   示される処理ループをコード化する代わりの方法を供給します:

      struct msghdr  msg;
      struct cmsghdr  *cmsgptr = NULL;

      /* fill in msg */
      /* msgを埋める */

      /* call recvmsg() */
      /* recvmsg()呼び出し */

      while ((cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) != NULL) {
          if (cmsgptr->cmsg_len == 0) {
              /* Error handling */
              /* エラー処理 */
           break;
          }
          if (cmsgptr->cmsg_level == ... &&
              cmsgptr->cmsg_type == ... ) {
              u_char  *ptr;

              ptr = CMSG_DATA(cmsgptr);
              /* process data pointed to by ptr */
              /* ptrで示されるデータの処理 */
          }
      }

   One possible implementation could be:
   1つの可能な実装が以下です:

      #define CMSG_NXTHDR(mhdr, cmsg) \
        (((cmsg) == NULL) ? CMSG_FIRSTHDR(mhdr) : \
         (((u_char *)(cmsg) + ALIGN_H((cmsg)->cmsg_len) \
                            + ALIGN_D(sizeof(struct cmsghdr)) > \
           (u_char *)((mhdr)->msg_control) + (mhdr)->msg_controllen) ? \
          (struct cmsghdr *)NULL : \
          (struct cmsghdr *)((u_char *)(cmsg) + \
                                        ALIGN_H((cmsg)->cmsg_len))))

   The macros ALIGN_H() and ALIGN_D(), which are implementation
   dependent, round their arguments up to the next even multiple of
   whatever alignment is required for the start of the cmsghdr structure
   and the data, respectively.  (This is probably a multiple of 4 or 8
   bytes.)  They are often the same macro in implementations platforms
   where alignment requirement for header and data is chosen to be
   identical.
   実装に依存するALIGN_H()とALIGN_D()マクロが、cmsghdr構造体とデータの開
   始に必要な整列の次の偶数へ切り上げます。(これは恐らく4あるいは8バ
   イトの倍数です)。これらはヘッダとデータで整列条件が同じである実装プ
   ラットホームでしばしば同じマクロです。

20.3.3.  CMSG_DATA
20.3.3.  CMSG_DATA

      unsigned char *CMSG_DATA(const struct cmsghdr *cmsg);

   CMSG_DATA() returns a pointer to the data (what is called the
   cmsg_data[] member, even though such a member is not defined in the
   structure) following a cmsghdr structure.
   CMSG_DATA()がcmsghdr構造体の後に続くデータへのポインタを返します
   (cmsg_data[]メンバーと呼ばれるもの、このようなメンバーが構造で定義さ
   れないが) 

   One possible implementation could be:
   1つの可能な実装が以下です:

      #define CMSG_DATA(cmsg) ( (u_char *)(cmsg) + \
                                ALIGN_D(sizeof(struct cmsghdr)) )

20.3.4.  CMSG_SPACE
20.3.4.  CMSG_SPACE

   CMSG_SPACE is new with this API (see Section 5.2).  It is used to
   determine how much space needs to be allocated for an ancillary data
   item.
   CMSG_SPACEはこのAPIで新規です(5.2章参照)。これはどれぐらい空間
   が補助的なデータ項目の割り当てに必要かを決定するために使われます。

   One possible implementation could be:
   1つの可能な実装が以下です:

      #define CMSG_SPACE(length) ( ALIGN_D(sizeof(struct cmsghdr)) + \
                                   ALIGN_H(length) )

20.3.5.  CMSG_LEN
20.3.5.  CMSG_LEN

   CMSG_LEN is new with this API (see Section 5.3).  It  returns the
   value to store in the cmsg_len member of the cmsghdr structure,
   taking into account any padding needed to satisfy alignment
   requirements.
   CMSG_LENはこのAPIで新規です(5.3章参照)。これは、整列条件を満た
   すために必要なパディングを考慮に入れてcmsghdr構造体のcmsg_lenメンバに
   しまっておくべき値を返します。

   One possible implementation could be:
   1つの可能な実装が以下です:

      #define CMSG_LEN(length) ( ALIGN_D(sizeof(struct cmsghdr)) + \
                                 length )

21.  Appendix B: Examples Using the inet6_rth_XXX() Functions
21.  付録B:inet6_rth_XXX()関数を使う例

   Here we show an example for both sending Routing headers and
   processing and reversing a received Routing header.
   ここで我々は、ルーティングヘッダの送信と、受信ルーティングヘッダの処
   理と反転をする例を見せます。

21.1.  Sending a Routing Header
21.1.  ルーティングヘッダ送信

   As an example of these Routing header functions defined in this
   document, we go through the function calls for the example on p. 17
   of [RFC-2460].  The source is S, the destination is D, and the three
   intermediate nodes are I1, I2, and I3.
   この文書で定義したこれらのルーティングヘッダ関数の例のように、我々は
   [RFC-2460]のページ17の例のための関数呼出しを体験します。ソースはS
   で、宛先はDで、3つの中間ノードはI1とI2とI3です。

              S -----> I1 -----> I2 -----> I3 -----> D

      src:    *    S         S         S         S   S
      dst:    D   I1        I2        I3         D   D
      A[1]:  I1   I2        I1        I1        I1  I1
      A[2]:  I2   I3        I3        I2        I2  I2
      A[3]:  I3    D         D         D        I3  I3
      #seg:   3    3         2         1         0   3

   src and dst are the source and destination IPv6 addresses in the IPv6
   header.  A[1], A[2], and A[3] are the three addresses in the Routing
   header.  #seg is the Segments Left field in the Routing header.
   srcとdstはIPv6ヘッダのソースとと宛先IPv6アドレスです。A[1]と
   A[2]とA[3]はルーティングヘッダの3つのアドレスです。#segはルーティン
   グヘッダーの残セグメントフィールドです。

   The six values in the column beneath node S are the values in the
   Routing header specified by the sending application using sendmsg()
   of setsockopt().  The function calls by the sender would look like:
   ノードSの下の列の6つの値はsetsockopt()のsendmsg()を使っている送信ア
   プリケーションによって指定されるルーティングヘッダの値です。送信者が
   呼ぶ関数は以下でしょう:

      void  *extptr;
      socklen_t   extlen;
      struct msghdr  msg;
      struct cmsghdr  *cmsgptr;
      int   cmsglen;
      struct sockaddr_in6  I1, I2, I3, D;

      extlen = inet6_rth_space(IPV6_RTHDR_TYPE_0, 3);
      cmsglen = CMSG_SPACE(extlen);
      cmsgptr = malloc(cmsglen);
      cmsgptr->cmsg_len = CMSG_LEN(extlen);
      cmsgptr->cmsg_level = IPPROTO_IPV6;
      cmsgptr->cmsg_type = IPV6_RTHDR;

      extptr = CMSG_DATA(cmsgptr);
      extptr = inet6_rth_init(extptr, extlen, IPV6_RTHDR_TYPE_0, 3);

      inet6_rth_add(extptr, &I1.sin6_addr);
      inet6_rth_add(extptr, &I2.sin6_addr);
      inet6_rth_add(extptr, &I3.sin6_addr);

      msg.msg_control = cmsgptr;
      msg.msg_controllen = cmsglen;

      /* finish filling in msg{}, msg_name = D */
      /* call sendmsg() */
      /* msg{}を記入し終えます、msg_name = D */
      /* sendmsg()を呼ぶ */

   We also assume that the source address for the socket is not
   specified (i.e., the asterisk in the figure).
   ソケットのソースアドレスが指定されないと想定します(すなわち、
   アスタリスクで記述)。

   The four columns of six values that are then shown between the five
   nodes are the values of the fields in the packet while the packet is
   in transit between the two nodes.  Notice that before the packet is
   sent by the source node S, the source address is chosen (replacing
   the asterisk), I1 becomes the destination address of the datagram,
   the two addresses A[2] and A[3] are "shifted up", and D is moved to
   A[3].
   5つのノードの間の4列の6つの値は、2つのノードの間で転送中のパケッ
   トのフィールド値です。パケットがソースノードSから送られる前に、ソー
   スアドレスが選択されることに気付いてください(アスタリスクが置き換わ
   る取って代わっている)、I1がデータグラムの宛先アドレスで、2つのア
   ドレスA[2]とA[3]の「位置が変り」、DはA[3]に移動します。

   The columns of values that are shown beneath the destination node are
   the values returned by recvmsg(), assuming the application has
   enabled both the IPV6_RECVPKTINFO and IPV6_RECVRTHDR socket options.
   The source address is S (contained in the sockaddr_in6 structure
   pointed to by the msg_name member), the destination address is D
   (returned as an ancillary data object in an in6_pktinfo structure),
   and the ancillary data object specifying the Routing header will
   contain three addresses (I1, I2, and I3).  The number of segments in
   the Routing header is known from the Hdr Ext Len field in the Routing
   header (a value of 6, indicating 3 addresses).
   宛先ノードの下の列の値は、アプリケーションがIPV6_RECVPKTINFOと
   IPV6_RECVRTHDRソケットオプションの両方を使用可能にしたと仮定した場合
   に、recvmsg()が返す値です。ソースアドレスは(msg_nameメンバで指し示さ
   れるsockaddr_in6構造体に含まれる)Sです、宛先アドレスは(in6_pktinfo
   構造体で補助的なデータオブジェクトとして返された)Dで、ルーティング
   ヘッダと示される補助的なデータオブジェクトが3つのアドレス(I1と
   I2とI3)を含んでいるでしょう。ルーティングヘッダのセグメント数は
   ルーティングヘッダのHdr Ext Lenフィールドから分かります(値6は3つの
   アドレスを示しています)。

   The return value from inet6_rth_segments() will be 3 and
   inet6_rth_getaddr(0) will return I1, inet6_rth_getaddr(1) will return
   I2, and inet6_rth_getaddr(2) will return I3,
   inet6_rthdr_segments()の返り値は3でしょう、inet6_rthdr_getaddr(0)は
   I1を、inet6_rthdr_getaddr(1)はI2を、inet6_rthdr_getaddr(2)はI3
   を返すでしょう。

   If the receiving application then calls inet6_rth_reverse(), the
   order of the three addresses will become I3, I2, and I1.
   もし受信アプリケーションがinet6_rthdr_reverse()を呼ぶなら、3つのア
   ドレスの順序はI3とI2とI1になるでしょう。

   We can also show what an implementation might store in the ancillary
   data object as the Routing header is being built by the sending
   process.  If we assume a 32-bit architecture where sizeof(struct
   cmsghdr) equals 12, with a desired alignment of 4-byte boundaries,
   then the call to inet6_rth_space(3) returns 68: 12 bytes for the
   cmsghdr structure and 56 bytes for the Routing header (8 + 3*16).
   送信プロセスがルーティングヘッダを作る時に、補助的なデータオブジェク
   トに何が登録されるか見ることができます。もしsizeof(struct cmsghdr)
   が12に等しい32ビット・アーキテクチャと、4バイト境界での整列でを
   仮定するなら、inet6_rth_space(3)呼び出しは68を返します:cmsghdr構
   造体が12バイトでルーティングヘッダが56バイト(8+3×16)。

   The call to inet6_rth_init() initializes the ancillary data object to
   contain a Type 0 Routing header:
   inet6_rth_init()呼び出しはタイプ0ルーティングヘッダーを含む補助的
   なデータオブジェクトを初期化します:

      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_len = 20                                           |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_level = IPPROTO_IPV6                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_type = IPV6_RTHDR                                  |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |  Next Header  | Hdr Ext Len=6 | Routing Type=0|  Seg Left=0   |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                           Reserved                            |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   The first call to inet6_rth_add() adds I1 to the list.
   inet6_rth_add()への最初の呼び出しはリストにI1を加えます。

      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_len = 36                                           |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_level = IPPROTO_IPV6                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_type = IPV6_RTHDR                                  |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |  Next Header  | Hdr Ext Len=6 | Routing Type=0|  Seg Left=1   |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                           Reserved                            |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      +                                                               +
      |                                                               |
      +                           Address[1] = I1                     +
      |                                                               |
      +                                                               +
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   cmsg_len is incremented by 16, and the Segments Left field is
   incremented by 1.
   cmsg_lenは16増加し、Segments Leftフィールドは1増加します。


   The next call to inet6_rth_add() adds I2 to the list.
   inet6_rth_add()への次の呼び出しはリストにI2を加えます。

      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_len = 52                                           |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_level = IPPROTO_IPV6                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_type = IPV6_RTHDR                                  |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |  Next Header  | Hdr Ext Len=6 | Routing Type=0|  Seg Left=2   |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                           Reserved                            |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      +                                                               +
      |                                                               |
      +                           Address[1] = I1                     +
      |                                                               |
      +                                                               +
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      +                                                               +
      |                                                               |
      +                           Address[2] = I2                     +
      |                                                               |
      +                                                               +
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   cmsg_len is incremented by 16, and the Segments Left field is
   incremented by 1.
   cmsg_lenは16増加し、Segments Leftフィールドは1増加します。


   The last call to inet6_rth_add() adds I3 to the list.
   inet6_rth_add()への最後の呼び出しはリストにI3を加えます。

      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_len = 68                                           |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_level = IPPROTO_IPV6                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |       cmsg_type = IPV6_RTHDR                                  |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |  Next Header  | Hdr Ext Len=6 | Routing Type=0|  Seg Left=3   |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                           Reserved                            |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      +                                                               +
      |                                                               |
      +                           Address[1] = I1                     +
      |                                                               |
      +                                                               +
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      +                                                               +
      |                                                               |
      +                           Address[2] = I2                     +
      |                                                               |
      +                                                               +
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      +                                                               +

      |                                                               |
      +                           Address[3] = I3                     +
      |                                                               |
      +                                                               +
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   cmsg_len is incremented by 16, and the Segments Left field is
   incremented by 1.
   cmsg_lenは16増加し、Segments Leftフィールドは1増加します。

21.2.  Receiving Routing Headers
21.2.  ルーティングヘッダ受信

   This example assumes that the application has enabled IPV6_RECVRTHDR
   socket option.  The application prints and reverses a source route
   and uses that to echo the received data.
   この例はアプリケーションがIPV6_RECVRTHDRソケットオプションを使用可能
   にしたと想定します。アプリケーションは表示し、ソースルートを反転し、
   そして受信データを返すためこれを使います。

      struct sockaddr_in6     addr;
      struct msghdr           msg;
      struct iovec            iov;
      struct cmsghdr          *cmsgptr;
      socklen_t               cmsgspace;
      void                    *extptr;
      int                     extlen;
      int                     segments;
      int                     i;
      char                    databuf[8192];

      segments = 100;        /* Enough */
      extlen = inet6_rth_space(IPV6_RTHDR_TYPE_0, segments);
      cmsgspace = CMSG_SPACE(extlen);
      cmsgptr = malloc(cmsgspace);
      if (cmsgptr == NULL) {
              perror("malloc");
              exit(1);
      }
      extptr = CMSG_DATA(cmsgptr);

      msg.msg_control = cmsgptr;
      msg.msg_controllen = cmsgspace;
      msg.msg_name = (struct sockaddr *)&addr;
      msg.msg_namelen = sizeof (addr);
      msg.msg_iov = &iov;
      msg.msg_iovlen = 1;
      iov.iov_base = databuf;
      iov.iov_len = sizeof (databuf);
      msg.msg_flags = 0;
      if (recvmsg(s, &msg, 0) == -1) {
              perror("recvmsg");
              return;
      }
      if (msg.msg_controllen != 0 &&
          cmsgptr->cmsg_level == IPPROTO_IPV6 &&
          cmsgptr->cmsg_type == IPV6_RTHDR) {
              struct in6_addr *in6;
              char asciiname[INET6_ADDRSTRLEN];
              struct ip6_rthdr *rthdr;

              rthdr = (struct ip6_rthdr *)extptr;
              segments = inet6_rth_segments(extptr);
              printf("route (%d segments, %d left): ",
                  segments, rthdr->ip6r_segleft);
              for (i = 0; i < segments; i++) {
                      in6 = inet6_rth_getaddr(extptr, i);
                      if (in6 == NULL)
                              printf("<NULL> ");
                      else
                              printf("%s ", inet_ntop(AF_INET6,
                                  (void *)in6->s6_addr,
                                  asciiname, INET6_ADDRSTRLEN));
              }
              if (inet6_rth_reverse(extptr, extptr) == -1) {
                      printf("reverse failed");
                      return;
              }
      }
      iov.iov_base = databuf;
      iov.iov_len = strlen(databuf);
      if (sendmsg(s, &msg, 0) == -1)
              perror("sendmsg");
      if (cmsgptr != NULL)
              free(cmsgptr);

   Note: The above example is a simple illustration.  It skips some
   error checks, including those involving the MSG_TRUNC and MSG_CTRUNC
   flags.  It also leaves some type mismatches in favor of brevity.
   メモ:上記の例は単純な記述です。MSG_TRUNCやMSG_CTRUNCフラグを含めてい
   くつかのエラーチェックを省略します。簡潔さのために、同じくあるのタイ
   プ不適当な組合わせを残します。

22.  Appendix C: Examples Using the inet6_opt_XXX() Functions
22.  付録C:inet6_opt_XXX()関数を使う例

   This shows how Hop-by-Hop and Destination options can be both built
   as well as parsed using the inet6_opt_XXX() functions.  These
   examples assume that there are defined values for OPT_X and OPT_Y.
   これはinet6_opt_XXX()関数を使ってどのようにホップ毎オプションと宛先オ
   プションが構築と解析されるかを示します。これらの例はOPT_XとOPT_Yに定
   義された値があると想定します。

   Note: The example is a simple illustration.  It skips some error
   checks and leaves some type mismatches in favor of brevity.
   メモ:例は単純なイラストです。これはいくつかのエラーチェックを省略し、
   簡潔さのためあるタイプ不適当な組合わせを残します。

22.1.  Building Options
22.1.  オプション構築

   We now provide an example that builds two Hop-by-Hop options using
   the example in Appendix B of [RFC-2460].
   我々は今[RFC-2460]の付録Bの例を使って2つのホップ毎オプションを構築
   する例を供給します。

      void *extbuf;
      socklen_t extlen;
      int currentlen;
      void *databuf;
      int offset;
      uint8_t value1;
      uint16_t value2;
      uint32_t value4;
      uint64_t value8;

      /* Estimate the length */
      /* 長さを見積り */

      currentlen = inet6_opt_init(NULL, 0);
      if (currentlen == -1)
              return (-1);
      currentlen = inet6_opt_append(NULL, 0, currentlen, OPT_X,
                                    12, 8, NULL);
      if (currentlen == -1)
              return (-1);
      currentlen = inet6_opt_append(NULL, 0, currentlen, OPT_Y,
                                    7, 4, NULL);
      if (currentlen == -1)
              return (-1);
      currentlen = inet6_opt_finish(NULL, 0, currentlen);
      if (currentlen == -1)
              return (-1);
      extlen = currentlen;

      extbuf = malloc(extlen);
      if (extbuf == NULL) {
              perror("malloc");
              return (-1);
      }

      currentlen = inet6_opt_init(extbuf, extlen);
      if (currentlen == -1)
              return (-1);

      currentlen = inet6_opt_append(extbuf, extlen, currentlen,
          OPT_X, 12, 8, &databuf);
      if (currentlen == -1)
              return (-1);
      /* Insert value 0x12345678 for 4-octet field */
      /* 4オクテットフィールドに値0x12345678を設定 */
      offset = 0;
      value4 = 0x12345678;
      offset = inet6_opt_set_val(databuf, offset,
                                 &value4, sizeof (value4));
      /* Insert value 0x0102030405060708 for 8-octet field */
      /* 8オクテットフィールドに値0x0102030405060708を設定 */
      value8 = 0x0102030405060708;
      offset = inet6_opt_set_val(databuf, offset,
                                 &value8, sizeof (value8));

      currentlen = inet6_opt_append(extbuf, extlen, currentlen,
          OPT_Y, 7, 4, &databuf);
      if (currentlen == -1)
              return (-1);
      /* Insert value 0x01 for 1-octet field */
      /* 1オクテットフィールドに値0x01を設定 */
      offset = 0;
      value1 = 0x01;
      offset = inet6_opt_set_val(databuf, offset,
                                 &value1, sizeof (value1));

      /* Insert value 0x1331 for 2-octet field */
      /* 2オクテットフィールドに値0x1331を設定 */
      value2 = 0x1331;
      offset = inet6_opt_set_val(databuf, offset,
                                 &value2, sizeof (value2));
      /* Insert value 0x01020304 for 4-octet field */
      /* 4オクテットフィールドに値0x01020304を設定 */
      value4 = 0x01020304;
      offset = inet6_opt_set_val(databuf, offset,
                                 &value4, sizeof (value4));

      currentlen = inet6_opt_finish(extbuf, extlen, currentlen);
      if (currentlen == -1)
              return (-1);
      /* extbuf and extlen are now completely formatted */
      /* extbufとextlenを完全に生成する */

22.2.  Parsing Received Options
22.2.  受信オプションの解析

   This example parses and prints the content of the two options in the
   previous example.
   この例は前の例の2つのオプションの内容を解析して印刷します。

      int
      print_opt(void *extbuf, socklen_t extlen)
      {
              struct ip6_dest *ext;
              int currentlen;
              uint8_t type;
              socklen_t len;
              void *databuf;
              int offset;
              uint8_t value1;
              uint16_t value2;
              uint32_t value4;
              uint64_t value8;

              ext = (struct ip6_dest *)extbuf;
              printf("nxt %u, len %u (bytes %d)\n", ext->ip6d_nxt,
                  ext->ip6d_len, (ext->ip6d_len + 1) * 8);

              currentlen = 0;
              while (1) {
                      currentlen = inet6_opt_next(extbuf, extlen,
                                                  currentlen, &type,
                                                  &len, &databuf);
                      if (currentlen == -1)
                              break;
                      printf("Received opt %u len %u\n",
                          type, len);
                      switch (type) {
                      case OPT_X:
                              offset = 0;
                              offset =
                                  inet6_opt_get_val(databuf, offset,
                                                    &value4,
                                                    sizeof (value4));
                              printf("X 4-byte field %x\n", value4);
                              offset =
                                  inet6_opt_get_val(databuf, offset,
                                                    &value8,
                                                    sizeof (value8));
                              printf("X 8-byte field %llx\n", value8);
                              break;
                      case OPT_Y:
                              offset = 0;
                              offset =
                                  inet6_opt_get_val(databuf, offset,
                                                    &value1,
                                                    sizeof (value1));
                              printf("Y 1-byte field %x\n", value1);
                              offset =
                                  inet6_opt_get_val(databuf, offset,
                                                    &value2,
                                                    sizeof (value2));
                              printf("Y 2-byte field %x\n", value2);
                              offset =

                                  inet6_opt_get_val(databuf, offset,
                                                    &value4,
                                                    sizeof (value4));
                              printf("Y 4-byte field %x\n", value4);
                              break;
                      default:
                              printf("Unknown option %u\n", type);
                              break;
                      }
              }
              return (0);
      }


23. Authors' Addresses
23. 著者のアドレス

   W. Richard Stevens (deceased)

   Matt Thomas
   3am Software Foundry
   8053 Park Villa Circle
   Cupertino, CA 95014

   EMail: matt@3am-software.com


   Erik Nordmark
   Sun Microsystems Laboratories, Europe
   180, avenue de l'Europe
   38334 SAINT ISMIER Cedex, France

   Phone: +33 (0)4 74 18 88 03
   Fax:   +33 (0)4 76 18 88 88
   EMail: Erik.Nordmark@sun.com


   Tatuya JINMEI
   Corporate Research & Development Center, Toshiba Corporation
   1 Komukai Toshiba-cho, Kawasaki-shi
   Kanagawa 212-8582, Japan

   EMail: jinmei@isl.rdc.toshiba.co.jp


24. Full Copyright Statement
24. 著作権表示全文

   Copyright (C) The Internet Society (2003).  All Rights Reserved.
   著作権(C)インターネット学会(2003)。すべての権利は保留される。

   This document and translations of it may be copied and furnished to
   others, and derivative works that comment on or otherwise explain it
   or assist in its implementation may be prepared, copied, published
   and distributed, in whole or in part, without restriction of any
   kind, provided that the above copyright notice and this paragraph are
   included on all such copies and derivative works.  However, this
   document itself may not be modified in any way, such as by removing
   the copyright notice or references to the Internet Society or other
   Internet organizations, except as needed for the purpose of
   developing Internet standards in which case the procedures for
   copyrights defined in the Internet Standards process must be
   followed, or as required to translate it into languages other than
   English.
   上記著作権表示とこの段落が全ての複写や派生的な仕事につけられていれば、
   この文書と翻訳は複写や他者への提供ができ、そしてコメントや説明や実装
   を支援する派生的な仕事のためにこの文書の全部か一部を制約なく複写や出
   版や配布できます。しかし、この文書自身は、英語以外の言葉への翻訳やイ
   ンターネット標準を開発する目的で必要な場合以外は、インターネット学会
   や他のインターネット組織は著作権表示や参照を削除されるような変更がで
   きません、インターネット標準を開発する場合はインターネット標準化プロ
   セスで定義された著作権の手順に従われます。

   The limited permissions granted above are perpetual and will not be
   revoked by the Internet Society or its successors or assigns.
   上に与えられた限定された許可は永久で、インターネット学会やその後継者
   や譲渡者によって無効にされません。

   This document and the information contained herein is provided on an
   "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
   TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
   BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
   HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
   この文書とここに含む情報は無保証で供給され、そしてインターネット学会
   とインターネット技術標準化タスクフォースは、特別にも暗黙にも、この情
   報の利用が権利を侵害しないことや商業利用や特別の目的への利用に適当で
   ある事の保障を含め、すべての保証を拒否します。

Acknowledgement
謝辞
 
   Funding for the RFC Editor function is currently provided by the
   Internet Society.
   RFCエディタ機能のための資金供給が現在インターネット学会によって
   供給されます。

Japanese translation by Ishida So