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


Network Working Group                                        W. Stevens
Request for Comments: 2292                                   Consultant
Category: Informational                                       M. Thomas
                                                              AltaVista
                                                          February 1998



                     Advanced Sockets 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 (1998).  All Rights Reserved.

Abstract
概要

   Specifications are in progress for changes to the sockets API to
   support IP version 6 [RFC-2133].  These changes are for TCP and UDP-
   based applications and will support most end-user applications in use
   today: Telnet and FTP clients and servers, HTTP clients and servers,
   and the like.
   ソケットAPIに対する変更仕様書がIPバージョン6[RFC-2133]をサポー
   トするために進行中です。これらの変更はTCPとUDPベースのアプリケー
   ションのためであって、今日のたいていの使用中のエンドユーザーアプリケー
   ションをサポートするでしょう:TelnetやFTPクライアントとサーバー、HTTP
   クライアントとサーバー、など

   But another class of applications exists that will also be run under
   IPv6.  We call these "advanced" applications and today this includes
   programs such as Ping, Traceroute, routing daemons, multicast routing
   daemons, router discovery daemons, and the like.  The API feature
   typically used by these programs that make them "advanced" is a raw
   socket to access ICMPv4, IGMPv4, or IPv4, along with some knowledge
   of the packet header formats used by these protocols.  To provide
   portability for applications that use raw sockets under IPv6, some
   standardization is needed for the advanced API features.
   けれども同じくIPv6下で走るであろうもう1つのアプリケーションのク
   ラスが存在します。我々はこれらの「高等」アプリケーションと呼び、今日
   これはPing、Traceroute、ルーティングデーモン、マルチキャストルーティ
   ングデーモンのようなプログラム、ルーター探索デーモン、などを含みます。
   典型的にこれらの「高等」プログラムで使われるAPIの特徴は、ICMPv4と
   IGMPv4とIPv4へのアクセスをする生ソケットで、これらのプロトコルのパケッ
   トヘッダーフォーマットの知識とともに使われます。IPv6下で生ソケッ
   トを使うアプリケーションにポータビリティを提供するために、高等API
   機能の標準化が必要です。

   There are other features of IPv6 that some applications will need to
   access: interface identification (specifying the outgoing interface
   and determining the incoming interface) and IPv6 extension headers
   that are not addressed in [RFC-2133]: Hop-by-Hop options, Destination
   options, and the Routing header (source routing).  This document
   provides API access to these features too.
   あるアプリケーションがアクセスする必要があるであろうIPv6の他の機
   能があります:インターフェース識別子(送信インタフェース指定と、受信
   インタフェース決定)と、[RFC-2133]で扱われないIPv6拡張ヘッダ:ホッ
   プバイホップオプションと宛先宛先オプションとルーティングヘッダー(ソー
   スルーティング)。この文書は同じくこれらの機能にAPIアクセスを供給
   します。


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.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 Type and Code Values
            2.2.2.  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タイプフィルタリング
   4.  Ancillary Data
   4.  補助的データ
       4.1.  The msghdr Structure
       4.1.  msghdr構造体
       4.2.  The cmsghdr Structure
       4.2.  cmsghdr構造体
       4.3.  Ancillary Data Object Macros
       4.3.  補助的なデータオブジェクトマクロ
            4.3.1.  CMSG_FIRSTHDR
            4.3.1.  CMSG_FIRSTHDR
            4.3.2.  CMSG_NXTHDR
            4.3.2.  CMSG_NXTHDR
            4.3.3.  CMSG_DATA
            4.3.3.  CMSG_DATA
            4.3.4.  CMSG_SPACE
            4.3.4.  CMSG_SPACE
            4.3.5.  CMSG_LEN
            4.3.5.  CMSG_LEN
       4.4.  Summary of Options Described Using Ancillary Data
       4.4.  補助的なデータを使うオプションのまとめ
       4.5.  IPV6_PKTOPTIONS Socket Option
       4.5.  IPV6_PKTOPTIONSソケットオプション
            4.5.1.  TCP Sticky Options
            4.5.1.  TCP貼付きオプション
            4.5.2.  UDP and Raw Socket Sticky Options
            4.5.2.  UDPと生ソケット貼付きオプション
   5.  Packet Information
   5.  パケット情報
       5.1.  Specifying/Receiving the Interface
       5.1.  インタフェース指定/受信
       5.2.  Specifying/Receiving Source/Destination Address
       5.2.  ソース/宛先アドレスの指定/受信
       5.3.  Specifying/Receiving the Hop Limit
       5.3.  ホップ限界の指定/受信
       5.4.  Specifying the Next Hop Address
       5.4.  次の転送先アドレスの指定
       5.5.  Additional Errors with sendmsg()
       5.5.  sendmsg()の追加のエラー
   6.  Hop-By-Hop Options
   6.  ホップ毎オプション
       6.1.  Receiving Hop-by-Hop Options
       6.1.  ホップ毎オプション受信
       6.2.  Sending Hop-by-Hop Options
       6.2.  ホップ毎オプションの送信
       6.3.  Hop-by-Hop and Destination Options Processing
       6.3.  ホップ毎と宛先オプション処理
            6.3.1.  inet6_option_space
            6.3.1.  inet6_option_space
            6.3.2.  inet6_option_init
            6.3.2.  inet6_option_init
            6.3.3.  inet6_option_append
            6.3.3.  inet6_option_append
            6.3.4.  inet6_option_alloc
            6.3.4.  inet6_option_alloc
            6.3.5.  inet6_option_next
            6.3.5.  inet6_option_next
            6.3.6.  inet6_option_find
            6.3.6.  inet6_option_find
            6.3.7.  Options Examples
            6.3.7.  オプション例
   7.  Destination Options
   7.  宛先オプション
       7.1.  Receiving Destination Options
       7.1.  宛先オプション受信
       7.2.  Sending Destination Options
       7.2.  宛先オプション送信
   8.  Routing Header Option
   8.  ルーティングヘッダーオプション
       8.1.  inet6_rthdr_space
       8.1.  inet6_rthdr_space
       8.2.  inet6_rthdr_init
       8.2.  inet6_rthdr_init
       8.3.  inet6_rthdr_add
       8.3.  inet6_rthdr_add
       8.4.  inet6_rthdr_lasthop
       8.4.  inet6_rthdr_lasthop
       8.5.  inet6_rthdr_reverse
       8.5.  inet6_rthdr_reverse
       8.6.  inet6_rthdr_segments
       8.6.  inet6_rthdr_segments
       8.7.  inet6_rthdr_getaddr
       8.7.  inet6_rthdr_getaddr
       8.8.  inet6_rthdr_getflags
       8.8.  inet6_rthdr_getflags
       8.9.  Routing Header Example
       8.9.  Routing Header Example
   9.  Ordering of Ancillary Data and IPv6 Extension Headers
   9.  補助的なデータとIPv6拡張ヘッダーの順序
   10.  IPv6-Specific Options with IPv4-Mapped IPv6 Addresses
   10.  IPv4マップIPv6アドレスを持つIPv6特有オプション
   11.  rresvport_af
   11.  rresvport_af
   12.  Future Items
   12.  未来の項目
       12.1.  Flow Labels
       12.1.  フローラベル
       12.2.  Path MTU Discovery and UDP
       12.2.  パスMTU探索とUDP
       12.3.  Neighbor Reachability and UDP
       12.3.  近隣到達可能性とUDP
   13.  Summary of New Definitions
   13.  新しい定義の要約
   14.  Security Considerations
   14.  セキュリティの考察
   15.  Change History
   15.  変更履歴
   16.  References
   16.  参考文献
   17.  Acknowledgments
   17.  謝辞
   18.  Authors' Addresses
   18.  著者のアドレス
   19.  Full Copyright Statement
   19.  著作権表示全文

1.  Introduction
1.  はじめに

   Specifications are in progress for changes to the sockets API to
   support IP version 6 [RFC-2133].  These changes are for TCP and UDP-
   based applications.  The current document defines some the "advanced"
   features of the sockets API that are required for applications to
   take advantage of additional features of IPv6.
   ソケットAPIに対する変更仕様書がIPバージョン6[RFC-2133]をサポー
   トするために進行中です。これらの変更は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 headers.  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-2133]: sending and receiving Hop-by-Hop
   options, Destination options, and Routing headers, specifying the
   outgoing interface, and being told of the receiving interface.
   同じく[RFC-2133]で扱われない基本的なIPv6仕様の特徴があります:ホッ
   プ毎オプションや宛先オプションやルーチングヘッダの送受信、出力経路決
   定、受信インターフェースの通知。

   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 Hop-by-Hop, Destination, and Routing
       headers.
   4.  オプションのホップ毎ヘッダと宛先ヘッダとルーティングヘッダへのア
       クセス。

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

   The packet information along with access to the extension headers
   (Hop-by-Hop options, Destination options, and Routing header) 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.1g standard (which should be
   approved in 1997) and should therefore be adopted by most vendors.
   拡張ヘッダ(ホップ毎オプションと宛先オプションとルーティングヘッダ)
   へのアクセスに加えてパケット情報は、1990年に4.3BSDレノソケット
   APIで加えられた「補助的なデータ」フィールドを使って指定します。理
   由はこれらの補助的なデータフィールドが(1997年に承認されるべきで
   ある)Posix.1g標準の一部で、たいていのベンダーが採用するべきである
   からです。

   This document does not address application access to either the
   authentication header or the encapsulating security payload header.
   この文章は認証ヘッダやカプセル化セキュリティペイロードヘッダのアプリ
   ケーションアクセスを扱いません。

   All examples in this document omit error checking in favor of brevity
   and clarity.
   すべてのこの文書での例は簡潔さと明快さのためエラーチェックを除きます。

   We note that many of the functions and socket options defined in this
   document may have error returns that are not defined in this
   document.  Many of these possible error returns will be recognized
   only as implementations proceed.
   我々はこの文書で定義された関数とソケットオプションの多くがこの文書に
   定義されないエラーリターンしてもよいことを指摘します。これらの可能な
   エラーリターンの多くが、ただ実装が処理する時だけ識別されるでしょう。

   Datatypes in this document follow the Posix.1g 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.1gフォーマットに従います: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 headers are required, along with common
   constant definitions for the structure members.
   多くの高等アプリケーションがIPv6ヘッダを調べ、ICMPv6ヘッダ
   の様々なフィールドを調べ、設定します。これらのヘッダーのための共通の
   構造と構造体のメンバーの共通定数の定義が必要です。

   Two new headers 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;   /* 24 bits of flow-ID */
                                   /* 24ビットのフロー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, 4 bits priority */
                                   /* 4ビットバージョン、4ビット優先 */
      } 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 fragmentation 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 */
   /* XXX should we pad it to force alignment on an 8-byte boundary? */
   /* ホップ毎オプションヘッダー */
   /* XXX は8バイトの境界に整列を強制する穴埋め? */
   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 */
   /* XXX should we pad it to force alignment on an 8-byte boundary? */
   /* 宛先オプションヘッダー */
   /* XXX は8バイトの境界に整列を強制する穴埋め? */
   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 */
                               /* 残りのセグメント */
     uint8_t  ip6r0_reserved;  /* reserved field */
                               /* 予約フィールド */
     uint8_t  ip6r0_slmap[3];  /* strict/loose bit map */
                               /* 厳密/あいまいビットマップ */
     struct in6_addr  ip6r0_addr[1];  /* up to 23 addresses */
                                      /* 最高23のアドレス */
   };

   /* 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 _offlg */
                                       /* _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 _offlg */
                                       /* _offlgのマスク */
   #define IP6F_RESERVED_MASK  0x0600  /* reserved bits in ip6f_offlg */
                                       /* ip6f_offlgの予約ビット */
   #define IP6F_MORE_FRAG      0x0100  /* more-fragments flag */
                                       /* 後続フラグ */
   #endif

   Defined constants for fields larger than 1 byte depend on the byte
   ordering that is used.  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().
   使われるバイト順に依存する1バイトより大きいフィールドの定数を定義し
   ました。このAPIはプロトコルヘッダのフィールドがネットワークバイト
   オーダーのままと想定し、これはインターネット・プロトコルでビッグエン
   ディアンです。もしそうでなければ、それでこれらの定数あるいはテストさ
   れているフィールドが、htons()かhtonl()などを使って、実行時に変換され
   なくてはなりません。

   (Note: We show an implementation that supports both big-endian and
   little-endian byte ordering, assuming a hypothetical compile-time #if
   test to determine the byte ordering.  The constant that we show,
   BYTE_ORDER, with values of BIG_ENDIAN and LITTLE_ENDIAN, are for
   example purposes only.  If an implementation runs on only one type of
   hardware it need only define the set of constants for that hardware's
   byte ordering.)
   (ノート:我々はコンパイル時に#ifテストがバイト順を決定すると仮定して、
   ビッグエンディアンとリトルエンディアンバイト順の両方をサポートする実
   装を示します。我々が示す定数BYTE_ORDERは例示が目的で、BIG_ENDIANと
   LITTLE_ENDIANの値です。もし実装が1つのハードウェアタイプでだけ走るな
   ら、そのハードウェアのバイト順の定数を定義することが必要なだけです。)

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_MEMBERSHIP_QUERY      130
#define ICMP6_MEMBERSHIP_REPORT     131
#define ICMP6_MEMBERSHIP_REDUCTION  132

#define ICMP6_DST_UNREACH_NOROUTE     0 /* no route to destination */
                                        /* 宛先への経路なし */
#define ICMP6_DST_UNREACH_ADMIN       1 /* communication with */
                                        /* destination */
                                        /* administratively */
                                        /* prohibited */
                                        /* 宛先への通信の管理的禁止 */
#define ICMP6_DST_UNREACH_NOTNEIGHBOR 2 /* not a neighbor */
                                        /* 近隣でない */
#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 Type and Code Values
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 discussed with ip6f_offlg.
   我々はnd_na_flags_reservedフラグがip6f_offlgに関して我々が論じたのと
   同じバイト順の問題を持つことを指摘します。

2.3.  Address Testing Macros
2.3.  アドレステストマクロ

   The basic API ([RFC-2133]) 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-2133])はある特定の性質についてIPv6アドレスをテ
   ストするマクロを定義します。このAPIはアドレステストマクロを追加し
   て定義を拡張します、定義は<netinet/in.h>に含まれます。

    int  IN6_ARE_ADDR_EQUAL(const struct in6_addr *,
                            const struct in6_addr *);

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 from ftp://ftp.isi.edu/in-notes/iana/assignments/protocol-
   numbers.
   我々は次のプロトコル名と値を定義します。これらは
   ftp://ftp.isi.edu/in-notes/iana/assignments/protocol- numbersから引用
   されます。

       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 typically used the host's byte order.
   すべての生ソケットにから送るデータはネットワークバイト順で(MUST)、生
   ソケットから受け取ったすべてのデータはネットワークバイト順でしょう。
   これはIPv4生ソケットがバイト順を指定せず、一般的にホストバイトオー
   ダーを使うのと異なっています。

   Another difference from IPv4 raw sockets is that complete packets
   (that is, IPv6 packets with extension headers) cannot be read or
   written using the IPv6 raw sockets API.  Instead, ancillary data
   objects are used to transfer the extension headers, as described
   later in this document.  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
   を使って読み書きできないということです。その代わりに、この文書で後に
   記述されるように、補助的なデータオブジェクトが拡張子ヘッダーを転送す
   るために使われます。もしアプリケーションが完全なIPv6パケットにア
   クセスを必要としたなら、何か他の、データリンクインタフェースBPFや
   DLPIのような、テクニックが使われなくてはなりません。

   All fields 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 in a received IPv6 header (other
   than the version number and Next Header fields) and all extension
   headers 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.
   アプリケーションが変えることを望むかもしれないすべてのIPv6ヘッダー
   フィールド(すなわち、バージョン番号以外のすべて)は出力アプリケーショ
   ンが補助的なデータやソケットオプションを使って修正できます。すべての
   受信IPv6ヘッダフィールド(バージョン番号と次ヘッダーフィールド以
   外)とすべての拡張子ヘッダのフィールドは入力の補助的なデータとしてア
   プリケーションに利用可能です。それ故IPv4 IP_HDRINCLソケットオプ
   ションに類似しているソケットオプションが必要ありません。

   When writing to a raw socket the kernel will automatically fragment
   the packet if its size exceeds the path MTU, inserting the required
   fragmentation 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 PF_INET6,
   SOCK_RAW, and IPPROTO_ICMPV6.
   我々が「ICMPv6生ソケット」と言う時、我々は3つの引数PF_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.  We note that this value 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).  (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.)
   たいていのIPv4実装がsocket()の3番目の引数であるIPPROTO_RAWの値が
   通常255で生成されたソケットを特別扱いします。我々はこの値がIPv
   6生ソケットに特別な意味がないことを指摘します(そしてIANAは、次
   のヘッダーフィールドで用いる255の値を予約します)。(メモ:この機
   能は1988年にVan Jacobsonによってtracerouteをサポートするために追
   加され、IP_HDRINCLソケットオプションが追加される前に、アプリケーショ
   ンが完全なヘッダを渡すことを許します。)。

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-
   1883].  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- 1883]の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)カーネルは
   受信パケットのチェックサムを検証しない、事を意味します。

   (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 group membership 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> header.
   この構造体とさらにマクロと変数がこの章の後で定義され<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 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(PF_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()を使ってインストー
   ルされます。

   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>ヘッダのインクルー
   ドを必要とします。)

4.  Ancillary Data
4.  補助的データ

   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.3BSD
   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.1g sockets API standard (which should be completed during
   1997).
   にもかかわらずmsghdr構造体の補助的なデータフィールドは読み書きする
   データ以外の情報を渡すクリーンな方法を供給します。msg_controlメンバー
   によって示されるcmsghdr構造体と共にmsghdr構造体のmsg_controlと
   msg_controllenメンバーの包含は(1997年の間に完了されるべきである)
   Posix.1gソケットAPI標準で必要とされます。

   In this document ancillary data is used to exchange the following
   optional information between the application and the kernel:
   この文書で補助的なデータがアプリケーションとカーネルの間に次の任意の
   情報を交換するために使われます:

       1.  the send/receive interface and source/destination address,
           送受信インターフェースとソース/宛先アドレス
       2.  the hop limit,
           ホップ限界
       3.  next hop address,
           次ホップアドレス
       4.  Hop-by-Hop options,
           ホップ毎オプション
       5.  Destination options, and
           宛先オプション
       6.  Routing header.
           ルーチングヘッダ

   Before describing these uses in detail, we review the definition of
   the msghdr structure itself, the cmsghdr structure that defines an
   ancillary data object, and some functions that operate on the
   ancillary data objects.
   詳細にこれらの使い方を記述する前に、我々はmsghdr構造体の定義、補助的
   なデータオブジェクトを定義するcmsghdr構造体の定義、補助的なデータオ
   ブジェクトに作用する関数定義を再検討します。

4.1.  The msghdr Structure
4.1.  msghdr構造体

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

    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配列 */
      size_t     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.1g the two "void *" pointers were typically "char
   *", and the two socklen_t members and the size_t member were
   typically integers.  Earlier drafts of Posix.1g had the two socklen_t
   members as size_t, but Draft 6.6 of Posix.1g, apparently the final
   draft, changed these to socklen_t to simplify binary portability for
   64-bit implementations and to align Posix.1g 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.1g以前では2つの"void *"ポインタは一般に"char *"で、
   2つのsocklen_tメンバーとsize_tメンバーは一般に整数でした。Posix.1g
   の以前のドラフトでが2つのsocklen_tメンバーsize_tでしたが、しかし多分
   最終ドラフトのPosix.1gドラフト6.6で、64ビット実装のバイナリポータ
   ビリティを単純化して、Posix.1g を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 Type 0 Routing header is 376 bytes.)
   たいていのバークレー系実装でsendmsg()呼び出しの補助的なデータの量を
   108バイト(mbuf)以下に制限します。このAPIは最小10240バイ
   トの補助的なデータを必要としますが、データ量制限が(SO_SNDBUFソケット
   オプションで修正できる)ソケットの予約バッファ空間にだけ依存すること
   を勧めます。(ノート:このマジックナンバー10240は常に十分な値と
   して選ばれました。108バイトは、タイプ0ルーティングヘッダーの最大
   サイズが376バイトであるので、明らかにあまりにも小さいです。)

4.2.  The cmsghdr Structure
4.2.  cmsghdr構造体

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

    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>で宣言されます。

   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 shortly.  Nevertheless, it is common
   to refer to the cmsg_data[] member.
   この定義に示されるように、通常、名前cmsg_data[]にメンバーがありません。
   その代わりに、データ部は後に記述するCMSG_xxx()マクロを使ってアクセス
   します。にもかかわらず、cmsg_data[]メンバーを参照するのが普通です。

   (Note: Before Posix.1g 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.1g以前にcmsg_lenメンバーはsocklen_tではなく整数でした。
   socklen_tがここで使われる理由は前の章のノートを見てください。)

   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 -------------------------->|
|                                                                       |
|<----- ancillary data object ----->|<----- ancillary data object ----->|
|<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
|                                   |                                   |
|<---------- cmsg_len ---------->|  |<--------- cmsg_len ----------->|  |
|<--------- CMSG_LEN() --------->|  |<-------- CMSG_LEN() ---------->|  |
|                                |  |                                |  |
+-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
|cmsg_|cmsg_|cmsg_|XX|           |XX|cmsg_|cmsg_|cmsg_|XX|           |XX|
|len  |level|type |XX|cmsg_data[]|XX|len  |level|type |XX|cmsg_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.
   "XX"と示したフィールドは、もし実装が必要なら、cmsghdr構造体とデータの
   間、データと次のcmsghdr構造体の間に可能なパディングです。

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

   To aid in the manipulation of ancillary data objects, three macros
   from 4.4BSD are defined by Posix.1g: 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.1gによって定義されます: 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_level == ... && cmsgptr->cmsg_type == ... ) {
            u_char  *ptr;

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

   We now describe the three Posix.1g 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.1gマクロを記述します、次の2つ以降はこのAPIで新
   規です:CMSG_SPACE()とCMSG_LEN()。全てのマクロは<sys/socket.h>で定義
   されます。

4.3.1.  CMSG_FIRSTHDR
4.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 the by 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に設定する事で示すからです。
   アプリケーションにテストを行わせるよりこのテストをマクロの中に置くの
   がより容易です。)

4.3.2.  CMSG_NXTHDR
4.3.2.  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.  This
   provides an alternative way of coding the processing loop shown
   earlier:
   次のこのマクロの動作はこのAPIで新規です:もしcmsgポインタ値がNULL
   なら、最初の補助的なデータオブジェクトを記述しているcmsghdr構造体への
   ポインタが返されます。すなわち、CMSG_NXTHDR(mhdr, NULL)は
   CMSG_FIRSTHDR(mhdr)と等価です。もし補助的なデータオブジェクトがないな
   ら、返りの値はNULLです。これは前記の処理ループのコードの他の方法を供
   給します:

struct msghdr  msg;
struct cmsghdr  *cmsgptr = NULL;

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

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

while ((cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) != NULL) {
    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((cmsg)->cmsg_len) \
                             + ALIGN(sizeof(struct cmsghdr)) > \
            (u_char *)((mhdr)->msg_control) + (mhdr)->msg_controllen) ? \
           (struct cmsghdr *)NULL : \
           (struct cmsghdr *)((u_char *)(cmsg) + ALIGN((cmsg)->cmsg_len))) )

   The macro ALIGN(), which is implementation dependent, rounds its
   argument up to the next even multiple of whatever alignment is
   required (probably a multiple of 4 or 8 bytes).
   実装に依存するマクロALIGN()は必要な整列(恐らく4あるいは8バイトの倍
   数)に従うように引数を丸めます。

4.3.3.  CMSG_DATA
4.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(sizeof(struct cmsghdr)) )

4.3.4.  CMSG_SPACE
4.3.4.  CMSG_SPACE

       unsigned int CMSG_SPACE(unsigned int length);

   This macro is new with this API.  Given the length of an ancillary
   data object, CMSG_SPACE() returns 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, to
   allocate 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()マクロを使います。

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

       #define CMSG_SPACE(length) ( ALIGN(sizeof(struct cmsghdr)) + \
                                    ALIGN(length) )

4.3.5.  CMSG_LEN
4.3.5.  CMSG_LEN

       unsigned int CMSG_LEN(unsigned int 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メンバーに設定すべき値を返し
   ます。

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

       #define CMSG_LEN(length) ( ALIGN(sizeof(struct cmsghdr)) + length
       )

   Note the difference between CMSG_SPACE() and CMSG_LEN(), shown also
   in the figure in Section 4.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()の違いについて4.2章の図を見てくださ
   い:前者の合計は補助的なデータオブジェクトの終わりにパディングが必要
   で、後者は補助的なデータオブジェクトのcmsg_lenメンバーに設定すべき実
   際の長さです。

4.4.  Summary of Options Described Using Ancillary Data
4.4.  補助的なデータを使うオプションのまとめ

   There are six types of optional information described in this
   document that are passed between the application and the kernel using
   ancillary data:
   この文書は、アプリケーションとカーネル間で補助的なデータを使ってやり
   取りする6種類のオプション情報を記述します:

       1.  the send/receive interface and source/destination address,
       1.  送信/受信インタフェースとソース/宛先アドレス、
       2.  the hop limit,
       2.  ホップ限界、
       3.  next hop address,
       3.  次の転送先アドレス、
       4.  Hop-by-Hop options,
       4.  ホップ毎オプション、
       5.  Destination options, and
       5.  宛先オプション、
       6.  Routing header.
       6.  ルーティングヘッダー

   First, to receive any of this optional information (other than the
   next hop address, which can only be set), the application must call
   setsockopt() to turn on the corresponding flag:
   最初に、このオプション情報を受け取るため(次の転送先アドレス以外、こ
   れは必ず設定されます)、アプリケーションは対応するフラグをオンにする
   setsockopt()をコールします:

       int  on = 1;

       setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO,  &on, sizeof(on));
       setsockopt(fd, IPPROTO_IPV6, IPV6_HOPLIMIT, &on, sizeof(on));
       setsockopt(fd, IPPROTO_IPV6, IPV6_HOPOPTS,  &on, sizeof(on));
       setsockopt(fd, IPPROTO_IPV6, IPV6_DSTOPTS,  &on, sizeof(on));
       setsockopt(fd, IPPROTO_IPV6, IPV6_RTHDR,    &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()から、制御情報として
   返されます。

   Nothing special need be done to send any of this optional
   information; the application just calls sendmsg() and specifies one
   or more ancillary data objects as control information.
   このオプション情報を送るのに特別な事は必要がありません;アプリケー
   ションはsendmsg()を呼び、1つ以上の補助的なデータオブジェクトを制御情
   報として明示します。

   We also summarize the three cmsghdr fields that describe the
   ancillary data objects:
   我々は同じく補助的なデータオブジェクトを記述する3つのcmsghdrフィール
   ドをまとめます:

       cmsg_level    cmsg_type      cmsg_data[]               #times
       ------------  ------------   ------------------------  ------
       IPPROTO_IPV6  IPV6_PKTINFO   in6_pktinfo structure     once
       IPPROTO_IPV6  IPV6_HOPLIMIT  int                       once
       IPPROTO_IPV6  IPV6_NEXTHOP   socket address structure  once
       IPPROTO_IPV6  IPV6_HOPOPTS   implementation dependent  mult.
       IPPROTO_IPV6  IPV6_DSTOPTS   implementation dependent  mult.
       IPPROTO_IPV6  IPV6_RTHDR     implementation dependent  once

   The final column indicates how many times an ancillary data object of
   that type can appear as control information.  The Hop-by-Hop and
   Destination options can appear multiple times, while all the others
   can appear only one time.
   最終の欄はそのタイプの補助的なデータオブジェクトが、何回、制御情報と
   して現われることができるか示します。ホップ毎オプションと宛先オプショ
   ンは何度も現れる事ができて、他が1回だけ現われることができます。

   All these options are described in detail in following sections.  All
   the constants beginning with IPV6_ are defined as a result of
   including the <netinet/in.h> header.
   これらすべてのオプションは後の章で詳細に記述します。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").  This is
   consistent with the existing use of ancillary data in 4.4BSD:
   returning the destination address of an IPv4 datagram.)
   (ノート:我々は意図的にgetsockopt()とsetsockopt()の2番目の引数("レ
   ベル"と呼ばれるもの)として使うcmsg_levelメンバーのために同じ定数を使
   い、getsockopt()とsetsockopt()の3番目の引数 ("オプション名"と呼ばれ
   るもの)として使うcmsg_typeメンバーのために同じ定数を使います。これは
   4.4BSDの補助的なデータの既存の使用と一貫しています:IPv4データ
   グラムの宛先アドレスを返す。)

   (Note: It is up to the implementation what it passes as ancillary
   data for the Hop-by-Hop option, Destination option, and Routing
   header option, since the API to these features is through a set of
   inet6_option_XXX() and inet6_rthdr_XXX() functions that we define
   later.  These functions serve two purposes: to simplify the interface
   to these features (instead of requiring the application to know the
   intimate details of the extension header formats), and to hide the
   actual implementation from the application.  Nevertheless, we show
   some examples of these features that store the actual extension
   header as the ancillary data.  Implementations need not use this
   technique.)
   (ノート:これらの機能へのAPIが後に定義するinet6_option_XXX()や
   inet6_rthdr_XXX()関数を使うので、ホップ毎オプションや宛先オプションや
   ルーティングヘッダーオプションの補助的なデータとして何を渡すかは実装
   依存です。これらの関数は2つの目的を満たします:(アプリケーションが
   拡張ヘッダーフォーマットの詳細な細部を知るように要求する代わりに)こ
   れらの機能へのインタフェースを単純化し、アプリケーションから実際の実
   装を隠します。にもかかわらず、我々は補助的なデータとして実際の拡張ヘッ
   ダーを登録するこれらの機能の例を見せます。実装がこのテクニックを使う
   必要がありません。)

4.5.  IPV6_PKTOPTIONS Socket Option
4.5.  IPV6_PKTOPTIONSソケットオプション

   The summary in the previous section assumes a UDP socket.  Sending
   and receiving ancillary data is easy with UDP: the application calls
   sendmsg() and recvmsg() instead of sendto() and recvfrom().
   前章のまとめはUDPソケットを想定します。補助的なデータの送受信はU
   DPで容易です:アプリケーションはsendto()とrecvfrom()の代わりに
   sendmsg()とrecvmsg()を呼びます。

   But there might be cases where a TCP application wants to send or
   receive this optional information.  For example, a TCP client might
   want to specify a Routing header and this needs to be done before
   calling connect().  Similarly a TCP server might want to know the
   received interface after accept() returns along with any Destination
   options.
   しかし、TCPアプリケーションがこのオプション情報の送受信を望む場合
   があるかもしれません。例えば、TCPクライアントがルーティングヘッダー
   を指定することを望むかもしれません、これはconnect()を呼び出す前にする
   必要があります。同様にTCPサーバーが宛先オプションと共にaccept()が
   返った後に受信インタフェースを知ることを望むかもしれません。

   A new socket option is defined that provides access to the optional
   information described in the previous section, but without using
   recvmsg() and sendmsg().  Setting the socket option specifies any of
   the optional output fields:
   前章で記述されたオプション情報に、recvmsg()とsendmsg()を使わないで、
   アクセスを供給する新しいソケットオプションが定義されます。ソケットオ
   プションの設定はオプション出力フィールドのどれかを指定します:

       setsockopt(fd, IPPROTO_IPV6, IPV6_PKTOPTIONS, &buf, len);

   The fourth argument points to a buffer containing one or more
   ancillary data objects, and the fifth argument is the total length of
   all these objects.  The application fills in this buffer exactly as
   if the buffer were being passed to sendmsg() as control information.
   4番目の引数は1つ以上の補助的なデータオブジェクトを含むバッファを指
   し示します、そして5番目の引数はこれらすべてのオブジェクトの全体の長
   さです。アプリケーションは制御情報としてsendmsg()に渡されるの同じよう
   に、このバッファを記入します。

   The options set by calling setsockopt() for IPV6_PKTOPTIONS are
   called "sticky" options because once set they apply to all packets
   sent on that socket.  The application can call setsockopt() again to
   change all the sticky options, or it can call setsockopt() with a
   length of 0 to remove all the sticky options for the socket.
   IPV6_PKTOPTIONSのsetsockoptを()を呼ぶことで設定したオプションは、1度
   設定するとそのソケットで送る全てのパケットに適用されるので「貼付き」
   オプションと呼ばれます。アプリケーションはすべての貼付きオプションを
   変えるため再度setsockopt()を呼ぶ事ができ、長さ0setsockopt()を呼ぶ事
   でソケットの全ての貼付きオプションを削除できます。

   The corresponding receive option
   対応する受信オプション

       getsockopt(fd, IPPROTO_IPV6, IPV6_PKTOPTIONS, &buf, &len);

   returns a buffer with one or more ancillary data objects for all the
   optional receive information that the application has previously
   specified that it wants to receive.  The fourth argument points to
   the buffer that is filled in by the call.  The fifth argument is a
   pointer to a value-result integer: when the function is called the
   integer specifies the size of the buffer pointed to by the fourth
   argument, and on return this integer contains the actual number of
   bytes that were returned.  The application processes this buffer
   exactly as if the buffer were returned by recvmsg() as control
   information.
   は、アプリケーションが前もって受信したいと指定した全ての受信オプショ
   ンである1つ以上の補助的なデータオブジェクトを含むバッファを返します。
   4番目の引数は呼び出しで記入されるバッファを指し示します。5番目の引
   数は値結果整数へのポインタです:関数が呼ばれたとき、整数は4番目の引
   数で示したバッファのサイズを示し、返された実際のバイト数を返します。
   アプリケーションはバッファをrecvmsg()の返す制御情報と同じように処理し
   ます。

   To simplify this document, in the remaining sections when we say "can
   be specified as ancillary data to sendmsg()" we mean "can be
   specified as ancillary data to sendmsg() or specified as a sticky
   option using setsockopt() and the IPV6_PKTOPTIONS socket option".
   Similarly when we say "can be returned as ancillary data by
   recvmsg()" we mean "can be returned as ancillary data by recvmsg() or
   returned by getsockopt() with the IPV6_PKTOPTIONS socket option".
   この文書を単純化するために、以降の章で「sendmsg()の補助的なデータに指
   定できます」と言った場合、これは「sendmsg()の補助的なデータに指定でき
   るか、setsockopt()とIPV6_PKTOPTIONSソケットオプションを使って貼付きオ
   プションに指定できます」を意味します。同様に「recvmsg()で補助的なデー
   タとして返せます」と言う場合、「recvmsg()で補助的なデータとして返せる
   か、IPV6_PKTOPTIONSソケットオプションでgetsockopt()で返せます」を意味
   します。

4.5.1.  TCP Sticky Options
4.5.1.  TCP貼付きオプション

   When using getsockopt() with the IPV6_PKTOPTIONS option and a TCP
   socket, only the options from the most recently received segment are
   retained and returned to the caller, and only after the socket option
   has been set.  That is, TCP need not start saving a copy of the
   options until the application says to do so.
   IPV6_PKTOPTIONSオプションのgetsockopt()とTCPソケットを使う時、最も
   最近受け取ったセグメントのオプションだけが維持されて、ソケットオブ
   ションが設定された後にだけ呼び出しで返されます。すなわち、TCPは、
   アプリケーションがそうするように言うまで、オプションのコピーを保存し
   始める必要がありません。

   The application is not allowed to specify ancillary data in a call to
   sendmsg() on a TCP socket, and none of the ancillary data that we
   describe in this document is ever returned as control information by
   recvmsg() on a TCP socket.
   アプリケーションはTCPソケットのsendmsg()呼び出しで補助的なデータを
   指定することを許されません、そして我々がこの文書で記述する補助的なデー
   タのいずれもTCPソケットのrecvmsg()の制御情報として返されません。

4.5.2.  UDP and Raw Socket Sticky Options
4.5.2.  UDPと生ソケット貼付きオプション

   The IPV6_PKTOPTIONS socket option can also be used with a UDP socket
   or with a raw IPv6 socket, normally to set some of the options once,
   instead of with each call to sendmsg().
   IPV6_PKTOPTIONSソケットオプションははUDPソケットや生IPv6ソケッ
   トで使われることができ、通常各sendmsg()呼び出しではなく1度だけオプ
   ションを設定します。

   Unlike the TCP case, the sticky options can be overridden on a per-
   packet basis with ancillary data specified in a call to sendmsg() on
   a UDP or raw IPv6 socket.  If any ancillary data is specified in a
   call to sendmsg(), none of the sticky options are sent with that
   datagram.
   TCPの場合と異なり、貼付きオプションはUDPあるいは生IPv6ソケッ
   ト上のsendmsg()でパケット毎の補助的なデータの上書きができます。もし補
   助的なデータがsendmsg()呼び出しで指定されるなら、貼付きオプションはそ
   のデータグラムで送られません。

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

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

       1.  the source IPv6 address,
       1.  ソースIPv6アドレス、
       2.  the outgoing interface index,
       2.  外向インタフェースインデックス、
       3.  the outgoing hop limit, and
       3.  外向ホップ限界、そして
       4.  the next hop address.
       4.  次の転送先アドレス

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

       1.  the destination IPv6 address,
       1.  宛先IPv6アドレス、
       2.  the arriving interface index, and
       2.  到着インタフェースインデックス、そして
       3.  the arriving hop limit.
       3.  到着ホップ限界

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

       struct in6_pktinfo {
         struct in6_addr ipi6_addr;    /* src/dst IPv6 address */
         unsigned int    ipi6_ifindex; /* send/recv interface index */
       };

   In the cmsghdr structure containing this ancillary data, the
   cmsg_level member will be IPPROTO_IPV6, the cmsg_type member will be
   IPV6_PKTINFO, and the first byte of cmsg_data[] will be the first
   byte of the in6_pktinfo structure.
   この補助的なデータを含んでいるcmsghdr構造体で、cmsg_levelメンバーは
   IPPROTO_IPV6であろう、cmsg_typeメンバーはIPV6_PKTINFOとcmsg_data[]の
   最初のバイトであろうin6_pktinfo構造体の最初のバイトであろう。

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

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

   Nothing special need be done to send this information: just specify
   the control information as ancillary data for sendmsg().
   この情報を送るため特別なことは必要ありません:制御情報をsendmsg()の補
   助的なデータとして指定します。

   (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_PKTINFO 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_PKTINFOソケットオプショ
   ンを利用可能にし、次にrecvmsg()から受信した制御情報をsendmsg()のため
   の外向制御情報として用いることができます。アプリケーションはまったく
   in6_pktinfo構造体を調査したり修正したりする必要がありません。けれども
   もしホップ限界がこの構造体にあれば、アプリケーションは受信制御情報を
   解析し、受信ホップ限界が外向パケットに望ましい値ではない場合、ホップ
   限界メンバーを変えなければならないでしょう。)

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

   Interfaces on an IPv6 node are identified by a small positive
   integer, as described in Section 4 of [RFC-2133].  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-2133]の4章で記述されるように、
   小さい正の整数によって識別されます。その文書はインタフェース名をその
   インタフェースインデックスに変換する関数と、インタフェースインデック
   スをインタフェース名に変換する関数と、すべてのインタフェース名とイン
   デックスを返す関数を記述します。この文書からインタフェースにインデッ
   クス0が割り当てられないことに注意してください。

   When specifying the outgoing interface, if the ipi6_ifindex value is
   0, the kernel will choose the outgoing interface.  If the application
   specifies an outgoing interface for a multicast packet, the interface
   specified by the ancillary data overrides any interface specified by
   the IPV6_MULTICAST_IF socket option (described in [RFC-2133]), for
   that call to sendmsg() only.
   外向インタフェースを指定する時、もしipi6_ifindex値が0であるなら、カー
   ネルは外向インタフェースを選択するでしょう。もしアプリケーションがマ
   ルチキャストパケットの外向インタフェースを指定するなら、補助的なデー
   タによって指定されたインタフェースは、sendmsg()を呼び出すときのみ、
   ([RFC-2133]で記述された) IPV6_MULTICAST_IFソケットオプションで指定
   されたインタフェースを上書きします。

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

5.2.  Specifying/Receiving Source/Destination Address
5.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), 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)
   であるなら、(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 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アドレスを含んでいます。

5.3.  Specifying/Receiving the Hop Limit
5.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-2133].  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 programs
   such as Traceroute and 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-2133]で
   指定されます。ホップ限界を補助的なデータとして明示することで、アプリ
   ケーションをひとつの出力オペレーションで、ユニキャスト宛先かマルチキャ
   スト宛先で、カーネルのデフォルトか前に指定された値を上書きします。受
   信ホップ限界を返すことは、Tracerouteや受信ホップ限界が255である
   (つまりパケットが転送されていない)ことを確かめる必要があるIPv6
   アプリケーションのような、プログラムに役立ちます。

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

       int  on = 1;
       setsockopt(fd, IPPROTO_IPV6, IPV6_HOPLIMIT, &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-2133], the interpretation of the integer hop limit
   value is
   外向ホップ限界を指定するために特別なことは必要ありません:制御情報を
   sendmsg()の補助的なデータとして明示してください。[RFC-2133]で指定され
   るように、整数ホップ限界値の解釈は以下です。

       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エラーを返す

5.4.  Specifying the Next Hop Address
5.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を持っていなくては
   ならないことを意味するために、この用語を使います。)

   If the socket address structure contains an IPv6 address (e.g., the
   sin6_family member is AF_INET6), then 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.
   もしソケットアドレス構造体がIPv6アドレスを含んでいる(つまり、
   sin6_familyメンバーがAF_INET6である)なら、そのアドレスによって識別
   されたノードは送信ホストの近隣であるに違いありません。もしそのアドレ
   スがデータグラムの宛先IPv6アドレスに一致するなら、これは既存の
   SO_DONTROUTEソケットオプションと等しいです。

5.5.  Additional Errors with sendmsg()
5.5.  sendmsg()の追加のエラー

   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().  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()で追加のエラーがありえます。次は例ですが、これらのいくつかは
   実装によっては供給されないかもしれず、ある実装が追加のエラーを定義す
   るかもしれません:

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

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

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

   EHOSTUNREACH  No route to the destination exists over the interface
                 specified by ifi6_ifindex.
   EHOSTUNREACH  宛先へのルートがifi6_ifindexによって指定されたインタ
                 フェースの上に存在しません。

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

   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.
   複数のホップ毎オプションがひとつのホップ毎オプションヘッダーに現われ
   ることができます。各ヘッダーのオプションがタイプと長さと値でTLVコー
   ド化されています。

   Today only three Hop-by-Hop options are defined for IPv6 [RFC-1883]:
   Jumbo Payload, Pad1, and PadN, although a proposal exists for a
   router-alert Hop-by-Hop option.  The Jumbo Payload option should not
   be passed back to an application and an application should receive an
   error if it attempts to set it.  This option is processed entirely by
   the kernel.  It is indirectly specified by datagram-based
   applications as the size of the datagram to send and indirectly
   passed back to these applications as the length of the received
   datagram.  The two pad options are for alignment purposes and are
   automatically inserted by a sending kernel when needed and ignored by
   the receiving kernel.  This section of the API is therefore defined
   for future Hop-by-Hop options that an application may need to specify
   and receive.
   現在3つのホップ毎オプションだけがIPv6で定義されています[RFC-1883]:
   巨大ペイロード、パッド1、パッドN、提案としてはルーター警告ホップ毎
   オプションが存在します。巨大ペイロードオプションはアプリケーションに
   渡されるべきでなく、アプリケーションがそれをつけようと試みるならエラー
   を受けるべきです。このオプションは完全にカーネルで処理されます。これ
   は送るべきデータグラムの大きさとして間接的にデータグラムベースのアプ
   リケーションに指定され、受信データグラムの長さとして間接的にこれらの
   アプリケーションに渡されます。2つのパッドオプションは整列の目的のた
   めであり、必要な時に自動的に送信カーネルで挿入し、受信カーネルが無視
   します。従ってこのAPIの章はアプリケーションが指定し受信する必要が
   あるかもしれない未来のホップ毎オプションのために定義されます。

   Individual Hop-by-Hop options (and Destination options, which are
   described shortly, and which are 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 A of [RFC-1883].  The alignment
   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.  Whatever code builds
   either a Hop-by-Hop options header or a Destination options header
   must know the values of x and y for each option.
   個別のホップ毎オプション(と後で記述するホップ毎オプションに類似して
   いる宛先オプション)は特定の整列条件を持っているかもしれません。例え
   ば、4バイトの巨大ペイロード長は4バイト境界に現われるべきで、IPv
   6アドレスが通常8バイト境界上に並べられます。これらのオプションの条
   件と用語は4.2章と[RFC-1883]の付録Aで論じられます。各オプションの
   整列はxとyと呼ばれる2つの値で、"xn+y"と書かて指定されます。これはオ
   プションがオプションヘッダーの先頭から、xバイトの整数倍(xの価は1
   か2か4か8)、足す、yバイト(yが0以上7以下の値)に現われなくて
   はならないと述べます。Pad1とPadNオプションは必要とされる整列
   をするため必要に応じて差し込まれます。ホップ毎オプションヘッダーある
   いは宛先オプションヘッダーを組み立てるプログラムは、各オプションのx
   とyの値を知っていなくてはなりません。

   Multiple Hop-by-Hop options can be specified by the application.
   Normally one ancillary data object describes all the Hop-by-Hop
   options (since each option is itself TLV-encoded) but the application
   can specify multiple ancillary data objects for the Hop-by-Hop
   options, each object specifying one or more options.  Care must be
   taken designing the API for these options since
   アプリケーションが多数のホップ毎オプションを指定できます。(各オプショ
   ンがそれぞれTLVでコードされているので)通常1つの補助的なデータオ
   ブジェクトがすべてのホップ毎オプションを記述しますが、アプリケーショ
   ンはそれぞれ1つ以上のオプションを指定している多数のホップ毎オプショ
   ンの補助的なデータオブジェクトを指定できます。以下の理由で、これらの
   オプションのAPI設計に注意しなければなりません。

   1.   it may be possible for some future Hop-by-Hop options to be
        generated by the application and processed entirely by the
        application (e.g., the kernel may not know the alignment
        restrictions for the option),
   1.   ある未来のホップ毎オプションがアプリケーションによって生成され、
        アプリケーションが完全に処理可能であるかもしれません(例えばカー
        ネルがオプションの整列条件を知らないかもしれません)、

   2.   it must be possible for the kernel to insert its own Hop-by-Hop
        options in an outgoing packet (e.g., the Jumbo Payload option),
   2.   外向パケットでカーネル自身のホップ毎オプション(例えば、巨大ペイ
        ロードオプション)を差し込むことが可能であるに違いありません、

   3.   the application can place one or more Hop-by-Hop options into a
        single ancillary data object,
   3.   アプリケーションは、補助的なデータオブジェクトの中に、1つ以上の
        ホップ毎オプションを置くことができます、

   4.   if the application specifies multiple ancillary data objects,
        each containing one or more Hop-by-Hop options, the kernel must
        combine these a single Hop-by-Hop options header, and
   4.   もしアプリケーションがそれぞれ1つ以上のホップ毎オプションを含ん
        でいる多数の補助的なデータオブジェクトを指定するなら、カーネルは
        ひとつのホップ毎オプションヘッダにこれらを結合しなくてはなりませ
        ん、そして、

   5.   it must be possible for the kernel to remove some Hop-by-Hop
        options from a received packet before returning the remaining
        Hop-by-Hop options to the application.  (This removal might
        consist of the kernel converting the option into a pad option of
        the same length.)
   5.   カーネルがアプリケーションに受信ホップ毎オプションを返す前にある
        ホップ毎オプションを受信パケットから取り除くことが可能であるに違
        いありません。(この取り除きはカーネルがオプションを同じ長さのパッ
        ドオプションに変換することかもしれません。)

   Finally, we note that access to some Hop-by-Hop options or to 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.
   最終的に、我々はあるホップ毎オプションやある宛先オプションへのアクセ
   スに、特別な特権を必要とするかもしれないことを指摘します。すなわち、
   標準的なアプリケーション(特別な特権がない)がある特定のオプションを
   外向パケットにセットすることを禁止されるかもしれなくて、受信パケット
   である特定のオプションを見れないかもしれません。

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

   To receive Hop-by-Hop options the application must enable the
   IPV6_HOPOPTS socket option:
   ホップ毎オプションを受け取るために、アプリケーションはIPV6_HOPOPTSソ
   ケットオプションを可能にしなくてはなりません:

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

   All the Hop-by-Hop options are returned as one ancillary data object
   described by a cmsghdr structure.  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_option_next() and
   inet6_option_find() functions, described shortly.
   すべてのホップ毎オプションはcmsghdr構造体で記述されたひとつの補助的な
   データオブジェクトとして返されます。cmsg_levelメンバーはIPPROTO_IPV6
   であるでしょう、そしてcmsg_typeメンバーはIPV6_HOPOPTSであるでしょう。
   これらのオプションはまもなく記述するinet6_option_next()と
   inet6_option_find()関数を呼ぶことで処理されます。

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

   To send one or more Hop-by-Hop options, the application just
   specifies them as ancillary data in a call to sendmsg().  No socket
   option need be set.
   1つ以上のホップ毎オプションを送るために、アプリケーションはsendmsg()
   への呼び出しでそれらを補助的なデータとして明示します。ソケットオプショ
   ンは設定する必要がありません。

   Normally all the Hop-by-Hop options are specified by a single
   ancillary data object.  Multiple ancillary data objects, each
   containing one or more Hop-by-Hop options, can also be specified, in
   which case the kernel will combine all the Hop-by-Hop options into a
   single Hop-by-Hop extension header.  But it should be more efficient
   to use a single ancillary data object to describe all the Hop-by-Hop
   options.  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_option_init(), inet6_option_append(), and
   inet6_option_alloc() functions, described shortly.
   通常すべてのホップ毎オプションはひとつの補助的なデータオブジェクトで
   指定されます。それぞれ1つ以上のホップ毎オプションを含んでいる多数の
   補助的なデータオブジェクトも指定できます、そしてその場合カーネルはひ
   とつのホップ毎拡張ヘッダーにすべてのホップ毎オプションを結合するでしょ
   う。けれどもすべてのホップ毎オプションを記述するためにひとつの補助的
   なデータオブジェクトを使うことはより効率的であるべきです。cmsg_level
   メンバーはIPPROTO_IPV6が設定され、cmsg_typeメンバーはIPV6_HOPOPTSが設
   定されます。オプションは通常、まもなく記述されるinet6_option_init()と
   inet6_option_append()とinet6_option_alloc()で構築されます。

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

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

   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.  The function prototypes for
   these functions are all in the <netinet/in.h> header.
   ホップ毎と宛先オプションの生成と解析は前に書いた理由で複雑です。従っ
   て我々はアプリケーションに手を貸すための関数を定義します。これらの関
   数のプロトタイプはすべて<netinet/in.h>ヘッダにあります。

6.3.1.  inet6_option_space
6.3.1.  inet6_option_space

       int inet6_option_space(int nbytes);

   This function returns the number of bytes required to hold an option
   when it is stored as ancillary data, including the cmsghdr structure
   at the beginning, and any padding at the end (to make its size a
   multiple of 8 bytes).  The argument is the size of the structure
   defining the option, which must include any pad bytes at the
   beginning (the value y in the alignment term "xn + y"), the type
   byte, the length byte, and the option data.
   この関数は補助的なデータとして登録した場合に、始めのcmsghdr構造体と、
   終わりの(8の倍数バイトにするための)パディングを含めて、オプション
   を記憶するのに必要なバイト数を返します。引数はオプションを定義する構
   造体の大きさで、先頭にパディングバイト(整列用語「 xn  + y」での値
   y)と、タイプバイトと長さバイトとオプションデータを含まなくてはなり
   ません。

   (Note: If multiple options are stored in a single ancillary data
   object, which is the recommended technique, this function
   overestimates the amount of space required by the size of N-1 cmsghdr
   structures, where N is the number of options to be stored in the
   object.  This is of little consequence, since it is assumed that most
   Hop-by-Hop option headers and Destination option headers carry only
   one option (p. 33 of [RFC-1883]).)
   (ノート:もし多数のオプションがであるひとつの補助的なデータオブジェ
   クトに登録されるなら、これは推薦されたテクニックですが、Nをオブジェ
   クトにしまうオプションすうとすると、この関数はN-1個のcmsghdr構造体
   の大きさに必要なスペースの量を過大に見積もります。これは、たいていの
   ホップ毎オプションヘッダーと宛先オプションヘッダーがただ1つのオプ
   ションを伴うと想定されるので([RFC-1883]のページ33)、影響はたいし
   た事はありません。)

6.3.2.  inet6_option_init
6.3.2.  inet6_option_init

       int inet6_option_init(void *bp, struct cmsghdr **cmsgp, int
       type);

   This function is called once per ancillary data object that will
   contain either Hop-by-Hop or Destination options.  It returns 0 on
   success or -1 on an error.
   この関数はホップ毎オプションか宛先オプションを含んでいるであろう補助
   的なデータオブジェクト毎に呼び出されます。これは成功すれば0をエラー
   なら−1を返します。

   bp is a pointer to previously allocated space that will contain the
   ancillary data object.  It must be large enough to contain all the
   individual options to be added by later calls to
   inet6_option_append() and inet6_option_alloc().
   bpは以前に割当てた、補助的なデータオブジェクトを含んでいるであろう空
   間へのポインタです。これは後で呼び出すinet6_option_append()と
   inet6_option_alloc()で加えられるすべてのオプションを含むのに十分な大
   きさに違いありません。

   cmsgp is a pointer to a pointer to a cmsghdr structure.  *cmsgp is
   initialized by this function to point to the cmsghdr structure
   constructed by this function in the buffer pointed to by bp.
   cmsgpはcmsghdr構造体へのポインタへのポインタです。*cmsgpがbpのポイン
   トしたバッファ内にこの関数が作ったcmsghdr構造体をポイントするように
   初期化されます。

   type is either IPV6_HOPOPTS or IPV6_DSTOPTS.  This type is stored in
   the cmsg_type member of the cmsghdr structure pointed to by *cmsgp.
   typeはIPV6_HOPOPTSかIPV6_DSTOPTSです。typeは*cmsgpでポイントされた
   cmsghdr構造体のcmsg_typeメンバーにしまっておかれます。

6.3.3.  inet6_option_append
6.3.3.  inet6_option_append

       int inet6_option_append(struct cmsghdr *cmsg, const uint8_t *typep,
                               int multx, int plusy);

   This function appends a Hop-by-Hop option or a Destination option
   into an ancillary data object that has been initialized by
   inet6_option_init().  This function returns 0 if it succeeds or -1 on
   an error.
   この関数はinet6_option_init()で初期化された補助的なデータオブジェクト
   の中へのホップ毎オプションや宛先オプションを付加します。もし成功する
   ならこの関数は0を返し、エラーなら-1を返します。

   cmsg is a pointer to the cmsghdr structure that must have been
   initialized by inet6_option_init().
   cmsgはinet6_option_init()によって初期化されたに違いないcmsghdr構造体
   へのポインタです。

   typep is a pointer to the 8-bit option type.  It is assumed that this
   field is immediately followed by the 8-bit option data length field,
   which is then followed immediately by the option data.  The caller
   initializes these three fields (the type-length-value, or TLV) before
   calling this function.
   typepは8ビットのオプションタイプへのポインタです。このフィールドの直
   後に8ビットのオプションデータ長さフィールドが続くと想定され、その直
   後にオプションデータが続くと想定されます。この関数を呼び出す前にこれ
   らの3つのフィールド(タイプ−長さ−値、TLV)を初期化します。

   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がそれぞれPa
   d1と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以下で、後に続くオプションデータの
   長さです。

   multx is the value x in the alignment term "xn + y" described
   earlier.  It must have a value of 1, 2, 4, or 8.
   multxは前に書いた「xn+y」整列の価xです。これは1か2か4か8の値で
   す。

   plusy is the value y in the alignment term "xn + y" described
   earlier.  It must have a value between 0 and 7, inclusive.
   plusyは前に書いた「xn+y」整列の価yです。これは0以上7以下です。

6.3.4.  inet6_option_alloc
6.3.4.  inet6_option_alloc

       uint8_t *inet6_option_alloc(struct cmsghdr *cmsg, int datalen,
                                    int multx, int plusy);

   This function appends a Hop-by-Hop option or a Destination option
   into an ancillary data object that has been initialized by
   inet6_option_init().  This function returns a pointer to the 8-bit
   option type field that starts the option on success, or NULL on an
   error.
   この関数はinet6_option_init()で初期化された補助的なデータオブジェクト
   の中へのホップ毎オプションか宛先オプションを追加します。この関数は成
   功した場合オプションの開始の8ビットのオプションタイプフィールドへの
   ポインタを返し、エラー場合NULLを返します。

   The difference between this function and inet6_option_append() is
   that the latter copies the contents of a previously built option into
   the ancillary data object while the current function returns a
   pointer to the space in the data object where the option's TLV must
   then be built by the caller.
   この関数とinet6_option_append()の間の相違は、後者が以前に作ったオプ
   ションの中身を補助的なデータオブジェクトにコピーし、この関数がデータ
   オブジェクト空間へのポインタを返し、オプションのTLVは呼び出し人が
   作らなければいけないということです。

   cmsg is a pointer to the cmsghdr structure that must have been
   initialized by inet6_option_init().
   cmsgはinet6_option_init()で初期化されたに違いないcmsghdr構造体へのポ
   インタです。

   datalen is the value of the option data length byte for this option.
   This value is required as an argument to allow the function to
   determine if padding must be appended at the end of the option.  (The
   inet6_option_append() function does not need a data length argument
   since the option data length must already be stored by the caller.)
   datalenはこのオプションのオプションデータ長バイトの値です。この値は関
   数がオプションの後にパディングが必要かを決定するために必要な引数です。
   (inet6_option_append()関数は、オプションデータ長を呼び出し人が設定し
   ているので、データ長引数を必要としません。)

   multx is the value x in the alignment term "xn + y" described
   earlier.  It must have a value of 1, 2, 4, or 8.
   multxは前に書いた「xn+y」整列の価xです。これは1か2か4か8の値で
   す。

   plusy is the value y in the alignment term "xn + y" described
   earlier.  It must have a value between 0 and 7, inclusive.
   plusyは前に書いた「xn+y」整列の価yです。これは0以上7以下です。

6.3.5.  inet6_option_next
6.3.5.  inet6_option_next

       int inet6_option_next(const struct cmsghdr *cmsg, uint8_t
       **tptrp);

   This function processes the next Hop-by-Hop option or Destination
   option in an ancillary data object.  If another option remains to be
   processed, the return value of the function is 0 and *tptrp points to
   the 8-bit option type field (which is followed by the 8-bit option
   data length, followed by the option data).  If no more options remain
   to be processed, the return value is -1 and *tptrp is NULL.  If an
   error occurs, the return value is -1 and *tptrp is not NULL.
   この関数は補助的なデータオブジェクトの次のホップ毎オプションか宛先オ
   プションを処理します。もし他のオプションを処理しなければならないなら、
   関数の返り値は0で、*tptrpは8ビットオプションタイプフィールドをポイ
   ントします(その後に8ビットのオプションデータ長とオプションデータが
   続きます)。もしこれ以上のオプションが処理が必要なければ、返り値は-1
   で、*tptrpはNULLです。もしエラーが起きたら返り値は-1で、*tptrpはNULL
   でありません。

   cmsg is a pointer to cmsghdr structure of which cmsg_level equals
   IPPROTO_IPV6 and cmsg_type equals either IPV6_HOPOPTS or
   IPV6_DSTOPTS.
   cmsgはcmsghdr構造体へのポインタで、この構造体のcmsg_levelは
   IPPROTO_IPV6に一致し、cmsg_typeがIPV6_HOPOPTSかIPV6_DSTOPTSに一致します。

   tptrp is a pointer to a pointer to an 8-bit byte and *tptrp is used
   by the function to remember its place in the ancillary data object
   each time the function is called.  The first time this function is
   called for a given ancillary data object, *tptrp must be set to NULL.
   tptrpは8ビットのバイトへのポインタのポインタで、*tptrpは関数が呼ばれ
   る度に関数が補助的なデータオブジェクトの場所を覚えるために使われます。
   ある補助的なデータオブジェクトに対して最初にこの関数を呼ぶ際には、
   *tptrpはNULLを設定しなければなりません。

   Each time this function returns success, *tptrp points to the 8-bit
   option type field for the next option to be processed.
   この関数が成功するたびに、*tptrpは次に処理すべき8ビットオプションタ
   イプフィールドをポイントします。

6.3.6.  inet6_option_find
6.3.6.  inet6_option_find

       int inet6_option_find(const struct cmsghdr *cmsg, uint8_t *tptrp,
                             int type);

   This function is similar to the previously described
   inet6_option_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 ancillary data object.  cmsg is a
   pointer to cmsghdr structure of which cmsg_level equals IPPROTO_IPV6
   and cmsg_type equals either IPV6_HOPOPTS or IPV6_DSTOPTS.
   この関数は前に記述されたinet6_option_next()関数に類似しています、違い
   は、関数が常に補助的なデータオブジェクトの次のオプションを返すのでは
   なく、関数を呼び出す際に検索するオプションタイプを指定する事です。
   cmsgはcmsghdr構造体へのポインタで、この構造体のcmsg_levelがIPPROTO_IPV6
   と一致し、cmsg_typeがIPV6_HOPOPTSかIPV6_DSTOPTSに一致します。

   tptrp is a pointer to a pointer to an 8-bit byte and *tptrp is used
   by the function to remember its place in the ancillary data object
   each time the function is called.  The first time this function is
   called for a given ancillary data object, *tptrp must be set to NULL.
   tptrpは8ビットのバイトへのポインタのポインタで、*tptrpは関数が呼ばれ
   る度に関数が補助的なデータオブジェクトの場所を覚えるために使われます。
   ある補助的なデータオブジェクトに対して最初にこの関数を呼ぶ際には、
   *tptrpはNULLを設定しなければなりません。

   This function starts searching for an option of the specified type
   beginning after the value of *tptrp.  If an option of the specified
   type is located, this function returns 0 and *tptrp points to the 8-
   bit option type field for the option of the specified type.  If an
   option of the specified type is not located, the return value is -1
   and *tptrp is NULL.  If an error occurs, the return value is -1 and
   *tptrp is not NULL.
   この関数は*tptrp値で指定されたところから指定されたタイプのオプション
   を検索します。もし指定されたタイプのオプションがあれば関数は0を返し、
   *tptrpが指定したタイプのオプションの8ビットオプションタイプをポイント
   します。もし指定されたタイプのオプションがなければ、返り値は-1で、
   *tptrpはNULLです。もしエラーが起きたら、返り値は-1で、*tptrpはNULLで
   ありません。

6.3.7.  Options Examples
6.3.7.  オプション例

   We now provide an example that builds two Hop-by-Hop options.  First
   we define two options, called X and Y, taken from the example in
   Appendix A of [RFC-1883].  We assume that all options will have
   structure definitions similar to what is shown below.
   我々は今2つのホップ毎オプションを作る例を供給します。最初に我々は
   [RFC-1883]の付録Aの例から取り出されたXとYと呼ばれる2つのオプション
   を定義します。我々はすべてのオプションが以下に類似した構造体定義を持
   つと想定します。

        /* option X and option Y are defined in [RFC-1883], pp. 33-34 */
        /* オプションXとオプションYは[RFC-1883]の33−34ページで定義されます */
#define IP6_X_OPT_TYPE       X   /* replace X with assigned value */
#define IP6_X_OPT_LEN       12
#define IP6_X_OPT_MULTX      8   /* 8n + 2 alignment */
                                 /* 8n + 2 整列 */
#define IP6_X_OPT_OFFSETY    2

struct ip6_X_opt {
  uint8_t   ip6_X_opt_pad[IP6_X_OPT_OFFSETY];
  uint8_t   ip6_X_opt_type;
  uint8_t   ip6_X_opt_len;
  uint32_t  ip6_X_opt_val1;
  uint64_t  ip6_X_opt_val2;
};

#define IP6_Y_OPT_TYPE       Y   /* replace Y with assigned value */
                                 /* Yを割り当て値と取り替える */
#define IP6_Y_OPT_LEN        7
#define IP6_Y_OPT_MULTX      4   /* 4n + 3 alignment */
                                 /* 4n + 3 整列 */
#define IP6_Y_OPT_OFFSETY    3

struct ip6_Y_opt {
  uint8_t   ip6_Y_opt_pad[IP6_Y_OPT_OFFSETY];
  uint8_t   ip6_Y_opt_type;
  uint8_t   ip6_Y_opt_len;
  uint8_t   ip6_Y_opt_val1;
  uint16_t  ip6_Y_opt_val2;
  uint32_t  ip6_Y_opt_val3;
};

   We now show the code fragment to build one ancillary data object
   containing both options.
   我々は両方のオプションを含む1つの補助的なデータオブジェクトを作
   るコードの部分を示します。

struct msghdr  msg;
struct cmsghdr  *cmsgptr;
struct ip6_X_opt  optX;
struct ip6_Y_opt  optY;

msg.msg_control = malloc(inet6_option_space(sizeof(optX) +
                                            sizeof(optY)));

inet6_option_init(msg.msg_control, &cmsgptr, IPV6_HOPOPTS);

optX.ip6_X_opt_type = IP6_X_OPT_TYPE;
optX.ip6_X_opt_len  = IP6_X_OPT_LEN;
optX.ip6_X_opt_val1 = <32-bit value>;
optX.ip6_X_opt_val2 = <64-bit value>;
inet6_option_append(cmsgptr, &optX.ip6_X_opt_type,
                    IP6_X_OPT_MULTX, IP6_X_OPT_OFFSETY);

optY.ip6_Y_opt_type = IP6_Y_OPT_TYPE;
optY.ip6_Y_opt_len  = IP6_Y_OPT_LEN;
optY.ip6_Y_opt_val1 = <8-bit value>;
optY.ip6_Y_opt_val2 = <16-bit value>;
optY.ip6_Y_opt_val3 = <32-bit value>;
inet6_option_append(cmsgptr, &optY.ip6_Y_opt_type,
                    IP6_Y_OPT_MULTX, IP6_Y_OPT_OFFSETY);

msg.msg_controllen = cmsgptr->cmsg_len;

   The call to inet6_option_init() builds the cmsghdr structure in the
   control buffer.
   inet6_option_init()呼び出しは、制御バッファにcmsghdr構造体を作ります。

     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = CMSG_LEN(0) = 12                             |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_HOPOPTS                                |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   Here we assume a 32-bit architecture where sizeof(struct cmsghdr)
   equals 12, with a desired alignment of 4-byte boundaries (that is,
   the ALIGN() macro shown in the sample implementations of the
   CMSG_xxx() macros rounds up to a multiple of 4).
   ここで我々は32ビットアーキテクチャで、4バイト境界整列により、
   sizeof(struct cmsghdr)を仮定します(すなわち、CMSG_xxx( マクロの例示
   的実装で示されるALIGN()マクロは端数を4の倍数に切り上げます)。

   The first call to inet6_option_append() appends the X option.  Since
   this is the first option in the ancillary data object, 2 bytes are
   allocated for the Next Header byte and for the Hdr Ext Len byte.  The
   former will be set by the kernel, depending on the type of header
   that follows this header, and the latter byte is set to 1.  These 2
   bytes form the 2 bytes of padding (IP6_X_OPT_OFFSETY) required at the
   beginning of this option.
   inet6_option_append()への最初の呼び出しはオプションXを追加します。こ
   れが補助的なデータオブジェクトの最初のオプションであるので、次ヘッダー
   バイトとHdr長バイトして2バイトが割当てられます。前者はこのヘッダーの
   後に続くヘッダーのタイプに依存してカーネルにつけられるでしょう、そし
   て後者のバイトは1に設定されます。これらの2バイトはこのオプションの
   始めに必要な2バイトのパディング(IP6_X_OPT_OFFSETY)を構成します。

     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = 28                                           |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_HOPOPTS                                |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |  Next Header  | Hdr Ext Len=1 | Option Type=X |Opt Data Len=12|
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                         4-octet field                         |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                         8-octet field                         +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   The cmsg_len member of the cmsghdr structure is incremented by 16,
   the size of the option.
   cmsghdr構造体のcmsg_lenメンバーは、オプションの大きさ、16増加します。

   The next call to inet6_option_append() appends the Y option to the
   ancillary data object.
   inet6_option_append()への次の呼び出しは補助的なデータオブジェクトにY
   オプションを追加します。

     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = 44                                           |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_HOPOPTS                                |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |  Next Header  | Hdr Ext Len=3 | Option Type=X |Opt Data Len=12|
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                         4-octet field                         |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                         8-octet field                         +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     | PadN Option=1 |Opt Data Len=1 |       0       | Option Type=Y |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |Opt Data Len=7 | 1-octet field |         2-octet field         |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                         4-octet field                         |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     | PadN Option=1 |Opt Data Len=2 |       0       |       0       |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   16 bytes are appended by this function, so cmsg_len becomes 44.  The
   inet6_option_append() function notices that the appended data
   requires 4 bytes of padding at the end, to make the size of the
   ancillary data object a multiple of 8, and appends the PadN option
   before returning.  The Hdr Ext Len byte is incremented by 2 to become
   3.
   16バイトがこの関数で追加され、cmsg_lenが44になります。
   inet6_option_append()関数は付加したデータの終わりに、補助的なデータオ
   ブジェクトの大きさを8の倍数にするため、4バイトのパディングが必要と
   気づき、戻る前にPadNオプションを付加します。Hdr Ext Lenバイトは2増え
   て、3になります。

   Alternately, the application could build two ancillary data objects,
   one per option, although this will probably be less efficient than
   combining the two options into a single ancillary data object (as
   just shown).  The kernel must combine these into a single Hop-by-Hop
   extension header in the final IPv6 packet.
   代わりに、恐らく1つの補助的なデータオブジェクトに2つのオプションを
   結合するより効率が悪いが、アプリケーションはオプション毎にひとつの補
   助的なデータオブジェクトを作る事ができます。カーネルは最終的なIPv
   6パケットでひとつのホップ毎拡張ヘッダにこれらを結合しなくてはなりま
   せん。

       struct msghdr  msg;
       struct cmsghdr  *cmsgptr;
       struct ip6_X_opt  optX;
       struct ip6_Y_opt  optY;

       msg.msg_control = malloc(inet6_option_space(sizeof(optX)) +
                                inet6_option_space(sizeof(optY)));

       inet6_option_init(msg.msg_control, &cmsgptr, IPPROTO_HOPOPTS);

       optX.ip6_X_opt_type = IP6_X_OPT_TYPE;
       optX.ip6_X_opt_len  = IP6_X_OPT_LEN;
       optX.ip6_X_opt_val1 = <32-bit value>;
       optX.ip6_X_opt_val2 = <64-bit value>;
       inet6_option_append(cmsgptr, &optX.ip6_X_opt_type,
                           IP6_X_OPT_MULTX, IP6_X_OPT_OFFSETY);
       msg.msg_controllen = CMSG_SPACE(sizeof(optX));

       inet6_option_init((u_char *)msg.msg_control + msg.msg_controllen,
                         &cmsgptr, IPPROTO_HOPOPTS);

       optY.ip6_Y_opt_type = IP6_Y_OPT_TYPE;
       optY.ip6_Y_opt_len  = IP6_Y_OPT_LEN;
       optY.ip6_Y_opt_val1 = <8-bit value>;
       optY.ip6_Y_opt_val2 = <16-bit value>;
       optY.ip6_Y_opt_val3 = <32-bit value>;
       inet6_option_append(cmsgptr, &optY.ip6_Y_opt_type,
                           IP6_Y_OPT_MULTX, IP6_Y_OPT_OFFSETY);
       msg.msg_controllen += cmsgptr->cmsg_len;

   Each call to inet6_option_init() builds a new cmsghdr structure, and
   the final result looks like the following:
   各inet6_option_init()呼び出しが新しいcmsghdr構造体を作り、最終結果は
   次のように見えます:

     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = 28                                           |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_HOPOPTS                                |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |  Next Header  | Hdr Ext Len=1 | Option Type=X |Opt Data Len=12|
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                         4-octet field                         |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                         8-octet field                         +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = 28                                           |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_HOPOPTS                                |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |  Next Header  | Hdr Ext Len=1 | Pad1 Option=0 | Option Type=Y |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |Opt Data Len=7 | 1-octet field |         2-octet field         |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                         4-octet field                         |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     | PadN Option=1 |Opt Data Len=2 |       0       |       0       |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   When the kernel combines these two options into a single Hop-by-Hop
   extension header, the first 3 bytes of the second ancillary data
   object (the Next Header byte, the Hdr Ext Len byte, and the Pad1
   option) will be combined into a PadN option occupying 3 bytes.
   カーネルがひとつのホップ毎拡張ヘッダにこれらの2つのオプションを結合
   する時、2番目の補助的なデータオブジェクトの最初の3バイト(次ヘッダー
   バイト、 Hdr Ext LenバイトとPad1オプション)は3バイトのPadN
   オプションに結合されるでしょう。

   The following code fragment is a redo of the first example shown
   (building two options in a single ancillary data object) but this
   time we use inet6_option_alloc().
   次のコードは前の例(ひとつの補助的なデータオブジェクトに2つのオプショ
   ンを作る)の修正で、今回はinet6_option_alloc()を使います。

uint8_t  *typep;
struct msghdr  msg;
struct cmsghdr  *cmsgptr;
struct ip6_X_opt  *optXp;  /* now a pointer, not a struct */
                           /* 今は構造体ではなくポインタ */
struct ip6_Y_opt  *optYp;  /* now a pointer, not a struct */
                           /* 今は構造体ではなくポインタ */

msg.msg_control = malloc(inet6_option_space(sizeof(*optXp) +
                                            sizeof(*optYp)));

inet6_option_init(msg.msg_control, &cmsgptr, IPV6_HOPOPTS);

typep = inet6_option_alloc(cmsgptr, IP6_X_OPT_LEN,
                           IP6_X_OPT_MULTX, IP6_X_OPT_OFFSETY);
optXp = (struct ip6_X_opt *) (typep - IP6_X_OPT_OFFSETY);
optXp->ip6_X_opt_type = IP6_X_OPT_TYPE;
optXp->ip6_X_opt_len  = IP6_X_OPT_LEN;
optXp->ip6_X_opt_val1 = <32-bit value>;
optXp->ip6_X_opt_val2 = <64-bit value>;

typep = inet6_option_alloc(cmsgptr, IP6_Y_OPT_LEN,
                           IP6_Y_OPT_MULTX, IP6_Y_OPT_OFFSETY);
optYp = (struct ip6_Y_opt *) (typep - IP6_Y_OPT_OFFSETY);
optYp->ip6_Y_opt_type = IP6_Y_OPT_TYPE;
optYp->ip6_Y_opt_len  = IP6_Y_OPT_LEN;
optYp->ip6_Y_opt_val1 = <8-bit value>;
optYp->ip6_Y_opt_val2 = <16-bit value>;
optYp->ip6_Y_opt_val3 = <32-bit value>;

msg.msg_controllen = cmsgptr->cmsg_len;

   Notice that inet6_option_alloc() returns a pointer to the 8-bit
   option type field.  If the program wants a pointer to an option
   structure that includes the padding at the front (as shown in our
   definitions of the ip6_X_opt and ip6_Y_opt structures), the y-offset
   at the beginning of the structure must be subtracted from the
   returned pointer.
   inet6_option_alloc()が8ビットのオプションタイプフィールドへのポイン
   タを返すことに注意してください。もしプログラムが、(ip6_X_optと
   ip6_Y_opt構造体の定義に示されるように)前にパディングを含む、オプショ
   ン構造体へのポインタを求めるなら、構造体の始めのyオフセットを返され
   たポインタから引かなければなりません。

   The following code fragment shows the processing of Hop-by-Hop
   options using the inet6_option_next() function.
   次のコードはinet6_option_next()関数を使うホップ毎オプションの処理を
   示します。

    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_level == IPPROTO_IPV6 &&
            cmsgptr->cmsg_type == IPV6_HOPOPTS) {

            uint8_t  *tptr = NULL;

            while (inet6_option_next(cmsgptr, &tptr) == 0) {
                if (*tptr == IP6_X_OPT_TYPE) {
                    struct ip6_X_opt  *optXp;

                    optXp = (struct ip6_X_opt *) (tptr - IP6_X_OPT_OFFSETY);
                    <do whatever with> optXp->ip6_X_opt_val1;
                    <do whatever with> optXp->ip6_X_opt_val2;

                } else if (*tptr == IP6_Y_OPT_TYPE) {
                    struct ip6_Y_opt  *optYp;

                    optYp = (struct ip6_Y_opt *) (tptr - IP6_Y_OPT_OFFSETY);
                    <do whatever with> optYp->ip6_Y_opt_val1;
                    <do whatever with> optYp->ip6_Y_opt_val2;
                    <do whatever with> optYp->ip6_Y_opt_val3;
                }
            }
            if (tptr != NULL)
                <error encountered by inet6_option_next()>;
        }
    }

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

   A variable number of Destination options can appear in one or more
   Destination option headers.  As defined in [RFC-1883], 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 appearing after 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-1883]で定義されるように、ルーティングヘッダーの前
   に現われている宛先オプションヘッダーが最初の宛先と、ルーチングヘッダ
   で指定される続く宛先で処理され、ルーティングヘッダーの後に現われてい
   る宛先オプションヘッダーが最終の宛先でだけ処理されます。ホップ毎オプ
   ションと同じように、各宛先オプションヘッダーのオプションががタイプと
   長さと値のTLVでコードさます。

   Today no Destination options are defined for IPv6 [RFC-1883],
   although proposals exist to use Destination options with mobility and
   anycasting.
   今日[RFC-1883]で宛先オプションが提案されていませんが、移動とエニキャ
   ストで宛先オプションを使う提案がされています。

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

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

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

   All the Destination options appearing before a Routing header are
   returned as one ancillary data object described by a cmsghdr
   structure and all the Destination options appearing after a Routing
   header are returned as another ancillary data object described by a
   cmsghdr structure.  For these ancillary data objects, 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_option_next() and inet6_option_find() functions.
   ルーティングヘッダーの前に現われているすべての宛先オプションはcmsghdr
   構造体で記述されたひとつの補助的なデータオブジェクトとして返され、ルー
   ティングヘッダーの後に現われているすべての宛先オプションは他のcmsghdr
   構造体で記述された補助的なデータオブジェクトとして返されます。これら
   の補助的なデータオブジェクトで、cmsg_levelメンバーはIPPROTO_IPV6で、
   cmsg_type メンバーはIPV6_HOPOPTSであるでしょう。これらのオプションは
   inet6_option_next()とinet6_option_find()関数を呼ぶことで処理されます。

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

   To send one or more Destination options, the application just
   specifies them as ancillary data in a call to sendmsg().  No socket
   option need be set.
   宛先オプションを送るために、アプリケーションはsendmsg()の呼び出しでそ
   れらを補助的なデータとして明示します。ソケットオプションの設定は必要
   ありません。

   As described earlier, one set of Destination options can appear
   before a Routing header, and one set can appear after a Routing
   header.  Each set can consist of one or more options.
   以前に記述したように、宛先オプションの1つがルーティングヘッダーの前
   に現われることができ、1つがルーティングヘッダーの後に現われることが
   できます。それぞれが1つ以上のオプションから成り立ちます。

   Normally all the Destination options in a set are specified by a
   single ancillary data object, since each option is itself TLV-
   encoded.  Multiple ancillary data objects, each containing one or
   more Destination options, can also be specified, in which case the
   kernel will combine all the Destination options in the set into a
   single Destination extension header.  But it should be more efficient
   to use a single ancillary data object to describe all the Destination
   options in a set.  The cmsg_level member is set to IPPROTO_IPV6 and
   the cmsg_type member is set to IPV6_DSTOPTS.  The option is normally
   constructed using the inet6_option_init(), inet6_option_append(), and
   inet6_option_alloc() functions.
   それぞれのオプションがTLVでコードされていているので、通常すべての
   宛先オプションは1つの補助的なデータオブジェクトで指定されます。それ
   ぞれ1つ以上の宛先オプションを含む多数の補助的なデータオブジェクトを
   指定することもでき、この場合カーネルはひとつの宛先拡張ヘッダーの中に
   すべての宛先オプションを結合するでしょう。けれどもすべての宛先オプショ
   ンを記述するためにひとつの補助的なデータオブジェクトを使うことはより
   効率的です。cmsg_levelメンバーはIPPROTO_IPV6が設定され、cmsg_typeメン
   バーはIPV6_DSTOPTSが設定されます。オプションは通常inet6_option_init()
   とinet6_option_append()とinet6_option_alloc()関数を使って組み立てられ
   ます。

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

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

   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-1883].  This type supports up to 23 intermediate nodes.  With
   this maximum number of intermediate nodes, a source, and a
   destination, there are 24 hops, each of which is defined as a strict
   or loose hop.
   IPv6のソースルーティングはルーティングヘッダーを拡張ヘッダーと明
   示することで達成されます。異なったタイプのルーティングヘッダーがあり
   得ますが、IPv6は現在ただタイプ0ルーティングヘッダーだけを定義し
   ます[RFC-1883]。このタイプは最高23の中間ノードをサポートします。こ
   の中間ノードとソースと宛先で、最大24ホップあり、それぞれは厳密か、
   あいまいホップと定義されます。

   Source routing with 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 eight
   functions that the application calls to build and examine a Routing
   header.  Four functions build a Routing header:
   IPv4ソケットAPIのソースルーティング(IP_OPTIONSソケットオプショ
   ン)がアプリケーションにIPv4ヘッダオプションで現れるフォーマット
   でソースルートを作るように要求しし、IPv4オプションフォーマットの
   詳細な知識を必要とします。このIPv6のAPIは、アプリケーションが
   ルーティングヘッダーを構築し調べるために呼び出す8つの関数を定義しま
   す。4つの関数がルーティングヘッダーを生成します:

   inet6_rthdr_space()    - return #bytes required for ancillary data
                          - 補助的なデータのために必要なバイト数を返す
   inet6_rthdr_init()     - initialize ancillary data for Routing header
                          - ルーティングヘッダーの補助的なデータを初期化
   inet6_rthdr_add()      - add IPv6 address & flags to Routing header
                          - ルーティングヘッダーにIPv6アドレスとフラグを追加
   inet6_rthdr_lasthop()  - specify the flags for the final hop
                          - 最終ホップのフラグを指定

   Four functions deal with a returned Routing header:
   4つの関数が返されたルーティングヘッダを分けます:

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

   The function prototypes for these functions are all in the
   <netinet/in.h> header.
   これらの関数の関数プロトタイプはすべて<netinet/in.h>ヘッダにあります。

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

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

   To send a Routing header the application just specifies it as
   ancillary data in a call to sendmsg().
   ルーティングヘッダーを送るために、アプリケーションはsendmsg()への呼び
   出しでこれを補助的なデータとして明示します。

   A Routing header is passed between the application and the kernel as
   an ancillary data object.  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 eight functions that we are about to describe.
   ルーティングヘッダーが補助的なデータオブジェクトとしてアプリケーショ
   ンとカーネルの間で渡されます。cmsg_levelメンバーはIPPROTO_IPV6の価値
   を持ち、cmsg_typeメンバーはIPV6_RTHDRの値を持っています。cmsg_data[]
   メンバーの中身は実装依存で、直接アプリケーションからアクセスされるべ
   きではなく、我々が記述しようとしている8つの関数を使ってアクセスされ
   るべきです。

   The following constants are defined in the <netinet/in.h> header:
   次の定数は<netinet/in.h>ヘッダで定義されます:

    #define IPV6_RTHDR_LOOSE     0 /* this hop need not be a neighbor */
                                   /* このホップは隣人でなくても良い */
    #define IPV6_RTHDR_STRICT    1 /* this hop must be a neighbor */
                                   /* このホップは隣人でなければならない */
    #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()で
   指定された宛先アドレスはデータグラムの最終の宛先アドレスです。ルーティ
   ングヘッダーはすべての中間ノードのアドレスを含んでいます。

8.1.  inet6_rthdr_space
8.1.  inet6_rthdr_space

       size_t inet6_rthdr_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 1 and 23, inclusive.  The return value
   includes the size of the cmsghdr structure that precedes the Routing
   header, and any required padding.
   この関数は指定されたタイプで指定された数のセグメント(アドレス)のルー
   ティングヘッダーに必要なバイト数を返します。IPv6タイプ0ルーティ
   ングヘッダーで、セグメントの数は、1以上と23以下であるに違いありま
   せん。帰り値はルーティングヘッダの前のcmsghdr構造体の大きさと必要なパ
   ディングをを含みます。

   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()で指定されなければならないので、こ
   れはもし他の補助的なデータオブジェクトを望むアプリケーションにより大
   きいバッファの割り当てることを許します。)

8.2.  inet6_rthdr_init
8.2.  inet6_rthdr_init

       struct cmsghdr *inet6_rthdr_init(void *bp, int type);

   This function initializes the buffer pointed to by bp to contain a
   cmsghdr structure followed by a Routing header of the specified type.
   The cmsg_len member of the cmsghdr structure is initialized to the
   size of the structure plus the amount of space required by the
   Routing header.  The cmsg_level and cmsg_type members are also
   initialized as required.
   この関数は指定されたタイプのルーティングヘッダーが続くcmsghdr構造体を
   含めるためにbpでポイントされたバッファを初期化します。cmsghdr構造体の
   cmsg_lenメンバーは、構造体のサイズ足すルーティングヘッダーに必要な空
   間で初期化されます。cmsg_levelとcmsg_typeメンバーは、同じく必要なよう
   に初期化されます。

   The caller must allocate the buffer and its size can be determined by
   calling inet6_rthdr_space().
   呼び出し人はバッファを割り当てなければならず、これの大きさは
   inet6_rthdr_space()を呼ぶことで決定されます。

   Upon success the return value is the pointer to the cmsghdr
   structure, and this is then used as the first argument to the next
   two functions.  Upon an error the return value is NULL.
   成功した場合の返り値はcmsghdr構造体へのポインタで、これは次の2つの関
   数の最初の引数に使います。エラーの返り値はNULLです。

8.3.  inet6_rthdr_add
8.3.  inet6_rthdr_add

    int inet6_rthdr_add(struct cmsghdr *cmsg,
                        const struct in6_addr *addr, unsigned int flags);

   This function adds the address pointed to by addr to the end of the
   Routing header being constructed and sets the type of this hop to the
   value of flags.  For an IPv6 Type 0 Routing header, flags must be
   either IPV6_RTHDR_LOOSE or IPV6_RTHDR_STRICT.
   この関数はルーティングヘッダーの終わりにaddrでポイントされるアドレス
   を加えて、このホップのタイプをフラグの値に設定します。IPv6タイプ
   0ルーティングヘッダーで、フラグはIPV6_RTHDR_LOOSEかIPV6_RTHDR_STRICT
   であるに違いありません。

   If successful, the cmsg_len member of the cmsghdr structure 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.
   もし成功したらcmsghdr構造体のcmsg_lenメンバーはルーティングヘッダのア
   ドレスの合計を更新し、関数の返り値は0です。エラーの場合の関数の返り
   値は−1です。

8.4.  inet6_rthdr_lasthop
8.4.  inet6_rthdr_lasthop

       int inet6_rthdr_lasthop(struct cmsghdr *cmsg,
                               unsigned int flags);

   This function specifies the Strict/Loose flag for the final hop of a
   Routing header.  For an IPv6 Type 0 Routing header, flags must be
   either IPV6_RTHDR_LOOSE or IPV6_RTHDR_STRICT.
   この関数はルーティングヘッダーの最後のホップの厳格/あいまいフラグを
   指定します。IPv6タイプ0ルーティングヘッダーで、フラグは
   IPV6_RTHDR_LOOSEかIPV6_RTHDR_STRICTに違いありません。

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

   Notice that a Routing header specifying N intermediate nodes requires
   N+1 Strict/Loose flags.  This requires N calls to inet6_rthdr_add()
   followed by one call to inet6_rthdr_lasthop().
   N個の中間ノードを指定しているルーティングヘッダーがN+1個の厳密/
   あいまいフラグを必要とすることに注意iしてください。これはN回の
   inet6_rthdr_add()呼び出し後に1回のinet6_rthdr_lasthop()呼び出しがあ
   る事を要求します。

8.5.  inet6_rthdr_reverse
8.5.  inet6_rthdr_reverse

    int inet6_rthdr_reverse(const struct cmsghdr *in, struct cmsghdr *out);

   This function takes a Routing header that was received as ancillary
   data (pointed to by the first argument) and writes a new Routing
   header that sends datagrams along the reverse of that route.  Both
   arguments are allowed to point to the same buffer (that is, the
   reversal can occur in place).
   この関数は(最初の引数でポイントした)補助的なデータとして受信ルーティ
   ングヘッダーを取り出し、受信経路の反対にデータグラムを送る新しいルー
   ティングヘッダーを書きます。両方の引数が同じバッファをポイントする
   (すなわち、逆転は決まった場所で起こる)ことが許されます。

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

8.6.  inet6_rthdr_segments
8.6.  inet6_rthdr_segments

       int inet6_rthdr_segments(const struct cmsghdr *cmsg);

   This function returns the number of segments (addresses) contained in
   the Routing header described by cmsg.  On success the return value is
   between 1 and 23, inclusive.  The return value of the function is -1
   upon an error.
   この機能はcmsgで記述されたルーティングヘッダに含まれるセグメント(ア
   ドレス)の数を返します。成功の返り値は1以上23以下です。関数のエラー
   の返り値は-1です。

8.7.  inet6_rthdr_getaddr
8.7.  inet6_rthdr_getaddr

    struct in6_addr *inet6_rthdr_getaddr(struct cmsghdr *cmsg, int
    index);

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

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

8.8.  inet6_rthdr_getflags
8.8.  inet6_rthdr_getflags

       int inet6_rthdr_getflags(const struct cmsghdr *cmsg, int index);

   This function returns the flags value specified by index (which must
   have a value between 0 and the value returned by
   inet6_rthdr_segments()) in the Routing header described by cmsg.  For
   an IPv6 Type 0 Routing header the return value will be either
   IPV6_RTHDR_LOOSE or IPV6_RTHDR_STRICT.
   この関数はcmsgで記述されたルーティングヘッダーからでindexで指定された
   フラグの値を返します(indexは0からinet6_rthdr_segments()の返した値の
   間でなければならない)。IPv6タイプ0ルーティングヘッダーの帰りの
   値はIPV6_RTHDR_LOOSEかIPV6_RTHDR_STRICTであるでしょう。

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

   (Note: Addresses are indexed starting at 1, and flags starting at 0,
   to maintain consistency with the terminology and figures in [RFC-
   1883].)
   (ノート:[RFC- 1883]の用語と図にあわせるため、アドレスのインデックス
   が1から始まり、フラグが0から始まります。)。

8.9.  Routing Header Example
8.9.  Routing Header Example

   As an example of these Routing header functions, we go through the
   function calls for the example on p. 18 of [RFC-1883].  The source is
   S, the destination is D, and the three intermediate nodes are I1, I2,
   and I3.  f0, f1, f2, and f3 are the Strict/Loose flags for each hop.
   これらのルーティングヘッダー関数の例として、我々は[RFC-1883]のページ
   18の例のために関数呼出しを体験します。ソースはSです、宛先はDです、
   そして3つの中間ノードはI1とI2とI3です。f0とf1とf2とf3はそれぞれ
   のホップの厳密/あいまいフラグです。

                   f0        f1        f2        f3
               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

       check: f0        f1        f2        f3

   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.
   check indicates which bit of the Strict/Loose Bit Map (0 through 3,
   specified as f0 through f3) that node checks.
   srcとdstはIPv6ヘッダのソースとと宛先IPv6アドレスです。A[1]と
   A[2]とA[3]はルーティングヘッダの3つのアドレスです。#segはルーティン
   グヘッダーの残セグメントフィールドです。checkがそのノードが検査する
   ビットマップの厳密/あいまいビットを示します(0から3で、f0からf3を指
   定)。

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

       void  *ptr;
       struct msghdr  msg;
       struct cmsghdr  *cmsgptr;
       struct sockaddr_in6  I1, I2, I3, D;
       unsigned int  f0, f1, f2, f3;

       ptr = malloc(inet6_rthdr_space(IPV6_RTHDR_TYPE_0, 3));
       cmsgptr = inet6_rthdr_init(ptr, IPV6_RTHDR_TYPE_0);

       inet6_rthdr_add(cmsgptr, &I1.sin6_addr, f0);
       inet6_rthdr_add(cmsgptr, &I2.sin6_addr, f1);
       inet6_rthdr_add(cmsgptr, &I3.sin6_addr, f2);
       inet6_rthdr_lasthop(cmsgptr, f3);

       msg.msg_control = ptr;
       msg.msg_controllen = cmsgptr->cmsg_len;

       /* 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].  If f0 is IPV6_RTHDR_STRICT, then I1 must be a neighbor of S.
   5つのノードの間の4列の6つの値は、パケットが2つのノードの間で転送
   中の間のパケットのフィールド値です。パケットがソースノードSから送ら
   れる前に、ソースアドレスが選択されることに気付いてください(アスタリ
   スクが置き換わる取って代わっている)、I1がデータグラムの宛先アドレス
   で、2つのアドレスA[2]とA[3]が「シフトアップ」し、DはA[3]に移動します。
   もしf0がIPV6_RTHDR_STRICTなら、I1はSの近隣であるに違いありません。

   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_PKTINFO and IPV6_RTHDR 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) and four flags (f0, f1, f2, and f3).
   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_PKTINFO
   とIPV6_RTHDRソケットオプションの両方を使用可能にたと仮定した場合に、
   recvmsg()で返される値です。ソースアドレスは(msg_nameメンバーで指し示
   されるsockaddr_in6構造体に含まれる)Sです、宛先アドレスは(in6_pktinfo
   構造体で補助的なデータオブジェクトとして返された)Dで、ルーティング
   ヘッダと示される補助的なデータオブジェクトが3つのアドレス(I1とI2と
   I3)と4つのフラグ(f0とf1とf2とf3)を含んでいるでしょう。ルーティン
   グヘッダのセグメント数はルーティングヘッダのHdr Ext Lenフィールドか
   ら解かります(値6は3つのアドレスを示しています)。

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

   If the receiving application then calls inet6_rthdr_reverse(), the
   order of the three addresses will become I3, I2, and I1, and the
   order of the four Strict/Loose flags will become f3, f2, f1, and f0.
   もし受信アプリケーションがinet6_rthdr_reverse()を呼ぶなら、3つのア
   ドレスの順序はI3とI2とI1になるでしょう、そして4つの厳密/あいまい
   フラグの順序はf3、f2、f1、f0になるでしょう。

   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_rthdr_space(3) returns 68: 12 bytes for the
   cmsghdr structure and 56 bytes for the Routing header (8 + 3*16).
   ルーティングヘッダを送信プロセスによって作られている時に、補助的なデー
   タオブジェクトに何が登録されるか見ることができます。もし我々が4バイ
   ト境界整列でsizeof(struct cmsghdr)が12に等しい32ビット・アーキ
   テクチャを仮定するなら、inet6_rthdr_space(3)呼び出しは68を返します:
   cmsghdr構造体が12バイトでルーティングヘッダが56バイト(8+3×
   16)です。

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

     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = 20                                           |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_RTHDR                                  |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |  Next Header  | Hdr Ext Len=0 | Routing Type=0|  Seg Left=0   |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |   Reserved    |             Strict/Loose Bit Map              |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

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

     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = 36                                           |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_RTHDR                                  |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |  Next Header  | Hdr Ext Len=2 | Routing Type=0|  Seg Left=1   |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |   Reserved    |X|           Strict/Loose Bit Map              |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                                                               +
     |                                                               |
     +                           Address[1] = I1                     +
     |                                                               |
     +                                                               +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   Bit 0 of the Strict/Loose Bit Map contains the value f0, which we
   just mark as X.  cmsg_len is incremented by 16, the Hdr Ext Len field
   is incremented by 2, and the Segments Left field is incremented by 1.
   厳密/あいまいビットマップのビット0が値f0を含み、それをXとマークしま
   す。cmsg_lenは16増加し、Hdr Ext Lenフィールドは2増加し、残りのセグ
   メントフィールドは1増加します。

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

     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_len = 52                                           |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_level = IPPROTO_IPV6                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |       cmsg_type = IPV6_RTHDR                                  |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |  Next Header  | Hdr Ext Len=4 | Routing Type=0|  Seg Left=2   |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |   Reserved    |X|X|         Strict/Loose Bit Map              |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                                                               +
     |                                                               |
     +                           Address[1] = I1                     +
     |                                                               |
     +                                                               +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                                                               +
     |                                                               |
     +                           Address[2] = I2                     +
     |                                                               |
     +                                                               +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   The next bit of the Strict/Loose Bit Map contains the value f1.
   cmsg_len is incremented by 16, the Hdr Ext Len field is incremented
   by 2, and the Segments Left field is incremented by 1.
   厳密/あいまいビットマップの次のビットは値f1を含んでいます。
   cmsg_lenは16増加し、Hdr Ext Lenフィールドは2増加し、残りのセグメ
   ントフィールドは1増加します。

   The last call to inet6_rthdr_add() adds I3 to the list.
   inet6_rthdr_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    |X|X|X|       Strict/Loose Bit Map              |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                                                               +
     |                                                               |
     +                           Address[1] = I1                     +
     |                                                               |
     +                                                               +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                                                               +
     |                                                               |
     +                           Address[2] = I2                     +
     |                                                               |
     +                                                               +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                                                               |
     +                                                               +
     |                                                               |
     +                           Address[3] = I3                     +
     |                                                               |
     +                                                               +
     |                                                               |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   The next bit of the Strict/Loose Bit Map contains the value f2.
   cmsg_len is incremented by 16, the Hdr Ext Len field is incremented
   by 2, and the Segments Left field is incremented by 1.
   厳密/あいまいビットマップの次のビットは値f2を含んでいます。
   cmsg_lenは16増加し、Hdr Ext Lenフィールドは2増加し、残セグメント
   フィールドは1増加します。

   Finally, the call to inet6_rthdr_lasthop() sets the next bit of the
   Strict/Loose Bit Map to the value specified by f3.  All the lengths
   remain unchanged.
   最終的に、inet6_rthdr_lasthop()呼び出しは厳密/あいまいビットマップ
   の次のビットをf3で指定した値に設定します。すべての長さは変化しません。

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

   Three IPv6 extension headers can be specified by the application and
   returned to the application using ancillary data with sendmsg() and
   recvmsg(): Hop-by-Hop options, Destination options, and the Routing
   header.  When multiple ancillary data objects are transferred via
   sendmsg() or 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.  This API
   imposes some ordering constraints when using multiple ancillary data
   objects with sendmsg().
   sendmsg()とrecvmsg()で補助的なデータを使って、3つのIPv6拡張子ヘッ
   ダーがアプリケーションによって指定でき、アプリケーションに返されます:
   ホップ毎オプションと、宛先オプションと、ルーティングヘッダー。多数の
   補助的なデータオブジェクトがsendmsg()やrecvmsg()で転送され、これらの
   オブジェクトがこれらの3つの拡張子ヘッダのどれかを表す時、それらの制
   御バッファでの配置は対応するIPv6データグラムの場所に直接結び付け
   られます。このAPIはsendmsg()で多数の補助的なデータオブジェクトを
   使う時の順序の制約を課します。

   When multiple IPv6 Hop-by-Hop options having the same option type are
   specified, these options will be inserted into the Hop-by-Hop options
   header in the same order as they appear in the control buffer.  But
   when multiple Hop-by-Hop options having different option types are
   specified, these options may be reordered by the kernel to reduce
   padding in the Hop-by-Hop options header.  Hop-by-Hop options may
   appear anywhere in the control buffer and will always be collected by
   the kernel and placed into a single Hop-by-Hop options header that
   immediately follows the IPv6 header.
   同じオプションタイプを持つ多数のIPv6ホップ毎オプションが指定され
   る時、これらのオプションはそれらが制御バッファに現われるのと同じ順序
   でホップ毎オプションヘッダーに挿入されるでしょう。けれども異なったオ
   プションタイプを持つ多数のホップ毎オプションが指定される時、これらの
   オプションはホップ毎オプションヘッダーの隙間を詰めるためカーネルが順
   序を変えるかもしれません。ホップ毎オプションは制御バッファの任意の場
   所に現われ、常にカーネルによって集められ、IPv6ヘッダーの直後に続
   く1つのホップ毎オプションヘッダーに置かれるでしょう。

   Similar rules apply to the Destination options: (1) those of the same
   type will appear in the same order as they are specified, and (2)
   those of differing types may be reordered.  But the kernel will build
   up to two Destination options headers: one to precede the Routing
   header and one to follow the Routing header.  If the application
   specifies a Routing header then all Destination options that appear
   in the control buffer before the Routing header will appear in a
   Destination options header before the Routing header and these
   options might be reordered, subject to the two rules that we just
   stated.  Similarly all Destination options that appear in the control
   buffer after the Routing header will appear in a Destination options
   header after the Routing header, and these options might be
   reordered, subject to the two rules that we just stated.
   類似の規則が宛先オプションに当てはまります:(1)同じタイプのオプショ
   ンは指定された順に現れ、(2)異なるタイプのオプションは順序が変るか
   もしれません。しかしカーネルは2つの宛先オプションヘッダーを作るでしょ
   う:1つはルーティングヘッダの前にあり、1つはルーティングヘッダーの
   後に続きます。もしアプリケーションがルーティングヘッダーを指定するな
   ら、制御バッファでルーティングヘッダーの前のに現われるすべての宛先オ
   プションは、ルーティングヘッダの前に現れ、上記の2つの規則の適用を受
   け、順序を入れ替えるかもしれません。制御装置バッファ上でルーティング
   ヘッダーの後にに現われるすべての宛先オプションはルーティングヘッダー
   の後に宛先オプションヘッダーに現われ、これらのオプションは上記2つの
   規則の適用を受け、順序が変るかもしれません。

   As an example, assume that an application specifies control
   information to sendmsg() containing six ancillary data objects: the
   first containing two Hop-by-Hop options, the second containing one
   Destination option, the third containing two Destination options, the
   fourth containing a Routing header, the fifth containing a Hop-by-Hop
   option, and the sixth containing two Destination options.  We also
   assume that all the Hop-by-Hop options are of different types, as are
   all the Destination options.  We number these options 1-9,
   corresponding to their order in the control buffer, and show them on
   the left below.
   例えば、アプリケーションが6つの補助的なデータオブジェクトを含んでい
   る制御情報をsendmsg()で指定すると想定してください:最初は2つのホップ
   毎オプション、2番目はは宛先オプション、3番目は2つの宛先オプション、
   4番目はルーティングヘッダ、5番目はホップ毎オプション、6番目は2つ
   の宛先オプション。すべてのホップ毎オプションが異なったタイプで、すべ
   ての宛先オプションも異なるタイプと想定します。制御バッファの順で1か
   ら9の番号を付け、これを左側に示します。

   In the middle we show the final arrangement of the options in the
   extension headers built by the kernel.  On the right we show the four
   ancillary data objects returned to the receiving application.
   真ん中にカーネルが作る拡張ヘッダーオプションの最終の割当を示します。
   右側にアプリケーションに戻った4つの補助的なデータオブジェクトを示し
   ます。

          Sender's                                       Receiver's
       Ancillary Data      -->   IPv6 Extension   -->  Ancillary Data
          Objects                    Headers              Objects
          送信側の                                        受信側の
      補助的なデータ      -->     IPv6拡張    -->  補助的なデータ
       オブジェクト                  ヘッダ             オブジェクト
       ------------------        ---------------       --------------
       HOPOPT-1,2 (first)        HOPHDR(J,7,1,2)       HOPOPT-7,1,2
       DSTOPT-3                  DSTHDR(4,5,3)         DSTOPT-4,5,3
       DSTOPT-4,5                RTHDR(6)              RTHDR-6
       RTHDR-6                   DSTHDR(8,9)           DSTOPT-8,9
       HOPOPT-7
       DSTOPT-8,9 (last)

   The sender's two Hop-by-Hop ancillary data objects are reordered, as
   are the first two Destination ancillary data objects.  We also show a
   Jumbo Payload option (denoted as J) inserted by the kernel before the
   sender's three Hop-by-Hop options.  The first three Destination
   options must appear in a Destination header before the Routing
   header, and the final two Destination options must appear in a
   Destination header after the Routing header.
   送信側の2つのホップ毎補助的なデータオブジェクトの順序が変えられ、最
   初の2つの宛先補助的なデータオブジェクも同じです。同じく巨大ペイロー
   ドオプションが(Jで示す)が送信側の3つのホップ毎オプションの前にカー
   ネルによって挿入されています。最初の3つの宛先オプションは宛先ヘッダー
   に現われ、最後の2つの宛先オプションがルーティングヘッダーの後の宛先
   ヘッダーに現われなくてはなりません。

   If Destination options are specified in the control buffer after a
   Routing header, or if Destination options are specified without a
   Routing header, the kernel will place those Destination options after
   an authentication header and/or an encapsulating security payload
   header, if present.
   もし宛先オプションがルーティングヘッダーの後に制御バッファで指定され
   るなら、あるいはもし宛先オプションがルーティングヘッダー無しで指定さ
   れるなら、カーネルは宛先オプションを、もしあれば、認証ヘッダーやカプ
   セル化セキュリティペイロードヘッダーの後に宛先オプションを置くでしょ
   う。

10.  IPv6-Specific Options with IPv4-Mapped IPv6 Addresses
10.  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マップIPv6
   アドレスを使って、実際には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.
   一般に、IPv4マップIPv6アドレスを使っているIPv6ソケットに、
   ホップ毎オプションや宛先オプションやルーティングヘッダーのようなIP
   v6だけのオプションの指定しようと試みると、恐らくエラーをもたらすで
   しょう。しかしかなら、ある実装がIPv4マップIPv6アドレスを使っ
   ているIPv6ソケットでパケット情報(ソース/宛先アドレスや送信/受
   信インタフェースやホップ限界)にアクセスを供給するかもしれません。

11.  rresvport_af
11.  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 IPv4/TCP socket, it can also create an
   IPv6/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()関数と同じように振る舞いますが、IPv4
   /TCPソケットを作る代わりに、IPv6/TCPソケットを作ることが
   できます。ファミリー引数は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>で定義し、他はまったく関数のプロトタイプを定義しません。)

   (Note: We define this function only, and do not define something like
   rcmd_af() or rcmd6().  The reason is that rcmd() calls
   gethostbyname(), which returns the type of address: AF_INET or
   AF_INET6.  It should therefore be possible to modify rcmd() to
   support either IPv4 or IPv6, based on the address family returned by
   gethostbyname().)
   (ノート:我々はこの関数のみを定義し、rcmd_af()やrcmd6()のようなもの
   を定義しません。理由はrcmd()がgethostbyname()を呼び出し、これがアド
   レスタイプを返すからです:AF_INETかAF_INET6。gethostbyname()から返さ
   れたアドレスファミリーに基づいて、IPv4かIPv6をサポートするよ
   うにrcmd()を修正することは従って可能であるべきです。)

12.  Future Items
12.  未来の項目

   Some additional items may require standardization, but no concrete
   proposals have been made for the API to perform these tasks.  These
   may be addressed in a later document.
   いくつかの追加の項目が標準化を必要とするかもしれませんが、APIがこ
   れらの仕事を行うための具体的な提案がされていませんでした。これらは後
   の文書で扱われるかもしれません。

12.1.  Flow Labels
12.1.  フローラベル

   Earlier revisions of this document specified a set of
   inet6_flow_XXX() functions to assign, share, and free IPv6 flow
   labels.  Consensus, however, indicated that it was premature to
   specify this part of the API.
   この文書の以前のバージョンがIPv6フローラベルの割当と共有と開放の
   ためにinet6_flow_XXX()関数を指定しました。しかしながら、APIがこの
   部分を指定するのは時期尚早との合意がありました。

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

   A standard method may be desirable for a UDP application to determine
   the "maximum send transport-message size" (Section 5.1 of [RFC-1981])
   to a given destination.  This would let the UDP application send
   smaller datagrams to the destination, avoiding fragmentation.
   UDPアプリケーションがある宛先への「最大送信メッセージサイズ」
   ([RFC-1981]の5.1章)を決定する標準方法が望ましいかもしれません。
   これでUDPアプリケーションが分割を避けて目的地により小さいデータグ
   ラムを送るでしょう。

12.3.  Neighbor Reachability and UDP
12.3.  近隣到達可能性とUDP

   A standard method may be desirable for a UDP application to tell the
   kernel that it is making forward progress with a given peer (Section
   7.3.1 of [RFC-1970]).  This could save unneeded neighbor
   solicitations and neighbor advertisements.
   UDPアプリケーションが特定の相手に送信可能かカーネルに問い合わせる
   標準方法が望ましいかもしれません([RFC-1970]7.3.1章)。これは必要
   でない近隣要請と近隣広告を減らせます。

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

   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_NOPORT
     <netinet/icmp6.h> ICMP6_DST_UNREACH_NOROUTE
     <netinet/icmp6.h> ICMP6_DST_UNREACH_NOTNEIGHBOR
     <netinet/icmp6.h> ICMP6_ECHO_REPLY
     <netinet/icmp6.h> ICMP6_ECHO_REQUEST
     <netinet/icmp6.h> ICMP6_INFOMSG_MASK
     <netinet/icmp6.h> ICMP6_MEMBERSHIP_QUERY
     <netinet/icmp6.h> ICMP6_MEMBERSHIP_REDUCTION
     <netinet/icmp6.h> ICMP6_MEMBERSHIP_REPORT
     <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_TIME_EXCEEDED
     <netinet/icmp6.h> ICMP6_TIME_EXCEED_REASSEMBLY
     <netinet/icmp6.h> ICMP6_TIME_EXCEED_TRANSIT
     <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 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/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_DSTOPTS
     <netinet/in.h>    IPV6_HOPLIMIT
     <netinet/in.h>    IPV6_HOPOPTS
     <netinet/in.h>    IPV6_NEXTHOP
     <netinet/in.h>    IPV6_PKTINFO
     <netinet/in.h>    IPV6_PKTOPTIONS
     <netinet/in.h>    IPV6_RTHDR
     <netinet/in.h>    IPV6_RTHDR_LOOSE
     <netinet/in.h>    IPV6_RTHDR_STRICT
     <netinet/in.h>    IPV6_RTHDR_TYPE_0
     <netinet/in.h>    struct in6_pktinfo{};

     <netinet/ip6.h>   IP6F_OFF_MASK
     <netinet/ip6.h>   IP6F_RESERVED_MASK
     <netinet/ip6.h>   IP6F_MORE_FRAG
     <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_rthdr{};
     <netinet/ip6.h>   struct ip6_rthdr0{};

     <sys/socket.h>    struct cmsghdr{};
     <sys/socket.h>    struct msghdr{};

   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>    uint8_t *inet6_option_alloc(struct cmsghdr *,
                                               int, int, int);
<netinet/in.h>    int inet6_option_append(struct cmsghdr *,
                                          const uint8_t *, int, int);
<netinet/in.h>    int inet6_option_find(const struct cmsghdr *,
                                        uint8_t *, int);
<netinet/in.h>    int inet6_option_init(void *, struct cmsghdr **, int);
<netinet/in.h>    int inet6_option_next(const struct cmsghdr *,
                                        uint8_t **);
<netinet/in.h>    int inet6_option_space(int);

<netinet/in.h>    int inet6_rthdr_add(struct cmsghdr *,
                                      const struct in6_addr *,
                                      unsigned int);
<netinet/in.h>    struct in6_addr inet6_rthdr_getaddr(struct cmsghdr *,
                                                      int);
<netinet/in.h>    int inet6_rthdr_getflags(const struct cmsghdr *, int);
<netinet/in.h>    struct cmsghdr *inet6_rthdr_init(void *, int);
<netinet/in.h>    int inet6_rthdr_lasthop(struct cmsghdr *,
                                                          unsigned int);
<netinet/in.h>    int inet6_rthdr_reverse(const struct cmsghdr *,
                                          struct cmsghdr *);
<netinet/in.h>    int inet6_rthdr_segments(const struct cmsghdr *);
<netinet/in.h>    size_t inet6_rthdr_space(int, int);

<sys/socket.h>    unsigned char *CMSG_DATA(const struct cmsghdr *);
<sys/socket.h>    struct cmsghdr *CMSG_FIRSTHDR(const struct msghdr *);
<sys/socket.h>    unsigned int CMSG_LEN(unsigned int);
<sys/socket.h>    struct cmsghdr *CMSG_NXTHDR(const struct msghdr *mhdr,
                                              const struct cmsghdr *);
<sys/socket.h>    unsigned int CMSG_SPACE(unsigned int);

<unistd.h>        int rresvport_af(int *, int);

14.  Security Considerations
14.  セキュリティの考察

   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 nonprivileged
   applications.
   ある特定のホップ毎オプションと宛先オプションの設定は特権を与えられた
   プロセスに制限されるかもしれません。同様にあるホップ毎オプションと宛
   先オプションを非特権アプリケーションに返さないかもしれません。

15.  Change History
15.  変更履歴

   Changes from the June 1997 Edition (-03 draft)
   1997年6月の版(03ドラフト)からの変更

    -  Added a note that defined constants for multibyte fields are in
       network byte order.  This affects the ip6f_offlg member of the
       Fragment header (Section 2.1.2) and the nd_na_flags_reserved
       member of the nd_neighbor_advert structure (Section 2.2.2).

    -  Section 5: the ipi6_ifindex member of the in6_pktinfo structure
       should be "unsigned int" instead of "int", for consistency with
       the interface indexes in [RFC-2133].

    -  Section 6.3.7: the three calls to inet6_option_space() in the
       examples needed to be arguments to malloc().  The final one of
       these was missing the "6" in the name "inet6_option_space".

    -  Section 8.6: the function prototype for inet6_rthdr_segments()
       was missing the ending semicolon.

   Changes from the March 1997 Edition (-02 draft)
   1997年3月の版(02ドラフト)からの変更

    -  In May 1997 Draft 6.6 of Posix 1003.1g (called Posix.1g herein)
       passed ballot and will be forwarded to the IEEE Standards Board
       later in 1997 for final approval.  Some changes made for this
       final Posix draft are incorporated into this Internet Draft,
       specifically the datatypes mentioned in Section 1 (and used
       throughout the text), and the socklen_t datatype used in Section
       4.1 and 4.2.

    -  Section 1: Added the intN_t signed datatypes, changed the
       datatype u_intN_t to uintN_t (no underscore after the "u"), and
       removed the datatype u_intNm_t, as per Draft 6.6 of Posix.1g.

    -  Name space issues for structure and constant names in Section 2:
       Many of the structure member names and constant names were
       changed so that the prefixes are the same.  The following
       prefixes are used for structure members: "ip6_", "icmp6_", and
       "nd_".  All constants have the prefixes "ICMP6_" and "ND_".

    -  New definitions: Section 2.1.2: contains definitions for the IPv6
       extension headers, other than AH and ESP.  Section 2.2.2:
       contains additional structures and constants for the neighbor
       discovery option header and redirected header.

    -  Section 2.2.2: the enum for the neighbor discovery option field
       was changed to be a set of #define constants.

    -  Changed the word "function" to "macro" for references to all the
       uppercase names in Sections 2.3 (IN6_ARE_ADDR_EQUAL), 3.2
       (ICMPV6_FILTER_xxx), and 4.3 (CMSG_xxx).

    -  Added more protocols to the /etc/protocols file (Section 2.4) and
       changed the name of "icmpv6" to "ipv6-icmp".

    -  Section 3: Made it more explicit that an application cannot read
       or write entire IPv6 packets, that all extension headers are
       passed as ancillary data.  Added a sentence that the kernel
       fragments packets written to an IPv6 raw socket when necessary.
       Added a note that IPPROTO_RAW raw IPv6 sockets are not special.

    -  Section 3.1: Explicitly stated that the checksum option applies
       to both outgoing packets and received packets.

    -  Section 3.2: Changed the array name within the icmp6_filter
       structure from "data" to "icmp6_filt".  Changes the prefix for
       the filter macros from "ICMPV6_" to "ICMP6_", for consistency
       with the names in Section 2.2.  Changed the example from a ping
       program to a program that wants to receive only router
       advertisements.

    -  Section 4.1: Changed msg_namelen and msg_controllen from size_t
       to the Posix.1g socklen_t datatype.  Updated the Note that
       follows.

    -  Section 4.2: Changed cmsg_len from size_t to the Posix.1g
       socklen_t datatype.  Updated the Note that follows.

    -  Section 4.4: Added a Note that the second and third arguments to
       getsockopt() and setsockopt() are intentionally the same as the
       cmsg_level and cmsg_type members.

    -  Section 4.5: Reorganized the section into a description of the
       option, followed by the TCP semantics, and the UDP and raw socket
       semantics.  Added a sentence on how to clear all the sticky
       options.  Added a note that TCP need not save the options from
       the most recently received segment until the application says to
       do so.  Added the statement that ancillary data is never passed
       with sendmsg() or recvmsg() on a TCP socket.  Simplified the
       interaction of the sticky options with ancillary data for UDP or
       raw IP: none of the sticky options are sent if ancillary data is
       specified.

    -  Final paragraph of Section 5.1: ipi6_index should be
       ipi6_ifindex.

    -  Section 5.4: Added a note on the term "privileged".

    -  Section 5.5: Noted that the errors listed are examples, and the
       actual errors depend on the implementation.

    -  Removed Section 6 ("Flow Labels") as the consensus is that it is
       premature to try and specify an API for this feature.  Access to
       the flow label field in the IPv6 header is still provided through
       the sin6_flowinfo member of the IPv6 socket address structure in
       [RFC-2133].  Added a subsection to Section 13 that this is a
       future item.

       All remaining changes are identified by their section number in
       the previous draft.  With the removal of Section 6, the section
       numbers are decremented by one.

    -  Section 7.3.7: the calls to malloc() in all three examples should
       be calls to inet6_option_space() instead.  The two calls to
       inet6_option_append() in the third example should be calls to
       inet6_option_alloc().  The two calls to CMSG_SPACE() in the first
       and third examples should be calls to CMSG_LEN().  The second
       call to CMSG_SPACE() in the second example should be a call to
       CMSG_LEN().

    -  Section 7.3.7: All the opt_X_ and opt_Y_ structure member names
       were changed to be ip6_X_opt_ and ip6_Y_opt_.  The two structure
       names ipv6_opt_X and ipv6_opt_Y were changed to ip6_X_opt and
       ip6_Y_opt.  The constants beginning with IPV6_OPT_X_ and
       IPV6_OPT_Y_ were changed to begin with IP6_X_OPT_ and IP6_Y_OPT_.

    -  Use the term "Routing header" throughout the draft, instead of
       "source routing".  Changed the names of the eight
       inet6_srcrt_XXX() functions in Section 9 to inet6_rthdr_XXX().
       Changed the name of the socket option from IPV6_SRCRT to
       IPV6_RTHDR, and the names of the three IPV6_SRCRT_xxx constants
       in Section 9 to IPV6_RTHDR_xxx.

    -  Added a paragraph to Section 9 on how to receive and send a
       Routing header.

    -  Changed inet6_rthdr_add() and inet6_rthdr_reverse() so that they
       return -1 upon an error, instead of an Exxx errno value.

    -  In the description of inet6_rthdr_space() in Section 9.1, added
       the qualifier "For an IPv6 Type 0 Routing header" to the
       restriction of between 1 and 23 segments.

    -  Refer to final function argument in Sections 9.7 and 9.8 as
       index, not offset.

    -  Updated Section 14 with new names from Section 2.

    -  Changed the References from "[n]" to "[RFC-abcd]".

   Changes from the February 1997 Edition (-01 draft)
   1997年2月の版(01ドラフト)からの変更

    -  Changed the name of the ip6hdr structure to ip6_hdr (Section 2.1)
       for consistency with the icmp6hdr structure.  Also changed the
       name of the ip6hdrctl structure contained within the ip6_hdr
       structure to ip6_hdrctl (Section 2.1).  Finally, changed the name
       of the icmp6hdr structure to icmp6_hdr (Section 2.2).  All other
       occurrences of this structure name, within the Neighbor Discovery
       structures in Section 2.2.1, already contained the underscore.

    -  The "struct nd_router_solicit" and "struct nd_router_advert"
       should both begin with "nd6_". (Section 2.2.2).

    -  Changed the name of in6_are_addr_equal to IN6_ARE_ADDR_EQUAL
       (Section 2.3) for consistency with basic API address testing
       functions.  The header defining this macro is <netinet/in.h>.

    -  getprotobyname("ipv6") now returns 41, not 0 (Section 2.4).

    -  The first occurrence of "struct icmpv6_filter" in Section 3.2
       should be "struct icmp6_filter".

    -  Changed the name of the CMSG_LENGTH() macro to CMSG_LEN()
       (Section 4.3.5), since LEN is used throughout the <netinet/*.h>
       headers.

    -  Corrected the argument name for the sample implementations of the
       CMSG_SPACE() and CMSG_LEN() macros to be "length" (Sections 4.3.4
       and 4.3.5).

    -  Corrected the socket option mentioned in Section 5.1 to specify
       the interface for multicasting from IPV6_ADD_MEMBERSHIP to
       IPV6_MULTICAST_IF.

    -  There were numerous errors in the previous draft that specified
       <netinet/ip6.h> that should have been <netinet/in.h>.  These have
       all been corrected and the locations of all definitions is now
       summarized in the new Section 14 ("Summary of New Definitions").

    Changes from the October 1996 Edition (-00 draft)
   1996年10月の版(00ドラフト)からの変更

    -  Numerous rationale added using the format (Note: ...).

    -  Added note that not all errors may be defined.

    -  Added note about ICMPv4, IGMPv4, and ARPv4 terminology.

    -  Changed the name of <netinet/ip6_icmp.h> to <netinet/icmp6.h>.

    -  Changed some names in Section 2.2.1: ICMPV6_PKT_TOOBIG to
       ICMPV6_PACKET_TOOBIG, ICMPV6_TIME_EXCEED to ICMPV6_TIME_EXCEEDED,
       ICMPV6_ECHORQST to ICMPV6_ECHOREQUEST, ICMPV6_ECHORPLY to
       ICMPV6_ECHOREPLY, ICMPV6_PARAMPROB_HDR to
       ICMPV6_PARAMPROB_HEADER, ICMPV6_PARAMPROB_NXT_HDR to
       ICMPV6_PARAMPROB_NEXTHEADER, and ICMPV6_PARAMPROB_OPTS to
       ICMPV6_PARAMPROB_OPTION.

    -  Prepend the prefix "icmp6_" to the three members of the
       icmp6_dataun union of the icmp6hdr structure (Section 2.2).

    -  Moved the neighbor discovery definitions into the
       <netinet/icmp6.h> header, instead of being in their own header
       (Section 2.2.1).

    -  Changed Section 2.3 ("Address Testing").  The basic macros are
       now in the basic API.

    -  Added the new Section 2.4 on "Protocols File".

    -  Added note to raw sockets description that something like BPF or
       DLPI must be used to read or write entire IPv6 packets.

    -  Corrected example of IPV6_CHECKSUM socket option (Section 3.1).
       Also defined value of -1 to disable.

    -  Noted that <netinet/icmp6.h> defines all the ICMPv6 filtering
       constants, macros, and structures (Section 3.2).

    -  Added note on magic number 10240 for amount of ancillary data
       (Section 4.1).

    -  Added possible padding to picture of ancillary data (Section
       4.2).

    -  Defined <sys/socket.h> header for CMSG_xxx() functions (Section
       4.2).

    -  Note that the data returned by getsockopt(IPV6_PKTOPTIONS) for a
       TCP socket is just from the optional headers, if present, of the
       most recently received segment.  Also note that control
       information is never returned by recvmsg() for a TCP socket.

    -  Changed header for struct in6_pktinfo from <netinet.in.h> to
       <netinet/ip6.h> (Section 5).

    -  Removed the old Sections 5.1 and 5.2, because the interface
       identification functions went into the basic API.

    -  Redid Section 5 to support the hop limit field.

    -  New Section 5.4 ("Next Hop Address").

    -  New Section 6 ("Flow Labels").

    -  Changed all of Sections 7 and 8 dealing with Hop-by-Hop and
       Destination options.  We now define a set of inet6_option_XXX()
       functions.

    -  Changed header for IPV6_SRCRT_xxx constants from <netinet.in.h>
       to <netinet/ip6.h> (Section 9).

    -  Add inet6_rthdr_lasthop() function, and fix errors in description
       of Routing header (Section 9).

    -  Reworded some of the Routing header descriptions to conform to
       the terminology in [RFC-1883].

    -  Added the example from [RFC-1883] for the Routing header (Section
       9.9).

    -  Expanded the example in Section 10 to show multiple options per
       ancillary data object, and to show the receiver's ancillary data
       objects.

    -  New Section 11 ("IPv6-Specific Options with IPv4-Mapped IPv6
       Addresses").

    -  New Section 12 ("rresvport_af").

    -  Redid old Section 10 ("Additional Items") into new Section 13
       ("Future Items").

16.  References
16.  参考文献

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

   [RFC-2133]  Gilligan, R., Thomson, S., Bound, J., and W. Stevens,
               "Basic Socket Interface Extensions for IPv6", RFC 2133,
               April 1997.

   [RFC-1981]  McCann, J., Deering, S., and J. Mogul, "Path MTU
   Discovery

               for IP version 6", RFC 1981, August 1996.

   [RFC-1970]  Narten, T., Nordmark, E., and W. Simpson, "Neighbor
               Discovery for IP Version 6 (IPv6)", RFC 1970, August
               1996.

17.  Acknowledgments
17.  謝辞

   Matt Thomas and Jim Bound have been working on the technical details
   in this draft 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.
   Matt ThomasとJim Boundは1以上年の間このドラフトの技術的細部に取り組
   みました。Keith SklowerはBSDネットワーキングコードで補助的なデータ
   のオリジナルの実装者です。Craig Metzは文書に書かれたこれらの特徴の多
   くの実装に基づいて行なわれたたくさんのフィードバックと示唆とコメント
   を供給しました。

   The following provided comments on earlier drafts: Pascal Anelli,
   Hamid Asayesh, Ran Atkinson, Karl Auerbach, Hamid Asayesh, Matt
   Crawford, Sam T. Denton, Richard Draves, Francis Dupont, Bob
   Gilligan, Tim Hartrick, Masaki Hirabaru, Yoshinobu Inoue, Mukesh
   Kacker, A. N. Kuznetsov, Pedro Marques, Jack McCann, der Mouse, John
   Moy, Thomas Narten, Erik Nordmark, Steve Parker, Charles Perkins, Tom
   Pusateri, Pedro Roque, Sameer Shah, Peter Sjodin, Stephen P.
   Spackman, Jinmei Tatuya, Karen Tracey, Quaizar Vohra, Carl Williams,
   Steve Wise, and Kazu Yamamoto.
   次の方が以前のドラフトにコメントを供給しました: Pascal Anelli,
   Hamid AsayeshとRan AtkinsonとKarl AuerbachとHamid AsayeshとMatt
   CrawfordとSam T. DentonとRichard DravesとFrancis DupontとBob
   GilliganとTim HartrickとMasaki HirabaruとYoshinobu InoueとMukesh
   KackerとA. N. KuznetsovとPedro MarquesとJack McCannとder MouseとJohn
   MoyとThomas NartenとErik NordmarkとSteve ParkerとCharles PerkinsとTom
   PusateriとPedro RoqueとSameer ShahとPeter SjodinとStephen P.
   SpackmanとJinmei TatuyaとKaren TraceyとQuaizar VohraとCarl Williamsと
   Steve WiseとKazu Yamamoto.

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

   W. Richard Stevens
   1202 E. Paseo del Zorro
   Tucson, AZ  85718

   EMail: rstevens@kohala.com


   Matt Thomas
   AltaVista Internet Software
   LJO2-1/J8
   30 Porter Rd
   Littleton, MA  01460
   EMail: matt.thomas@altavista-software.com



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

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

   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.
   この文書とここに含む情報は無保証で供給され、そしてインターネット学会
   とインターネット技術標準化タスクフォースは、特別にも暗黙にも、この情
   報の利用が権利を侵害しないことや商業利用や特別の目的への利用に適当で
   ある事の保障を含め、すべての保証を拒否します。

Japanese translation by Ishida So