net

package
v1.23.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 14, 2024 License: MIT Imports: 10 Imported by: 0

Documentation

Overview

netパッケージは、TCP/IP、UDP、ドメイン名の解決、およびUnixドメインソケットなど、ネットワークI/Oのためのポータブルなインターフェースを提供します。

このパッケージは、低レベルのネットワーキングプリミティブへのアクセスを提供していますが、ほとんどのクライアントは、Dial、Listen、Accept関数と関連する Conn と Listener インターフェースが提供する基本的なインターフェースだけを必要とします。crypto/tlsパッケージは、同じインターフェースと似たようなDialとListen関数を使用します。

Dial関数はサーバーに接続します： 

conn, err := net.Dial("tcp", "golang.org:80")
if err != nil {
	// エラーを処理する
}
fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
status, err := bufio.NewReader(conn).ReadString('\n')
// ...

Listen関数はサーバーを作成します： 

ln, err := net.Listen("tcp", ":8080")
if err != nil {
	// エラーを処理する
}
for {
	conn, err := ln.Accept()
	if err != nil {
		// エラーを処理する
	}
	go handleConnection(conn)
}

ネーム解決

ネーム解決の方法は、間接的にDialのような関数を使うか、LookupHost や LookupAddr のような関数を直接使うかによって、オペレーティングシステムによって異なります。

Unixシステムでは、名前を解決するための2つのオプションがあります。 /etc/resolv.confにリストされているサーバーに直接DNSリクエストを送信する純粋なGoリゾルバを使用するか、 getaddrinfoやgetnameinfoなどのCライブラリのルーチンを呼び出すcgoベースのリゾルバを使用するか、です。

Unixでは、ブロックされたDNSリクエストがゴルーチンだけを消費するため、 純粋なGoリゾルバがcgoリゾルバよりも優先されます。一方、ブロックされたC呼び出しは オペレーティングシステムのスレッドを消費します。 cgoが利用可能な場合、さまざまな条件下でcgoベースのリゾルバが代わりに使用されます： プログラムが直接DNSリクエストを行うことを許可しないシステム（OS X）上、 LOCALDOMAIN環境変数が存在する場合（空でも）、 RES_OPTIONSまたはHOSTALIASES環境変数が空でない場合、 ASR_CONFIG環境変数が空でない場合（OpenBSDのみ）、 /etc/resolv.confまたは/etc/nsswitch.confがGoリゾルバが実装していない機能の使用を指定している場合。

すべてのシステム（Plan 9を除く）で、cgoリゾルバが使用されている場合、 このパッケージは並行cgoルックアップ制限を適用して、システムがシステムスレッドを使い果たすのを防ぎます。 現在、同時ルックアップは500に制限されています。

リゾルバの決定は、GODEBUG環境変数のnetdns値をgoまたはcgoに設定することで 上書きすることができます（パッケージruntimeを参照）。 

export GODEBUG=netdns=go    # 純粋なGoリゾルバを強制する
export GODEBUG=netdns=cgo   # ネイティブリゾルバを強制する（cgo、win32）

この判断は、Goソースツリーをビルドする際にも、netgoまたはnetcgoビルドタグを設定することで強制することができます。

GODEBUG=netdns=1のような数値のnetdns設定は、リゾルバが自身の判断に関するデバッグ情報を出力します。 特定のリゾルバを強制すると同時にデバッグ情報を出力するには、 2つの設定をプラス記号で結合します。例：GODEBUG=netdns=go+1。

Goリゾルバは、DNSリクエストとともにEDNS0追加ヘッダーを送信し、 より大きなDNSパケットサイズを受け入れる意思を示します。 これは、一部のモデムやルーターが運用するDNSサーバーで断続的な障害を引き起こすと報告されています。 GODEBUG=netedns0=0を設定すると、追加ヘッダーの送信が無効になります。

macOSでは、netパッケージを使用するGoコードが-buildmode=c-archiveでビルドされる場合、 生成されたアーカイブをCプログラムにリンクする際に、Cコードをリンクするときに-lresolvを渡す必要があります。

Plan 9では、リゾルバは常に/net/csと/net/dnsにアクセスします。

Windowsでは、Go 1.18.x以前では、GetAddrInfoやDnsQueryなどのCライブラリ関数をリゾルバが常に使用していました。

Index

Examples

Constants

View Source 
const (
	IPv4len = 4
	IPv6len = 16
)

IPアドレスの長さ（バイト単位）。

Variables

View Source 
var (
	IPv4bcast     = IPv4(255, 255, 255, 255)
	IPv4allsys    = IPv4(224, 0, 0, 1)
	IPv4allrouter = IPv4(224, 0, 0, 2)
	IPv4zero      = IPv4(0, 0, 0, 0)
)

有名なIPv4アドレス

View Source 
var (
	IPv6zero                   = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	IPv6unspecified            = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	IPv6loopback               = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
	IPv6interfacelocalallnodes = IP{0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
	IPv6linklocalallnodes      = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
	IPv6linklocalallrouters    = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x02}
)

有名なIPv6アドレス

View Source 
var DefaultResolver = &Resolver{}

DefaultResolverは、パッケージレベルのLookup関数と指定されていないResolverを持つDialersによって使用されるリゾルバです。

View Source 
var ErrClosed error = errClosed

ErrClosedは、既に閉じられたネットワーク接続またはI/Oが完了する前に他のゴルーチンによって閉じられたネットワーク接続上のI/O呼び出しによって返されるエラーです。これは他のエラーに包まれる場合があり、通常はerrors.Is(err, net.ErrClosed)を使用してテストする必要があります。

View Source 
var (
	ErrWriteToConnected = errors.New("use of WriteTo with pre-connected connection")
)

OpErrorに含まれる様々なエラー。

Functions

func JoinHostPort 

func JoinHostPort(host, port string) string

JoinHostPort はホストとポートを "ホスト:ポート" のネットワークアドレスに結合します。 ホストがコロンを含んでいる場合、リテラルIPv6アドレスで見つかるように、JoinHostPortは "[host]:port" を返します。

ホストとポートパラメータの説明については、func Dial を参照してください。

func LookupAddr 

func LookupAddr(addr string) (names []string, err error)

LookupAddrは与えられたアドレスに対して逆引きを行い、そのアドレスにマッピングされる名前のリストを返します。 返された名前は適切にフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。応答に無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーと一緒に残りの結果（ある場合）が返されます。 ホストCライブラリリゾルバを使用する場合、最大で1つの結果が返されます。ホストリゾルバをバイパスするには、カスタム Resolver を使用してください。 LookupAddrは内部で context.Background を使用します。コンテキストを指定するには、Resolver.LookupAddr を使用してください。

func LookupCNAME 

func LookupCNAME(host string) (cname string, err error)

LookupCNAMEは指定されたホストの正式な名前（カノニカル名）を返します。 カノニカル名に関心がない場合は、LookupHost または LookupIP を直接呼び出すことができます。 どちらも、ルックアップの一部としてカノニカル名の解決を行います。

カノニカル名は、ゼロまたは複数のCNAMEレコードを辿った後の最終的な名前です。 hostにDNSの"CNAME"レコードが含まれていない場合でも、hostがアドレスレコードに解決されている限り、LookupCNAMEはエラーを返しません。

返されるカノニカル名は、正しくフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。

LookupCNAMEは内部的に context.Background を使用します。コンテキストを指定するには、Resolver.LookupCNAME を使用してください。

func LookupHost 

func LookupHost(host string) (addrs []string, err error)

LookupHostは、ローカルのリゾルバを使用して指定されたホストを検索します。 そのホストのアドレスのスライスを返します。

LookupHostは、内部的に context.Background を使用します。コンテキストを指定するには、 Resolver.LookupHost を使用してください。

func LookupPort 

func LookupPort(network, service string) (port int, err error)

LookupPortは指定されたネットワークとサービスに対するポートを調べます。

LookupPortは内部で context.Background を使用します。コンテキストを指定するには、 Resolver.LookupPort を使用してください。

func LookupTXT 

func LookupTXT(name string) ([]string, error)

LookupTXTは指定されたドメイン名のDNS TXTレコードを返します。

LookupTXTは内部で context.Background を使用します。コンテキストを指定するには、 Resolver.LookupTXT を使用してください。

func ParseCIDR 

func ParseCIDR(s string) (IP, *IPNet, error)

ParseCIDRはCIDR表記のIPアドレスとプレフィックス長を含むsを解析します。 例えば、"192.0.2.0/24"や"2001:db8::/32"のようなものです。 RFC 4632とRFC 4291で定義されています。

IPアドレスとプレフィックス長によって暗示されるIPとネットワークを返します。 例えば、ParseCIDR("192.0.2.1/24")はIPアドレスが 192.0.2.1でネットワークが192.0.2.0/24を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv4Addr, ipv4Net, err := net.ParseCIDR("192.0.2.1/24")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ipv4Addr)
	fmt.Println(ipv4Net)

	ipv6Addr, ipv6Net, err := net.ParseCIDR("2001:db8:a0b:12f0::1/32")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ipv6Addr)
	fmt.Println(ipv6Net)

}

Output:

192.0.2.1
192.0.2.0/24
2001:db8:a0b:12f0::1
2001:db8::/32

func Pipe 

func Pipe() (Conn, Conn)

Pipeは同期的な、インメモリ、フルダプレックスのネットワーク接続を作成します。 両端は Conn インターフェースを実装しています。 一方の端での読み取りは、もう一方の端での書き込みと一致し、データを直接コピーします。 内部バッファリングはありません。

func SplitHostPort 

func SplitHostPort(hostport string) (host, port string, err error)

SplitHostPortは、"host:port"、"host％zone:port"、"[host]:port"、または "[host%zone]:port" のネットワークアドレスをhostまたはhost％zoneとポートに分割します。

ホストポート内のリテラルIPv6アドレスは、"[::1]:80"、"[::1％lo0]:80"のように角括弧で囲む必要があります。

hostportパラメータ、およびhostとportの結果の詳細については、func Dialを参照してください。

Types

type Addr 

type Addr interface {
	Network() string
	String() string
}

Addrはネットワークのエンドポイントアドレスを表します。

2つのメソッド [Addr.Network] および [Addr.String] は、通常、Dial の引数として渡すことができる文字列を返しますが、 その文字列の形式や意味については実装次第です。

func InterfaceAddrs 

func InterfaceAddrs() ([]Addr, error)

InterfaceAddrsはシステムのユニキャストインターフェースのアドレスのリストを返します。

返されたリストは関連するインターフェースを識別しません。詳細についてはInterfacesと Interface.Addrs を使用してください。

type AddrError 

type AddrError struct {
	Err  string
	Addr string
}

func (*AddrError) Error 

func (e *AddrError) Error() string

func (*AddrError) Temporary 

func (e *AddrError) Temporary() bool

func (*AddrError) Timeout 

func (e *AddrError) Timeout() bool

type Buffers added in v1.8.0 

type Buffers [][]byte

Buffersは、書き込むバイトのゼロ以上のランを含んでいます。

ある種の接続に対して、特定のマシンでは、これはOS固有のバッチ書き込み操作（"writev"など）に最適化されます。

func (*Buffers) Read added in v1.8.0 

func (v *Buffers) Read(p []byte) (n int, err error)

バッファから読み込む。

Read は Buffers に io.Reader を実装します。

Read はスライス v と v[i]（ただし、0 <= i < len(v)）を変更しますが、 v[i][j]（ただし、任意の i, j）は変更しません。

func (*Buffers) WriteTo added in v1.8.0 

func (v *Buffers) WriteTo(w io.Writer) (n int64, err error)

WriteTo はバッファの内容を w に書き込みます。

WriteTo は、Buffers に io.WriterTo を実装します。

WriteTo は、0 <= i < len(v) の範囲の v[i] およびスライス v を変更しますが、v[i][j] (i, j は任意の値) は変更しません。

type Conn 

type Conn interface {
	Read(b []byte) (n int, err error)

	Write(b []byte) (n int, err error)

	Close() error

	LocalAddr() Addr

	RemoteAddr() Addr

	SetDeadline(t time.Time) error

	SetReadDeadline(t time.Time) error

	SetWriteDeadline(t time.Time) error
}

Connは汎用のストリーム指向のネットワーク接続です。

複数のgoroutineがConn上のメソッドを同時に呼び出すことができます。

func Dial 

func Dial(network, address string) (Conn, error)

Dialは指定されたネットワークのアドレスに接続します。

知られているネットワークは "tcp", "tcp4" (IPv4のみ), "tcp6" (IPv6のみ), "udp", "udp4" (IPv4のみ), "udp6" (IPv6のみ), "ip", "ip4" (IPv4のみ), "ip6" (IPv6のみ), "unix", "unixgram" および "unixpacket" です。

TCPとUDPのネットワークの場合、アドレスは "ホスト:ポート" の形式で指定します。 ホストはリテラルのIPアドレスであるか、IPアドレスに解決できるホスト名である必要があります。 ポートはリテラルのポート番号またはサービス名である必要があります。 ホストがリテラルのIPv6アドレスの場合、"[2001:db8::1]:80" または "[fe80::1%zone]:80" のように角括弧で囲む必要があります。 ゾーンは、RFC 4007で定義されているリテラルのIPv6アドレスのスコープを指定します。 関数 JoinHostPort と SplitHostPort は、この形式のホストとポートのペアを操作します。 TCPを使用し、ホストが複数のIPアドレスに解決される場合、Dialは順番に各IPアドレスを試し、成功したものを使用します。

例:

Dial("tcp", "golang.org:http") Dial("tcp", "192.0.2.1:http") Dial("tcp", "198.51.100.1:80") Dial("udp", "[2001:db8::1]:domain") Dial("udp", "[fe80::1%lo0]:53") Dial("tcp", ":80")

IPネットワークの場合、ネットワークは "ip", "ip4" または "ip6" の後にコロンとリテラルのプロトコル番号またはプロトコル名が続き、 アドレスは "ホスト" の形式となります。ホストはリテラルのIPアドレスまたはゾーン付きのリテラルのIPv6アドレスである必要があります。 "0" や "255" などの広く知られていないプロトコル番号の場合、各オペレーティングシステムによって動作が異なることによります。

例:

Dial("ip4:1", "192.0.2.1") Dial("ip6:ipv6-icmp", "2001:db8::1") Dial("ip6:58", "fe80::1%lo0")

TCP、UDP、およびIPネットワークの場合、ホストが空白またはリテラルの未指定IPアドレスの場合、 すなわち ":80", "0.0.0.0:80" または "[::]:80" などの場合、TCPおよびUDPでは、 ""、"0.0.0.0" または "::" などの場合、IPでは、ローカルシステムが仮定されます。

UNIXネットワークの場合、アドレスはファイルシステムのパスである必要があります。

func DialTimeout 

func DialTimeout(network, address string, timeout time.Duration) (Conn, error)

DialTimeoutは、タイムアウトを設定して Dial と同様の動作をします。

必要に応じて名前解決も含まれたタイムアウト処理が行われます。 TCPを使用している場合、アドレスパラメータのホストが複数のIPアドレスに解決される場合は、 タイムアウトは各連続したダイヤルに均等に分散され、それぞれが適切な時間の一部を接続に割り当てます。

ネットワークとアドレスパラメータの詳細については、func Dialを参照してください。

func FileConn 

func FileConn(f *os.File) (c Conn, err error)

FileConnは、開いているファイルfに対応するネットワーク接続のコピーを返します。 使用が完了したら、呼び出し元の責任でfを閉じる必要があります。 cを閉じてもfには影響しませんし、fを閉じてもcには影響しません。

type DNSConfigError 

type DNSConfigError struct {
	Err error
}

DNSConfigErrorは、マシンのDNS設定を読み取る際のエラーを表します。 （使用されていませんが、互換性のために保持されています。）

func (*DNSConfigError) Error 

func (e *DNSConfigError) Error() string

func (*DNSConfigError) Temporary 

func (e *DNSConfigError) Temporary() bool

func (*DNSConfigError) Timeout 

func (e *DNSConfigError) Timeout() bool

func (*DNSConfigError) Unwrap added in v1.13.0 

func (e *DNSConfigError) Unwrap() error

type DNSError 

type DNSError struct {
	UnwrapErr   error
	Err         string
	Name        string
	Server      string
	IsTimeout   bool
	IsTemporary bool

	// IsNotFound is set to true when the requested name does not
	// contain any records of the requested type (data not found),
	// or the name itself was not found (NXDOMAIN).
	IsNotFound bool
}

DNSErrorはDNSの検索エラーを表します。

func (*DNSError) Error 

func (e *DNSError) Error() string

func (*DNSError) Temporary 

func (e *DNSError) Temporary() bool

Temporaryは、DNSエラーが一時的であることが確認されたかどうかを報告します。 これは常に確認できるわけではありません。DNSルックアップは一時的なエラーにより失敗し、 Temporaryがfalseを返す DNSError を返すことがあります。

func (*DNSError) Timeout 

func (e *DNSError) Timeout() bool

Timeoutは、DNSルックアップがタイムアウトしたことが確認されたかどうかを報告します。 これは常に確認できるわけではありません。DNSルックアップはタイムアウトにより失敗し、 Timeoutがfalseを返す DNSError を返すことがあります。

func (*DNSError) Unwrap added in v1.23.0 

func (e *DNSError) Unwrap() error

Unwrap returns e.UnwrapErr.

type Dialer added in v1.1.0 

type Dialer struct {

	// Timeoutはダイヤルが接続の完了を待つ最大時間です。Deadlineも設定されている場合、より早く失敗する可能性があります。
	// デフォルトはタイムアウトなしです。
	// TCPを使用して複数のIPアドレスを持つホスト名にダイヤルする場合、タイムアウトはそれらの間で分割される場合があります。
	// タイムアウトの有無にかかわらず、オペレーティングシステムは独自の早期タイムアウトを課す場合があります。たとえば、TCPのタイムアウトは通常約3分です。
	Timeout time.Duration

	// Deadlineは、ダイヤルが失敗する絶対的な時間です。
	// Timeoutが設定されている場合、それよりも早く失敗することがあります。
	// ゼロは期限がないことを意味し、またはオペレーティングシステムに依存することもあります。
	// (Timeoutオプションと同様に)
	Deadline time.Time

	// LocalAddr is the local address to use when dialing an
	// address. The address must be of a compatible type for the
	// network being dialed.
	// If nil, a local address is automatically chosen.
	LocalAddr Addr

	// DualStackは以前からRFC 6555 Fast Fallback、または「Happy Eyeballs」として知られる機能をサポートしており、IPv6が誤設定されていて正しく動作していない場合にはIPv4がすぐに試されます。
	// 廃止予定：Fast Fallbackはデフォルトで有効になっています。無効にするには、FallbackDelayを負の値に設定してください。
	DualStack bool

	// FallbackDelayは、RFC 6555 Fast Fallback接続を作成する前に待機する時間の長さを指定します。つまり、IPv6が成功するまで待機する時間であり、IPv6の設定が誤っていると仮定し、IPv4に切り替える前に待機する時間です。
	// ゼロの場合、デフォルトの遅延時間は300msです。
	// 負の値はFast Fallbackサポートを無効にします。
	FallbackDelay time.Duration

	// KeepAlive specifies the interval between keep-alive
	// probes for an active network connection.
	//
	// KeepAlive is ignored if KeepAliveConfig.Enable is true.
	//
	// If zero, keep-alive probes are sent with a default value
	// (currently 15 seconds), if supported by the protocol and operating
	// system. Network protocols or operating systems that do
	// not support keep-alive ignore this field.
	// If negative, keep-alive probes are disabled.
	KeepAlive time.Duration

	// KeepAliveConfig specifies the keep-alive probe configuration
	// for an active network connection, when supported by the
	// protocol and operating system.
	//
	// If KeepAliveConfig.Enable is true, keep-alive probes are enabled.
	// If KeepAliveConfig.Enable is false and KeepAlive is negative,
	// keep-alive probes are disabled.
	KeepAliveConfig KeepAliveConfig

	// Resolverはオプションで、代替のリゾルバを指定することができます。
	Resolver *Resolver

	// Cancel is an optional channel whose closure indicates that
	// the dial should be canceled. Not all types of dials support
	// cancellation.
	//
	// Deprecated: Use DialContext instead.
	Cancel <-chan struct{}

	// Controlがnilでない場合、ネットワーク接続の作成後に、実際にダイアルする前に呼び出されます。
	//
	// Control関数に渡されるネットワークとアドレスのパラメータは、必ずしもDialに渡されるものとは限りません。たとえば、Dialに「tcp」を渡すと、Control関数は「tcp4」または「tcp6」で呼び出されます。
	//
	// ControlContextがnilでない場合、Controlは無視されます。
	Control func(network, address string, c syscall.RawConn) error

	// ControlContextがnilでない場合、ネットワークの接続を作成する前に呼び出されます。
	//
	// ControlContext関数に渡されるネットワークおよびアドレスのパラメータは、必ずしもDialに渡されたものではありません。
	// 例えば、Dialに"tcp"を渡すと、ControlContext関数は "tcp4" または "tcp6" とともに呼び出されます。
	//
	// ControlContextがnilでない場合、Controlは無視されます。
	ControlContext func(ctx context.Context, network, address string, c syscall.RawConn) error
	// contains filtered or unexported fields
}

Dialerはアドレスに接続するためのオプションを含んでいます。

各フィールドのゼロ値は、そのオプションなしでダイヤルすることと同等です。 Dialerのゼロ値でダイヤルすることは、単に Dial 関数を呼び出すのと同等です。

Dialerのメソッドを同時に呼び出しても安全です。

Example 
package main

import (
	"github.com/shogo82148/std/context"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
	"github.com/shogo82148/std/time"
)

func main() {
	var d net.Dialer
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	conn, err := d.DialContext(ctx, "tcp", "localhost:12345")
	if err != nil {
		log.Fatalf("Failed to dial: %v", err)
	}
	defer conn.Close()

	if _, err := conn.Write([]byte("Hello, World!")); err != nil {
		log.Fatal(err)
	}
}

Output:
Example (Unix) 
package main

import (
	"github.com/shogo82148/std/context"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
	"github.com/shogo82148/std/time"
)

func main() {
	// DialUnixはcontext.Contextパラメータを受け取りません。この例は、
	// Contextを使用してUnixソケットにダイヤルする方法を示しています。ただし、
	// Contextはダイヤル操作にのみ適用されます。接続が確立された後には適用されません。
	var d net.Dialer
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	d.LocalAddr = nil // もしローカルのアドレスがあれば、ここに追加してください。
	raddr := net.UnixAddr{Name: "/path/to/unix.sock", Net: "unix"}
	conn, err := d.DialContext(ctx, "unix", raddr.String())
	if err != nil {
		log.Fatalf("Failed to dial: %v", err)
	}
	defer conn.Close()
	if _, err := conn.Write([]byte("Hello, socket!")); err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Dialer) Dial added in v1.1.0 

func (d *Dialer) Dial(network, address string) (Conn, error)

Dialは指定されたネットワーク上のアドレスに接続します。

ネットワークとアドレスの詳細は、func Dialの説明を参照してください。

Dialは内部的に context.Background を使用します。コンテキストを指定するには、Dialer.DialContext を使用してください。

func (*Dialer) DialContext added in v1.7.0 

func (d *Dialer) DialContext(ctx context.Context, network, address string) (Conn, error)

DialContextは、指定されたコンテキストを使用して、指定されたネットワーク上のアドレスに接続します。

提供されたコンテキストは、nilでない必要があります。接続が完了する前にコンテキストが期限切れになると、エラーが返されます。接続が成功した後、コンテキストの期限切れは接続に影響しません。

TCPを使用し、アドレスパラメータのホストが複数のネットワークアドレスに解決される場合、ダイヤルタイムアウト（d.Timeoutまたはctxから）は、各連続したダイヤルに均等に分散されます。それぞれのダイヤルには、適切な接続時間の割合が与えられます。 例えば、ホストが4つのIPアドレスを持ち、タイムアウトが1分の場合、次のアドレスを試す前に、各単一のアドレスへの接続には15秒の時間が与えられます。

ネットワークやアドレスパラメータの説明については、Dial 関数を参照してください。

func (*Dialer) MultipathTCP added in v1.21.0 

func (d *Dialer) MultipathTCP() bool

MultipathTCPはMPTCPを使用するかどうかを報告します。

このメソッドは、オペレーティングシステムがMPTCPをサポートしているかどうかをチェックしません。

func (*Dialer) SetMultipathTCP added in v1.21.0 

func (d *Dialer) SetMultipathTCP(use bool)

SetMultipathTCPは、オペレーティングシステムでサポートされている場合、Dial メソッドがMPTCPを使用するかどうかを指示します。 このメソッドは、システムのデフォルトとGODEBUG=multipathtcp=...の設定を上書きします。

ホストでMPTCPが利用できない場合やサーバーでサポートされていない場合、DialメソッドはTCPにフォールバックします。

type Error 

type Error interface {
	error
	Timeout() bool

	Temporary() bool
}

Errorはネットワークエラーを表します。

type Flags 

type Flags uint
const (
	FlagUp Flags = 1 << iota
	FlagBroadcast
	FlagLoopback
	FlagPointToPoint
	FlagMulticast
	FlagRunning
)

func (Flags) String 

func (f Flags) String() string

type HardwareAddr 

type HardwareAddr []byte

HardwareAddrは物理的なハードウェアアドレスを表します。

func ParseMAC 

func ParseMAC(s string) (hw HardwareAddr, err error)

ParseMACは、次のいずれかの形式で定義されたIEEE 802 MAC-48、EUI-48、EUI-64、または20オクテットのIP over InfiniBandリンク層アドレスとしてsを解析します： 

00:00:5e:00:53:01
02:00:5e:10:00:00:00:01
00:00:00:00:fe:80:00:00:00:00:00:00:02:00:5e:10:00:00:00:01
00-00-5e-00-53-01
02-00-5e-10-00-00-00-01
00-00-00-00-fe-80-00-00-00-00-00-00-02-00-5e-10-00-00-00-01
0000.5e00.5301
0200.5e10.0000.0001
0000.0000.fe80.0000.0000.0000.0200.5e10.0000.0001

func (HardwareAddr) String 

func (a HardwareAddr) String() string

type IP 

type IP []byte

IPは単一のIPアドレス、バイトのスライスです。 このパッケージの関数は、4バイト（IPv4）または16バイト（IPv6）のスライスを入力として受け付けます。

このドキュメントでは、IPアドレスをIPv4アドレスまたはIPv6アドレスと呼ぶことは、アドレスの意味的な属性であり、単にバイトスライスの長さだけではありません：16バイトスライスもIPv4アドレスである可能性があります。

Example (To4) 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	ipv4 := net.IPv4(10, 255, 0, 0)

	fmt.Println(ipv6.To4())
	fmt.Println(ipv4.To4())

}

Output:

<nil>
10.255.0.0

func IPv4 

func IPv4(a, b, c, d byte) IP

IPv4は、IPv4アドレスa.b.c.dのIPアドレス（16バイト形式）を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	fmt.Println(net.IPv4(8, 8, 8, 8))

}

Output:

8.8.8.8

func LookupIP 

func LookupIP(host string) ([]IP, error)

LookupIPはローカルリゾルバを使用してホストを検索します。 それはそのホストのIPv4およびIPv6アドレスのスライスを返します。

func ParseIP 

func ParseIP(s string) IP

ParseIPは文字列sをIPアドレスと解釈し、結果を返します。 文字列sはIPv4点区切りの10進法（「192.0.2.1」）、IPv6（「2001:db8::68」）、またはIPv4-mapped IPv6形式（「::ffff:192.0.2.1」）で書かれている必要があります。 もしsが有効なIPアドレスのテキスト表現ではない場合、ParseIPはnilを返します。 返されるアドレスは常に16バイトであり、 IPv4アドレスはIPv4マップドIPv6形式で返されます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	fmt.Println(net.ParseIP("192.0.2.1"))
	fmt.Println(net.ParseIP("2001:db8::68"))
	fmt.Println(net.ParseIP("192.0.2"))

}

Output:

192.0.2.1
2001:db8::68
<nil>

func (IP) DefaultMask 

func (ip IP) DefaultMask() IPMask

DefaultMaskはIPアドレスipのデフォルトのマスクを返します。 IPv4アドレスのみがデフォルトマスクを持ちます。ipが有効なIPv4アドレスでない場合、DefaultMaskは nilを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ip := net.ParseIP("192.0.2.1")
	fmt.Println(ip.DefaultMask())

}

Output:

ffffff00

func (IP) Equal 

func (ip IP) Equal(x IP) bool

Equalは、ipとxが同じIPアドレスであるかどうかを報告します。 IPv4アドレスと同じアドレスを持つIPv6形式は 同じものと見なされます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv4DNS := net.ParseIP("8.8.8.8")
	ipv4Lo := net.ParseIP("127.0.0.1")
	ipv6DNS := net.ParseIP("0:0:0:0:0:FFFF:0808:0808")

	fmt.Println(ipv4DNS.Equal(ipv4DNS))
	fmt.Println(ipv4DNS.Equal(ipv4Lo))
	fmt.Println(ipv4DNS.Equal(ipv6DNS))

}

Output:

true
false
true

func (IP) IsGlobalUnicast 

func (ip IP) IsGlobalUnicast() bool

IsGlobalUnicastは、ipがグローバルユニキャストアドレスであるかどうかを報告します。

グローバルユニキャストアドレスの識別は、RFC 1122、RFC 4632、RFC 4291で定義されたアドレスタイプの識別を使用しますが、 IPv4の指示ブロードキャストアドレスは除外します。 ipがIPv4のプライベートアドレススペースまたはローカルIPv6ユニキャストアドレススペースにある場合でも、trueを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Global := net.ParseIP("2000::")
	ipv6UniqLocal := net.ParseIP("2000::")
	ipv6Multi := net.ParseIP("FF00::")

	ipv4Private := net.ParseIP("10.255.0.0")
	ipv4Public := net.ParseIP("8.8.8.8")
	ipv4Broadcast := net.ParseIP("255.255.255.255")

	fmt.Println(ipv6Global.IsGlobalUnicast())
	fmt.Println(ipv6UniqLocal.IsGlobalUnicast())
	fmt.Println(ipv6Multi.IsGlobalUnicast())

	fmt.Println(ipv4Private.IsGlobalUnicast())
	fmt.Println(ipv4Public.IsGlobalUnicast())
	fmt.Println(ipv4Broadcast.IsGlobalUnicast())

}

Output:

true
true
false
true
true
false

func (IP) IsInterfaceLocalMulticast 

func (ip IP) IsInterfaceLocalMulticast() bool

IsInterfaceLocalMulticastは、ipがインターフェースローカルなマルチキャストアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6InterfaceLocalMulti := net.ParseIP("ff01::1")
	ipv6Global := net.ParseIP("2000::")
	ipv4 := net.ParseIP("255.0.0.0")

	fmt.Println(ipv6InterfaceLocalMulti.IsInterfaceLocalMulticast())
	fmt.Println(ipv6Global.IsInterfaceLocalMulticast())
	fmt.Println(ipv4.IsInterfaceLocalMulticast())

}

Output:

true
false
false

func (IP) IsLinkLocalMulticast 

func (ip IP) IsLinkLocalMulticast() bool

IsLinkLocalMulticast は、与えられた IP アドレスがリンクローカルマルチキャストアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6LinkLocalMulti := net.ParseIP("ff02::2")
	ipv6LinkLocalUni := net.ParseIP("fe80::")
	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
	ipv4LinkLocalUni := net.ParseIP("169.254.0.0")

	fmt.Println(ipv6LinkLocalMulti.IsLinkLocalMulticast())
	fmt.Println(ipv6LinkLocalUni.IsLinkLocalMulticast())
	fmt.Println(ipv4LinkLocalMulti.IsLinkLocalMulticast())
	fmt.Println(ipv4LinkLocalUni.IsLinkLocalMulticast())

}

Output:

true
false
true
false

func (IP) IsLinkLocalUnicast 

func (ip IP) IsLinkLocalUnicast() bool

IsLinkLocalUnicast は、ip がリンクローカルユニキャストアドレスであるかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6LinkLocalUni := net.ParseIP("fe80::")
	ipv6Global := net.ParseIP("2000::")
	ipv4LinkLocalUni := net.ParseIP("169.254.0.0")
	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")

	fmt.Println(ipv6LinkLocalUni.IsLinkLocalUnicast())
	fmt.Println(ipv6Global.IsLinkLocalUnicast())
	fmt.Println(ipv4LinkLocalUni.IsLinkLocalUnicast())
	fmt.Println(ipv4LinkLocalMulti.IsLinkLocalUnicast())

}

Output:

true
false
true
false

func (IP) IsLoopback 

func (ip IP) IsLoopback() bool

IsLoopbackはipがループバックアドレスであるかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Lo := net.ParseIP("::1")
	ipv6 := net.ParseIP("ff02::1")
	ipv4Lo := net.ParseIP("127.0.0.0")
	ipv4 := net.ParseIP("128.0.0.0")

	fmt.Println(ipv6Lo.IsLoopback())
	fmt.Println(ipv6.IsLoopback())
	fmt.Println(ipv4Lo.IsLoopback())
	fmt.Println(ipv4.IsLoopback())

}

Output:

true
false
true
false

func (IP) IsMulticast 

func (ip IP) IsMulticast() bool

IsMulticastは、ipがマルチキャストアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Multi := net.ParseIP("FF00::")
	ipv6LinkLocalMulti := net.ParseIP("ff02::1")
	ipv6Lo := net.ParseIP("::1")
	ipv4Multi := net.ParseIP("239.0.0.0")
	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
	ipv4Lo := net.ParseIP("127.0.0.0")

	fmt.Println(ipv6Multi.IsMulticast())
	fmt.Println(ipv6LinkLocalMulti.IsMulticast())
	fmt.Println(ipv6Lo.IsMulticast())
	fmt.Println(ipv4Multi.IsMulticast())
	fmt.Println(ipv4LinkLocalMulti.IsMulticast())
	fmt.Println(ipv4Lo.IsMulticast())

}

Output:

true
true
false
true
true
false

func (IP) IsPrivate added in v1.17.0 

func (ip IP) IsPrivate() bool

IsPrivateは、RFC 1918（IPv4アドレス）およびRFC 4193（IPv6アドレス）に基づいて、IPがプライベートアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Private := net.ParseIP("fc00::")
	ipv6Public := net.ParseIP("fe00::")
	ipv4Private := net.ParseIP("10.255.0.0")
	ipv4Public := net.ParseIP("11.0.0.0")

	fmt.Println(ipv6Private.IsPrivate())
	fmt.Println(ipv6Public.IsPrivate())
	fmt.Println(ipv4Private.IsPrivate())
	fmt.Println(ipv4Public.IsPrivate())

}

Output:

true
false
true
false

func (IP) IsUnspecified 

func (ip IP) IsUnspecified() bool

IsUnspecified は、ipが特定されていないアドレスであるかどうかを報告します。 つまり、IPv4アドレスの "0.0.0.0" またはIPv6アドレス "::" です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Unspecified := net.ParseIP("::")
	ipv6Specified := net.ParseIP("fe00::")
	ipv4Unspecified := net.ParseIP("0.0.0.0")
	ipv4Specified := net.ParseIP("8.8.8.8")

	fmt.Println(ipv6Unspecified.IsUnspecified())
	fmt.Println(ipv6Specified.IsUnspecified())
	fmt.Println(ipv4Unspecified.IsUnspecified())
	fmt.Println(ipv4Specified.IsUnspecified())

}

Output:

true
false
true
false

func (IP) MarshalText added in v1.2.0 

func (ip IP) MarshalText() ([]byte, error)

MarshalTextは encoding.TextMarshaler インターフェースを実装します。 エンコードは IP.String で返されるものと同じですが、1つ例外があります： len(ip)がゼロの場合、空のスライスを返します。

func (IP) Mask 

func (ip IP) Mask(mask IPMask) IP

MaskはIPアドレスipをmaskでマスクした結果を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv4Addr := net.ParseIP("192.0.2.1")
	// このマスクはIPv4の/24サブネットに対応しています。
	ipv4Mask := net.CIDRMask(24, 32)
	fmt.Println(ipv4Addr.Mask(ipv4Mask))

	ipv6Addr := net.ParseIP("2001:db8:a0b:12f0::1")
	// このマスクはIPv6の/32サブネットに対応しています。
	ipv6Mask := net.CIDRMask(32, 128)
	fmt.Println(ipv6Addr.Mask(ipv6Mask))

}

Output:

192.0.2.0
2001:db8::

func (IP) String 

func (ip IP) String() string

StringはIPアドレスipの文字列形式を返します。 それは以下の4つの形式のいずれかを返します:

  • "<nil>", ipの長さが0の場合
  • ドット付きの10進表現 ("192.0.2.1"), ipがIPv4またはIP4-mapped IPv6アドレスの場合
  • RFC 5952に準拠したIPv6形式 ("2001:db8::1"), ipが有効なIPv6アドレスの場合
  • 上記の条件に当てはまらない場合は、ipの句読点を除いた16進数形式
Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	ipv4 := net.IPv4(10, 255, 0, 0)

	fmt.Println(ipv6.String())
	fmt.Println(ipv4.String())

}

Output:

fc00::
10.255.0.0

func (IP) To16 

func (ip IP) To16() IP

To16はIPアドレスipを16バイトの表現に変換します。 ipがIPアドレスでない場合（長さが正しくない場合）、To16はnilを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	ipv4 := net.IPv4(10, 255, 0, 0)

	fmt.Println(ipv6.To16())
	fmt.Println(ipv4.To16())

}

Output:

fc00::
10.255.0.0

func (IP) To4 

func (ip IP) To4() IP

To4はIPv4アドレスを4バイトの表現に変換します。 もしipがIPv4アドレスでない場合、To4はnilを返します。

func (*IP) UnmarshalText added in v1.2.0 

func (ip *IP) UnmarshalText(text []byte) error

UnmarshalTextは encoding.TextUnmarshaler インターフェースを実装します。 IPアドレスは ParseIP で受け入れられる形式で指定することが期待されています。

type IPAddr 

type IPAddr struct {
	IP   IP
	Zone string
}

IPAddrはIPエンドポイントのアドレスを表します。

func ResolveIPAddr 

func ResolveIPAddr(network, address string) (*IPAddr, error)

ResolveIPAddrはIPエンドポイントのアドレスを返します。

ネットワークはIPネットワーク名である必要があります。

アドレスパラメーターのホストがリテラルIPアドレスではない場合、 ResolveIPAddrはIPエンドポイントのアドレスに解決します。 そうでなければ、アドレスをリテラルのIPアドレスとして解析します。 アドレスパラメーターはホスト名を使用することもできますが、 これは推奨されません。なぜなら、ホスト名のIPアドレスのうち最大で1つしか返さないからです。

ネットワークとアドレスパラメーターの説明については、Dial 関数を参照してください。

func (*IPAddr) Network 

func (a *IPAddr) Network() string

Networkはアドレスのネットワーク名を返します。"ip"。

func (*IPAddr) String 

func (a *IPAddr) String() string

type IPConn 

type IPConn struct {
	// contains filtered or unexported fields
}

IPConnはIPネットワーク接続の Conn および PacketConn インターフェースの実装です。

func DialIP 

func DialIP(network string, laddr, raddr *IPAddr) (*IPConn, error)

DialIPはIPネットワークに対して Dial のように機能します。

ネットワークはIPネットワーク名である必要があります。詳細はfunc Dialを参照してください。

もしladdrがnilであれば、ローカルアドレスが自動的に選択されます。 もしraddrのIPフィールドがnilであるか、未指定のIPアドレスである場合、 ローカルシステムが仮定されます。

func ListenIP 

func ListenIP(network string, laddr *IPAddr) (*IPConn, error)

ListenIPはIPネットワーク用の ListenPacket と同様に機能します。

ネットワークはIPネットワーク名である必要があります。詳細についてはfunc Dialを参照してください。

もしladdrのIPフィールドがnilまたは指定されていないIPアドレスである場合、 ListenIPはローカルシステムの利用可能なすべてのIPアドレスでリッスンします マルチキャストIPアドレスを除く。

func (*IPConn) ReadFrom 

func (c *IPConn) ReadFrom(b []byte) (int, Addr, error)

ReadFromは PacketConn のReadFromメソッドを実装します。

func (*IPConn) ReadFromIP 

func (c *IPConn) ReadFromIP(b []byte) (int, *IPAddr, error)

ReadFromIPはReadFromと同様に動作しますが、IPAddrを返します。

func (*IPConn) ReadMsgIP added in v1.1.0 

func (c *IPConn) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error)

ReadMsgIPはcからメッセージを読み取り、ペイロードをbにコピーし、 関連する帯域外データをoobにコピーします。bにコピーされたバイト数、oobにコピーされたバイト数、 メッセージに設定されたフラグ、およびメッセージの送信元アドレスを返します。

パッケージ golang.org/x/net/ipv4 と golang.org/x/net/ipv6 を使用して、oobに対してIPレベルのソケットオプションを操作できます。

func (*IPConn) SyscallConn added in v1.9.0 

func (c *IPConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは、生のネットワーク接続を返します。 これは syscall.Conn インターフェースを実装しています。

func (*IPConn) WriteMsgIP added in v1.1.0 

func (c *IPConn) WriteMsgIP(b, oob []byte, addr *IPAddr) (n, oobn int, err error)

WriteMsgIPは、bからペイロードを、oobから関連のオフドーバンドータをコピーし、cを経由してaddrにメッセージを送信します。送信されたペイロードとオフドーバンドズダのバイト数を返します。

golang.org/x/net/ipv4とgolang.org/x/net/ipv6のパッケージを使用して、oob内のIPレベルのソケットオプションを操作することができます。

func (*IPConn) WriteTo 

func (c *IPConn) WriteTo(b []byte, addr Addr) (int, error)

WriteToは PacketConn のWriteToメソッドを実装します。

func (*IPConn) WriteToIP 

func (c *IPConn) WriteToIP(b []byte, addr *IPAddr) (int, error)

WriteToIPは IPConn.WriteTo と同様の動作をするが、IPAddr を取ります。

type IPMask 

type IPMask []byte

IPMaskは、IPアドレスのアドレッシングとルーティングに使用できる ビットマスクです。

詳細については、型 IPNet と関数 ParseCIDR を参照してください。

func CIDRMask 

func CIDRMask(ones, bits int) IPMask

CIDRMaskは、'ones'個の1ビットで構成された IPMask を返します。 その後、0ビットが 'bits'ビットの総長になるまで続きます。 この形式のマスクに対して、CIDRMaskは IPMask.Size の逆です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	// このマスクはIPv4の/31サブネットに対応しています。
	fmt.Println(net.CIDRMask(31, 32))

	// このマスクはIPv6の/64サブネットに対応しています。
	fmt.Println(net.CIDRMask(64, 128))

}

Output:

fffffffe
ffffffffffffffff0000000000000000

func IPv4Mask 

func IPv4Mask(a, b, c, d byte) IPMask

IPv4Maskは、IPv4マスクa.b.c.dのIPマスク（4バイト形式）を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	fmt.Println(net.IPv4Mask(255, 255, 255, 0))

}

Output:

ffffff00

func (IPMask) Size 

func (m IPMask) Size() (ones, bits int)

Sizeはマスクの先頭の1の数と合計のビット数を返します。 マスクが正規の形式でない場合、つまり、1が0に続く形式でない場合は、 Sizeは0, 0を返します。

func (IPMask) String 

func (m IPMask) String() string

Stringは、句読点なしのmの16進数形式を返します。

type IPNet 

type IPNet struct {
	IP   IP
	Mask IPMask
}

IPNetはIPネットワークを表します。

func (*IPNet) Contains 

func (n *IPNet) Contains(ip IP) bool

Containsは、ネットワークが指定したIPを含んでいるかどうかを報告します。

func (*IPNet) Network 

func (n *IPNet) Network() string

Networkはアドレスのネットワーク名、"ip+net"を返します。

func (*IPNet) String 

func (n *IPNet) String() string

Stringは、CIDR表記であるnの文字列を返します。例えば「192.0.2.0/24」やRFC 4632およびRFC 4291で定義されている「2001:db8::/48」です。 もしマスクが正規形式でない場合、IPアドレスに続いてスラッシュ文字とパンクチュエーションを含まない16進形式のマスクで表された文字列を返します。例えば「198.51.100.0/c000ff00」。

type Interface 

type Interface struct {
	Index        int
	MTU          int
	Name         string
	HardwareAddr HardwareAddr
	Flags        Flags
}

インターフェースはネットワークインタフェースの名前とインデックスのマッピングを表します。また、ネットワークインタフェースの機能情報も表します。

func InterfaceByIndex 

func InterfaceByIndex(index int) (*Interface, error)

InterfaceByIndex は、インデックスで指定されたインターフェースを返します。

Solarisでは、論理データリンクを共有する論理ネットワークインターフェースのうちの1つを返しますが、より正確な情報が必要な場合は、 InterfaceByName を使用してください。

func InterfaceByName 

func InterfaceByName(name string) (*Interface, error)

InterfaceByNameは、指定された名前で指定されたインターフェースを返します。

func Interfaces 

func Interfaces() ([]Interface, error)

インタフェースはシステムのネットワークインタフェースのリストを返します。

func (*Interface) Addrs 

func (ifi *Interface) Addrs() ([]Addr, error)

Addrsは特定のインターフェースのユニキャストインターフェースアドレスのリストを返します。

func (*Interface) MulticastAddrs 

func (ifi *Interface) MulticastAddrs() ([]Addr, error)

MulticastAddrsは特定のインターフェースに結合されたマルチキャストグループアドレスのリストを返します。

type InvalidAddrError 

type InvalidAddrError string

func (InvalidAddrError) Error 

func (e InvalidAddrError) Error() string

func (InvalidAddrError) Temporary 

func (e InvalidAddrError) Temporary() bool

func (InvalidAddrError) Timeout 

func (e InvalidAddrError) Timeout() bool

type KeepAliveConfig added in v1.23.0 

type KeepAliveConfig struct {
	// If Enable is true, keep-alive probes are enabled.
	Enable bool

	// Idle is the time that the connection must be idle before
	// the first keep-alive probe is sent.
	// If zero, a default value of 15 seconds is used.
	Idle time.Duration

	// Interval is the time between keep-alive probes.
	// If zero, a default value of 15 seconds is used.
	Interval time.Duration

	// Count is the maximum number of keep-alive probes that
	// can go unanswered before dropping a connection.
	// If zero, a default value of 9 is used.
	Count int
}

KeepAliveConfig contains TCP keep-alive options.

If the Idle, Interval, or Count fields are zero, a default value is chosen. If a field is negative, the corresponding socket-level option will be left unchanged.

Note that prior to Windows 10 version 1709, neither setting Idle and Interval separately nor changing Count (which is usually 10) is supported. Therefore, it's recommended to set both Idle and Interval to non-negative values in conjunction with a -1 for Count on those old Windows if you intend to customize the TCP keep-alive settings. By contrast, if only one of Idle and Interval is set to a non-negative value, the other will be set to the system default value, and ultimately, set both Idle and Interval to negative values if you want to leave them unchanged.

Note that Solaris and its derivatives do not support setting Interval to a non-negative value and Count to a negative value, or vice-versa.

type ListenConfig added in v1.11.0 

type ListenConfig struct {

	// Controlがnilでない場合、ネットワーク接続を作成した後、
	// オペレーティングシステムにバインドする前に呼び出されます。
	//
	// Controlメソッドに渡されるネットワークとアドレスのパラメータは、
	// 必ずしもListenに渡されるものとは限りません。例えば、"tcp"を
	// Listenに渡すと、Control関数へは"tcp4"または"tcp6"が渡されます。
	Control func(network, address string, c syscall.RawConn) error

	// KeepAlive specifies the keep-alive period for network
	// connections accepted by this listener.
	//
	// KeepAlive is ignored if KeepAliveConfig.Enable is true.
	//
	// If zero, keep-alive are enabled if supported by the protocol
	// and operating system. Network protocols or operating systems
	// that do not support keep-alive ignore this field.
	// If negative, keep-alive are disabled.
	KeepAlive time.Duration

	// KeepAliveConfig specifies the keep-alive probe configuration
	// for an active network connection, when supported by the
	// protocol and operating system.
	//
	// If KeepAliveConfig.Enable is true, keep-alive probes are enabled.
	// If KeepAliveConfig.Enable is false and KeepAlive is negative,
	// keep-alive probes are disabled.
	KeepAliveConfig KeepAliveConfig
	// contains filtered or unexported fields
}

ListenConfig はアドレスのリッスンに関するオプションを含んでいます。

func (*ListenConfig) Listen added in v1.11.0 

func (lc *ListenConfig) Listen(ctx context.Context, network, address string) (Listener, error)

Listenはローカルネットワークアドレスでアナウンスします。

ネットワークおよびアドレスの詳細については、func Listenを参照してください。

func (*ListenConfig) ListenPacket added in v1.11.0 

func (lc *ListenConfig) ListenPacket(ctx context.Context, network, address string) (PacketConn, error)

ListenPacketはローカルネットワークアドレスでアナウンスします。

ネットワークとアドレスのパラメーターの説明については、func ListenPacketを参照してください。

func (*ListenConfig) MultipathTCP added in v1.21.0 

func (lc *ListenConfig) MultipathTCP() bool

MultipathTCPはMPTCPが使用されるかどうかを報告します。

このメソッドはオペレーティングシステムがMPTCPをサポートしているかどうかを確認しません。

func (*ListenConfig) SetMultipathTCP added in v1.21.0 

func (lc *ListenConfig) SetMultipathTCP(use bool)

SetMultipathTCPは、オペレーティングシステムがサポートしている場合、Listen メソッドがMPTCPを使用するかどうかを指示します。 このメソッドは、システムのデフォルトおよびGODEBUG=multipathtcp=...の設定を上書きします。

ホスト上でMPTCPが利用できない場合、またはクライアントがサポートしていない場合、 ListenメソッドはTCPにフォールバックします。

type Listener 

type Listener interface {
	Accept() (Conn, error)

	Close() error

	Addr() Addr
}

リスナーはストリーム指向のプロトコルのための汎用のネットワークリスナーです。

複数のゴルーチンが同時にリスナーのメソッドを呼び出すことができます。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
)

func main() {
	// ローカルシステムの利用可能なすべてのユニキャストおよび
	// IPv4マルチキャストアドレス上のTCPポート2000でリッスンします。
	l, err := net.Listen("tcp", ":2000")
	if err != nil {
		log.Fatal(err)
	}
	defer l.Close()
	for {
		// Wait for a connection.
		conn, err := l.Accept()
		if err != nil {
			log.Fatal(err)
		}
		// 新しいgoroutineで接続を処理する。
		// ループはその後、受け付けを再開するため、
		// 複数の接続を同時に処理することが可能です。
		go func(c net.Conn) {
			// すべての受信データをエコーします。
			io.Copy(c, c)
			// 接続をシャットダウンします。
			c.Close()
		}(conn)
	}
}

Output:

func FileListener 

func FileListener(f *os.File) (ln Listener, err error)

FileListenerは、開いたファイルfに対応するネットワークリスナーのコピーを返します。 lnを使用後に閉じる責任は呼び出し元にあります。 lnを閉じるとfには影響しませんし、fを閉じるとlnにも影響しません。

func Listen 

func Listen(network, address string) (Listener, error)

Listenはローカルネットワークアドレスでアナウンスします。

ネットワークは"tcp"、"tcp4"、"tcp6"、"unix"、または"unixpacket"である必要があります。

TCPネットワークの場合、アドレスパラメータのホストが空または明示的に指定されていないIPアドレスの場合、Listenは利用可能なすべてのユニキャストおよびエニーキャストIPアドレスでリッスンします。 IPv4のみを使用する場合は、ネットワークに"tcp4"を使用します。 アドレスにはホスト名を使用できますが、これは推奨されないため、ホストのIPアドレスの最大1つのリスナーが作成されます。 アドレスパラメータのポートが空または"0"の場合、例えば"127.0.0.1:"や"[::1]:0"のように、ポート番号が自動的に選択されます。 Listener の Addr メソッドを使用して、選択されたポートを取得できます。

ネットワークおよびアドレスパラメータの説明については、Dial 関数を参照してください。

Listenは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、ListenConfig.Listen を使用してください。

type MX 

type MX struct {
	Host string
	Pref uint16
}

MXは単一のDNS MXレコードを表します。

func LookupMX 

func LookupMX(name string) ([]*MX, error)

LookupMXは指定されたドメイン名のDNS MXレコードを優先度に従ってソートして返します。

返されるメールサーバー名は、正しくフォーマットされた表示形式のドメイン名であることが検証されます。 レスポンスに無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーと共に残りの結果が返されます（もしあれば）。

LookupMXは内部的に context.Background を使用します。コンテキストを指定するには、Resolver.LookupMX を使用してください。

type NS added in v1.1.0 

type NS struct {
	Host string
}

NSは単一のDNS NSレコードを表します。

func LookupNS added in v1.1.0 

func LookupNS(name string) ([]*NS, error)

LookupNSは指定されたドメイン名のDNS NSレコードを返します。

返されるネームサーバ名は、正しくフォーマットされた表示形式のドメイン名であることが検証されます。 応答に無効な名前が含まれている場合、これらのレコードはフィルタリングされ、エラーが残りの結果と共に返されます。

LookupNSは内部的に context.Background を使用します。コンテキストを指定するには、Resolver.LookupNS を使用します。

type OpError 

type OpError struct {

	// Opはエラーの原因となった操作であり、
	// "read"または"write"などの操作です。
	Op string

	// Netはこのエラーが発生したネットワークの種類です。
	// 例えば、"tcp"や"udp6"などがあります。
	Net string

	// リモートネットワーク接続に関する操作（Dial、Read、またはWriteなど）において、ソースは対応するローカルネットワークアドレスです。
	Source Addr

	// Addrはこのエラーが発生したネットワークアドレスです。
	// ListenやSetDeadlineなどのローカルな操作の場合、Addrは操作されるローカルエンドポイントのアドレスです。
	// Dial、Read、またはWriteなどのリモートネットワーク接続に関する操作の場合、Addrはその接続のリモートアドレスです。
	Addr Addr

	// Errは操作中に発生したエラーです。
	// Errorメソッドはエラーがnilの場合にパニックを起こします。
	Err error
}

OpErrorは通常、netパッケージの関数によって返されるエラータイプです。これは操作、ネットワークタイプ、およびエラーのアドレスを説明します。

func (*OpError) Error 

func (e *OpError) Error() string

func (*OpError) Temporary 

func (e *OpError) Temporary() bool

func (*OpError) Timeout 

func (e *OpError) Timeout() bool

func (*OpError) Unwrap added in v1.13.0 

func (e *OpError) Unwrap() error

type PacketConn 

type PacketConn interface {
	ReadFrom(p []byte) (n int, addr Addr, err error)

	WriteTo(p []byte, addr Addr) (n int, err error)

	Close() error

	LocalAddr() Addr

	SetDeadline(t time.Time) error

	SetReadDeadline(t time.Time) error

	SetWriteDeadline(t time.Time) error
}

PacketConnは汎用のパケット指向のネットワーク接続です。

複数のゴルーチンは同時にPacketConnのメソッドを呼び出すことができます。

func FilePacketConn 

func FilePacketConn(f *os.File) (c PacketConn, err error)

FilePacketConn は、開いているファイル f に対応するパケットネットワーク接続のコピーを返します。 使用が終わったら f を閉じるのは呼び出し元の責任です。 c を閉じても f には影響しませんし、f を閉じても c には影響しません。

func ListenPacket 

func ListenPacket(network, address string) (PacketConn, error)

ListenPacketはローカルネットワークアドレスでの通知を行います。

ネットワークは「udp」「udp4」「udp6」「unixgram」またはIPトランスポートである必要があります。 IPトランスポートは、次の形式で「ip」「ip4」、「ip6」のいずれかの後に「:」とリテラルのプロトコル番号またはプロトコル名が続きます。 例：「ip:1」または「ip:icmp」。

UDPとIPネットワークの場合、アドレスパラメータのホストが空白またはリテラルの未指定のIPアドレスの場合、 ListenPacketはマルチキャストIPアドレス以外のすべての利用可能なローカルシステムのIPアドレスでリスンします。 IPv4のみを使用する場合は、ネットワークに「udp4」または「ip4:proto」を使用します。 アドレスはホスト名を使用することもできますが、これは推奨されません。 なぜなら、それによってホストのIPアドレスのうちの最大で1つのリスナが作成されるからです。 アドレスパラメータのポートが空または「0」の場合、「127.0.0.1:」や「[::1]:0」といった形式で、ポート番号は自動的に選択されます。 PacketConn のLocalAddrメソッドを使用して選択されたポートを特定することができます。

ネットワークおよびアドレスパラメータの説明については、Dial 関数を参照してください。

ListenPacketは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、 ListenConfig.ListenPacket を使用してください。

type ParseError 

type ParseError struct {

	// Typeは期待される文字列のタイプです。例えば、「IPアドレス」、「CIDRアドレス」などです。
	Type string

	// Textは不正なテキスト文字列です。
	Text string
}

ParseErrorは文字列形式のネットワークアドレスパーサーのエラータイプです。

func (*ParseError) Error 

func (e *ParseError) Error() string

func (*ParseError) Temporary added in v1.17.0 

func (e *ParseError) Temporary() bool

func (*ParseError) Timeout added in v1.17.0 

func (e *ParseError) Timeout() bool

type Resolver added in v1.8.0 

type Resolver struct {

	// PreferGoは、利用可能なプラットフォーム上でGoの組み込みDNSリゾルバーを優先するかどうかを制御します。これはGODEBUG=netdns=goを設定するのと同等ですが、このリゾルバーにのみスコープされます。
	PreferGo bool

	// StrictErrorsは、一時的なエラー（タイムアウト、ソケットエラー、およびSERVFAILを含む）の動作を制御します。Goの組み込みリゾルバを使用する場合、このオプションは複数のサブクエリからなるクエリ（A+AAAAアドレスの検索やDNS検索リストの走査など）に対して、部分的な結果を返す代わりに、エラーが発生した場合にクエリ全体を中止させます。これはデフォルトでは有効にされていませんが、AAAAクエリを正しく処理しないリゾルバとの互換性に影響を与える可能性があるためです。
	StrictErrors bool

	// Dialは、Go言語の組み込みDNSリゾルバがTCPおよびUDP接続を作成するために使用する代替ダイラーをオプションで指定します。アドレスパラメーターのホストは常にリテラルIPアドレスであり、ホスト名ではありません。また、アドレスパラメーターのポートはリテラルポート番号であり、サービス名ではありません。
	// 返されたConnがPacketConnでもある場合、送信および受信されるDNSメッセージはRFC 1035 Section 4.2.1 「UDP使用」に準拠する必要があります。
	Dial func(ctx context.Context, network, address string) (Conn, error)
	// contains filtered or unexported fields
}

Resolverは名前や数値を検索します。

nil *ResolverはゼロのResolverと同等です。

func (*Resolver) LookupAddr added in v1.8.0 

func (r *Resolver) LookupAddr(ctx context.Context, addr string) ([]string, error)

LookupAddrは指定されたアドレスの逆引きを行い、そのアドレスにマッピングされる名前のリストを返します。

返された名前は適切なフォーマットのプレゼンテーション形式のドメイン名であることが検証されます。 もし回答に無効な名前が含まれている場合、それらのレコードはフィルタリングされ、 残りの結果がある場合はエラーが返されます。

func (*Resolver) LookupCNAME added in v1.8.0 

func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error)

LookupCNAMEは指定されたホストの正規名を返します。 正規名に関心を持たない呼び出し元は、 LookupHost または LookupIP を直接呼び出すことができます。 両者は名前解決の一環として正規名を処理します。

正規名は、ゼロ個以上のCNAMEレコードをたどった後の最終名です。 LookupCNAMEは、ホストがDNSの"CNAME"レコードを含まない場合でも、 ホストがアドレスレコードに解決されている限り、エラーを返しません。

返される正規名は、適切な形式のドメイン名であることが検証されます。

func (*Resolver) LookupHost added in v1.8.0 

func (r *Resolver) LookupHost(ctx context.Context, host string) (addrs []string, err error)

LookupHostは、ローカルのリゾルバを使用して指定されたホストを検索します。 そのホストのアドレスのスライスを返します。

func (*Resolver) LookupIP added in v1.15.0 

func (r *Resolver) LookupIP(ctx context.Context, network, host string) ([]IP, error)

LookupIPは、ローカルリゾルバーを使用して指定されたネットワークのホストを検索します。 networkによって指定されたタイプのホストのIPアドレスのスライスを返します。 networkは"ip"、"ip4"、または"ip6"のいずれかでなければなりません。

func (*Resolver) LookupIPAddr added in v1.8.0 

func (r *Resolver) LookupIPAddr(ctx context.Context, host string) ([]IPAddr, error)

LookupIPAddrは、ローカルのリゾルバを使用してホストを検索します。 そのホストのIPv4およびIPv6アドレスのスライスを返します。

func (*Resolver) LookupMX added in v1.8.0 

func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error)

LookupMXは、指定されたドメイン名のDNS MXレコードを優先度に基づいてソートして返します。 返されるメールサーバー名は正しくフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。 レスポンスに無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーが返されます。 残りの結果がある場合、それらとともにエラーが返されます。

func (*Resolver) LookupNS added in v1.8.0 

func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error)

LookupNSは指定されたドメイン名のDNS NSレコードを返します。

返されたネームサーバの名前は、正しくフォーマットされた プレゼンテーション形式のドメイン名であることが検証されます。 もしレスポンスに無効な名前が含まれている場合、それらのレコードは フィルタリングされ、エラーが返されます。 残りの結果がある場合、それらとともにエラーが返されます。

func (*Resolver) LookupNetIP added in v1.18.0 

func (r *Resolver) LookupNetIP(ctx context.Context, network, host string) ([]netip.Addr, error)

LookupNetIPはローカルリゾルバを使用してホストを検索します。 それは、ネットワークで指定されたタイプのそのホストのIPアドレスのスライスを返します。 ネットワークは、"ip"、"ip4"、または "ip6"のいずれかでなければなりません。

func (*Resolver) LookupPort added in v1.8.0 

func (r *Resolver) LookupPort(ctx context.Context, network, service string) (port int, err error)

LookupPortは、指定されたネットワークとサービスのポートを検索します。

networkは、"tcp"、"tcp4"、"tcp6"、"udp"、"udp4"、"udp6"、または"ip"のいずれかでなければなりません。

func (*Resolver) LookupSRV added in v1.8.0 

func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error)

LookupSRVは、指定されたサービス、プロトコル、ドメイン名の SRV クエリを解決しようとします。 プロトコルは「tcp」または「udp」です。 返されるレコードは優先度でソートされ、優先度内でのウェイトによってランダムになります。

LookupSRVは、RFC 2782に従ってルックアップするためのDNS名を構築します。 つまり、_service._proto.nameをルックアップします。非標準の名前の下にSRVレコードを公開するサービスを収容するために、 serviceとprotoの両方が空の文字列の場合、LookupSRVは直接nameをルックアップします。

返されるサービス名は、正しくフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。 レスポンスに無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーが返されます。 残りの結果がある場合、それらと一緒にエラーが返されます。

func (*Resolver) LookupTXT added in v1.8.0 

func (r *Resolver) LookupTXT(ctx context.Context, name string) ([]string, error)

LookupTXTは指定されたドメイン名のDNSのTXTレコードを返します。

type SRV 

type SRV struct {
	Target   string
	Port     uint16
	Priority uint16
	Weight   uint16
}

SRVは単一のDNS SRVレコードを表します。

func LookupSRV 

func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error)

LookupSRVは、指定されたサービス、プロトコル、およびドメイン名の SRV クエリを解決しようとします。 protoは「tcp」または「udp」です。 返されるレコードは優先度に従ってソートされ、各優先度内で重みによってランダムになります。

LookupSRVはRFC 2782に従って調べるDNS名を構築します。 つまり、_service._proto.nameを検索します。非標準の名前でSRVレコードを公開するサービスに対応するために、 serviceとprotoの両方が空の文字列の場合、LookupSRVは直接nameを検索します。

返されたサービス名は、適切な形式のプレゼンテーション形式のドメイン名であることが検証されます。 応答に無効な名前が含まれている場合、これらのレコードはフィルタリングされ、エラーが返されます。 残りの結果がある場合は、これらのエラーと一緒に返されます。

type TCPAddr 

type TCPAddr struct {
	IP   IP
	Port int
	Zone string
}

TCPAddrはTCPエンドポイントのアドレスを表します。

func ResolveTCPAddr 

func ResolveTCPAddr(network, address string) (*TCPAddr, error)

ResolveTCPAddrはTCPエンドポイントのアドレスを返します。

ネットワークはTCPのネットワーク名である必要があります。

アドレスパラメータのホストがリテラルIPアドレスでない場合や、 ポートがリテラルのポート番号でない場合、ResolveTCPAddrは TCPエンドポイントのアドレスに解決します。 そうでなければ、アドレスをリテラルのIPアドレスとポート番号のペアとして解析します。 アドレスパラメータはホスト名を使用することもできますが、 ホスト名のIPアドレスの一つを最大で返すため、推奨されていません。

ネットワークとアドレスパラメータの詳細については、 Dial 関数の説明を参照してください。

func TCPAddrFromAddrPort added in v1.18.0 

func TCPAddrFromAddrPort(addr netip.AddrPort) *TCPAddr

TCPAddrFromAddrPortはaddrを TCPAddr として返します。もしaddrがIsValid()がfalseである場合、 返されるTCPAddrにはnilのIPフィールドが含まれ、アドレスファミリーに依存しない未指定のアドレスを示します。

func (*TCPAddr) AddrPort added in v1.18.0 

func (a *TCPAddr) AddrPort() netip.AddrPort

AddrPortは TCPAddr aを netip.AddrPort として返します。

もしa.Portがuint16に収まらない場合、静かに切り捨てられます。

もしaがnilの場合、ゼロ値が返されます。

func (*TCPAddr) Network 

func (a *TCPAddr) Network() string

Networkはアドレスのネットワーク名「tcp」を返します。

func (*TCPAddr) String 

func (a *TCPAddr) String() string

type TCPConn 

type TCPConn struct {
	// contains filtered or unexported fields
}

TCPConnはTCPネットワーク接続の Conn インターフェースの実装です。

func DialTCP 

func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)

DialTCPはTCPネットワークのための Dial のように振る舞います。

ネットワークはTCPネットワーク名でなければなりません。詳細についてはfunc Dialを参照してください。

laddrがnilの場合、自動的にローカルアドレスが選択されます。 raddrのIPフィールドがnilまたは未指定のIPアドレスの場合、ローカルシステムが使用されます。

func (*TCPConn) CloseRead 

func (c *TCPConn) CloseRead() error

CloseReadはTCP接続の読み込み側をシャットダウンします。 ほとんどの呼び出し元は、単にCloseを使用するだけで十分です。

func (*TCPConn) CloseWrite 

func (c *TCPConn) CloseWrite() error

CloseWrite は TCP 接続の書き込み側をシャットダウンします。 ほとんどの呼び出し元は Close を使用すべきです。

func (*TCPConn) MultipathTCP added in v1.21.0 

func (c *TCPConn) MultipathTCP() (bool, error)

MultipathTCPは、現在の接続がMPTCPを使用しているかどうかを報告します。

ホスト、他のピア、またはその間にあるデバイスによってMultipath TCPがサポートされていない場合、 意図的に/意図せずにフィルタリングされた場合、TCPへのフォールバックが行われます。 このメソッドは、MPTCPが使用されているかどうかを確認するために最善を尽くします。

Linuxでは、カーネルのバージョンがv5.16以上の場合、さらに条件が検証され、結果が改善されます。

func (*TCPConn) ReadFrom 

func (c *TCPConn) ReadFrom(r io.Reader) (int64, error)

ReadFrom は io.ReaderFrom の ReadFrom メソッドを実装します。

func (*TCPConn) SetKeepAlive 

func (c *TCPConn) SetKeepAlive(keepalive bool) error

SetKeepAliveは、オペレーティングシステムが接続に対して keep-aliveメッセージを送信するかどうかを設定します。

func (*TCPConn) SetKeepAliveConfig added in v1.23.0 

func (c *TCPConn) SetKeepAliveConfig(config KeepAliveConfig) error

SetKeepAliveConfig configures keep-alive messages sent by the operating system.

func (*TCPConn) SetKeepAlivePeriod added in v1.2.0 

func (c *TCPConn) SetKeepAlivePeriod(d time.Duration) error

SetKeepAlivePeriod sets the duration the connection needs to remain idle before TCP starts sending keepalive probes.

Note that calling this method on Windows prior to Windows 10 version 1709 will reset the KeepAliveInterval to the default system value, which is normally 1 second.

func (*TCPConn) SetLinger 

func (c *TCPConn) SetLinger(sec int) error

SetLingerは、まだ送信または確認待ちのデータがある接続に対してCloseの振る舞いを設定します。 sec < 0（デフォルト）の場合、オペレーティングシステムはバックグラウンドでデータの送信を完了します。 sec == 0の場合、オペレーティングシステムは未送信または確認待ちのデータを破棄します。 sec > 0の場合、データはsec < 0と同様にバックグラウンドで送信されます。 Linuxを含む一部のオペレーティングシステムでは、これによりCloseが全てのデータの送信または破棄が完了するまでブロックする場合があります。 sec秒経過後、未送信のデータは破棄される可能性があります。

func (*TCPConn) SetNoDelay 

func (c *TCPConn) SetNoDelay(noDelay bool) error

SetNoDelayは、パケットの送信を遅延させるかどうかを制御します。これにより、より少ないパケットで送信することが期待されます（Nagleのアルゴリズム）。デフォルト値はtrue（遅延なし）であり、Writeの後で可能な限りすぐにデータが送信されます。

func (*TCPConn) SyscallConn added in v1.9.0 

func (c *TCPConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは生のネットワーク接続を返します。 これは syscall.Conn インターフェースを実装しています。

func (*TCPConn) WriteTo added in v1.22.0 

func (c *TCPConn) WriteTo(w io.Writer) (int64, error)

WriteToは、io.WriterToのWriteToメソッドを実装します。

type TCPListener 

type TCPListener struct {
	// contains filtered or unexported fields
}

TCPListenerはTCPネットワークリスナーです。クライアントは通常、TCPを仮定する代わりに Listener 型の変数を使用するべきです。

func ListenTCP 

func ListenTCP(network string, laddr *TCPAddr) (*TCPListener, error)

ListenTCPはTCPネットワーク用の Listen のように機能します。

ネットワークはTCPネットワーク名でなければなりません。詳細はfunc Dialを参照してください。

laddrのIPフィールドがnilまたは未指定のIPアドレスの場合、ListenTCPはローカルシステムの利用可能なユニキャストおよびエニーキャストIPアドレスすべてでリスンします。 laddrのPortフィールドが0の場合、ポート番号は自動的に選択されます。

func (*TCPListener) Accept 

func (l *TCPListener) Accept() (Conn, error)

Accept implements the Accept method in the Listener interface; it waits for the next call and returns a generic Conn.

func (*TCPListener) AcceptTCP 

func (l *TCPListener) AcceptTCP() (*TCPConn, error)

AcceptTCPは次の着信呼び出しを受け入れ、新しい接続を返します。

func (*TCPListener) Addr 

func (l *TCPListener) Addr() Addr

Addrはリスナーのネットワークアドレス、*TCPAddr を返します。 返されるAddrはAddrのすべての呼び出しで共有されるため、 変更しないでください。

func (*TCPListener) Close 

func (l *TCPListener) Close() error

Close は TCP アドレスのリスニングを停止します。 既に受け入れられた接続は閉じられません。

func (*TCPListener) File 

func (l *TCPListener) File() (f *os.File, err error)

File は元の os.File のコピーを返します。 終了した後、f を閉じる責任は呼び出し元にあります。 l を閉じても f には影響を与えませんし、f を閉じても l には影響を与えません。

返された os.File のファイルディスクリプタは、接続のものとは異なります。 この複製を使用して元のもののプロパティを変更しようとすると、 望ましい効果が現れるかどうかは不明です。

func (*TCPListener) SetDeadline 

func (l *TCPListener) SetDeadline(t time.Time) error

SetDeadlineはリスナーに関連付けられた締め切りを設定します。 ゼロの時刻値は締め切りを無効にします。

func (*TCPListener) SyscallConn added in v1.10.0 

func (l *TCPListener) SyscallConn() (syscall.RawConn, error)

SyscallConn は生のネットワーク接続を返します。 これは syscall.Conn インターフェースを実装しています。

返された RawConn は Control の呼び出しのみをサポートします。 Read と Write はエラーを返します。

type UDPAddr 

type UDPAddr struct {
	IP   IP
	Port int
	Zone string
}

UDPAddrはUDPエンドポイントのアドレスを表します。

func ResolveUDPAddr 

func ResolveUDPAddr(network, address string) (*UDPAddr, error)

ResolveUDPAddr はUDPのエンドポイントのアドレスを返します。

ネットワークはUDPのネットワーク名である必要があります。

アドレスパラメータのホストがIPアドレスのリテラルでない場合、または ポート番号がリテラルのポート番号でない場合、ResolveUDPAddrは UDPエンドポイントのアドレスに解決します。 それ以外の場合は、アドレスをリテラルのIPアドレスとポート番号のペアとして解析します。 アドレスパラメータはホスト名を使用することもできますが、これは 推奨されません。なぜなら、ホスト名のIPアドレスのいずれか一つしか返さないからです。

ネットワークおよびアドレスパラメータの説明については、Dial 関数を参照してください。

func UDPAddrFromAddrPort added in v1.18.0 

func UDPAddrFromAddrPort(addr netip.AddrPort) *UDPAddr

UDPAddrFromAddrPortはaddrを UDPAddr として返します。 もしaddr.IsValid()がfalseであれば、返されるUDPAddrにはnilのIPフィールドが含まれ、 アドレスファミリーに依存しない未指定のアドレスを示します。

func (*UDPAddr) AddrPort added in v1.18.0 

func (a *UDPAddr) AddrPort() netip.AddrPort

AddrPortは UDPAddr aを netip.AddrPort として返します。

もしa.Portがuint16に収まらない場合、静かに切り捨てられます。

もしaがnilの場合、ゼロ値が返されます。

func (*UDPAddr) Network 

func (a *UDPAddr) Network() string

Networkはアドレスのネットワーク名、"udp"を返します。

func (*UDPAddr) String 

func (a *UDPAddr) String() string

type UDPConn 

type UDPConn struct {
	// contains filtered or unexported fields
}

UDPConnはUDPネットワーク接続の Conn および PacketConn インターフェースの実装です。

func DialUDP 

func DialUDP(network string, laddr, raddr *UDPAddr) (*UDPConn, error)

DialUDPはUDPネットワークのために Dial と同様の機能を提供します。

ネットワークはUDPネットワークの名前でなければならず、詳細については Dial 関数を参照してください。

もしladdrがnilの場合、自動的にローカルアドレスが選択されます。 もしraddrのIPフィールドがnilまたは未指定のIPアドレスの場合、ローカルシステムが仮定されます。

func ListenMulticastUDP 

func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)

ListenMulticastUDPは、UDPネットワークに対して ListenPacket と同様に動作しますが、 特定のネットワークインターフェース上のグループアドレスを受け取ります。

ネットワークはUDPネットワーク名でなければなりません。詳細については、Dial 関数を参照してください。

ListenMulticastUDPは、グループのマルチキャストIPアドレスを含む、 ローカルシステムのすべての利用可能なIPアドレスでリッスンします。 ifiがnilの場合、ListenMulticastUDPはシステムが割り当てた マルチキャストインターフェースを使用しますが、これは推奨されません。 割り当てはプラットフォームに依存し、場合によってはルーティング構成が必要になることがあるためです。 gaddrのPortフィールドが0の場合、ポート番号は自動的に選択されます。

ListenMulticastUDPは、シンプルで小さなアプリケーションのための便利な関数です。 一般的な用途には、golang.org/x/net/ipv4 および golang.org/x/net/ipv6 パッケージがあります。

ListenMulticastUDPは、IPPROTO_IPの下でIP_MULTICAST_LOOPソケットオプションを0に設定し、 マルチキャストパケットのループバックを無効にすることに注意してください。

func ListenUDP 

func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)

ListenUDPは、UDPネットワークに対して ListenPacket と同様の機能を提供します。

ネットワークはUDPネットワーク名でなければなりません。詳細については、Dial 関数を参照してください。

laddrのIPフィールドがnilまたは未指定のIPアドレスである場合、 ListenUDPは、マルチキャストIPアドレスを除く、ローカルシステムのすべての利用可能なIPアドレスでリスンします。 laddrのPortフィールドが0の場合、ポート番号が自動的に選択されます。

func (*UDPConn) ReadFrom 

func (c *UDPConn) ReadFrom(b []byte) (int, Addr, error)

ReadFrom は PacketConn の ReadFrom メソッドを実装します。

func (*UDPConn) ReadFromUDP 

func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)

ReadFromUDPは UDPConn.ReadFrom と同様の動作をしますが、UDPAddrを返します。

func (*UDPConn) ReadFromUDPAddrPort added in v1.18.0 

func (c *UDPConn) ReadFromUDPAddrPort(b []byte) (n int, addr netip.AddrPort, err error)

ReadFromUDPAddrPortはReadFromと同様の機能を提供しますが、netip.AddrPort を返します。

cが指定されていないアドレスにバインドされている場合、返される netip.AddrPortのアドレスは、IPv4-mapped IPv6アドレスの可能性があります。 IPv6のプレフィックスなしのアドレスを取得するには、netip.Addr.Unmap を使用してください。

func (*UDPConn) ReadMsgUDP added in v1.1.0 

func (c *UDPConn) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)

ReadMsgUDPは、cからメッセージを読み込み、ペイロードをbにコピーし、サイドバンドデータをoobにコピーします。bにコピーされたバイト数、oobにコピーされたバイト数、メッセージに設定されたフラグ、およびメッセージのソースアドレスを返します。

パッケージ golang.org/x/net/ipv4 および golang.org/x/net/ipv6 は、oob内のIPレベルのソケットオプションを操作するために使用できます。

func (*UDPConn) ReadMsgUDPAddrPort added in v1.18.0 

func (c *UDPConn) ReadMsgUDPAddrPort(b, oob []byte) (n, oobn, flags int, addr netip.AddrPort, err error)

ReadMsgUDPAddrPortは UDPConn.WriteTo と同様に動作しますが、UDPAddr の代わりに netip.AddrPort を返します。

func (*UDPConn) SyscallConn added in v1.9.0 

func (c *UDPConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは生のネットワーク接続を返します。 これは syscall.Conn インターフェースを実装しています。

func (*UDPConn) WriteMsgUDP added in v1.1.0 

func (c *UDPConn) WriteMsgUDP(b, oob []byte, addr *UDPAddr) (n, oobn int, err error)

WriteMsgUDPは、cが接続されていない場合はcを介してaddrにメッセージを書き込み、 cが接続されている場合はcのリモートアドレスにメッセージを書き込みます（その場合、 addrはnilでなければなりません）。ペイロードはbからコピーされ、関連する フラグデータはoobからコピーされます。ペイロードとフラグデータの書き込まれた バイト数を返します。

パッケージ golang.org/x/net/ipv4 および golang.org/x/net/ipv6 を使用して、 oob内のIPレベルのソケットオプションを操作することができます。

func (*UDPConn) WriteMsgUDPAddrPort added in v1.18.0 

func (c *UDPConn) WriteMsgUDPAddrPort(b, oob []byte, addr netip.AddrPort) (n, oobn int, err error)

WriteMsgUDPAddrPortは UDPConn.WriteMsgUDP と同様に動作しますが、UDPAddr の代わりに netip.AddrPort を受け取ります。

func (*UDPConn) WriteTo 

func (c *UDPConn) WriteTo(b []byte, addr Addr) (int, error)

WriteToは PacketConn のWriteToメソッドを実装します。

Example 
package main

import (
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
)

func main() {
	// Dialとは異なり、ListenPacketはピアとの関連付けなしで
	// 接続を作成します。
	conn, err := net.ListenPacket("udp", ":0")
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dst, err := net.ResolveUDPAddr("udp", "192.0.2.1:2000")
	if err != nil {
		log.Fatal(err)
	}

	// この接続は、指定したアドレスにデータを書き込むことができます。
	_, err = conn.WriteTo([]byte("data"), dst)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*UDPConn) WriteToUDP 

func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

WriteToUDPはWriteToと同様に動作しますが、UDPAddr を引数に取ります。

func (*UDPConn) WriteToUDPAddrPort added in v1.18.0 

func (c *UDPConn) WriteToUDPAddrPort(b []byte, addr netip.AddrPort) (int, error)

WriteToUDPAddrPortは、WriteToと同様に動作しますが、netip.AddrPort を受け取ります。

type UnixAddr 

type UnixAddr struct {
	Name string
	Net  string
}

UnixAddrはUnixドメインソケットエンドポイントのアドレスを表します。

func ResolveUnixAddr 

func ResolveUnixAddr(network, address string) (*UnixAddr, error)

ResolveUnixAddrは、Unixドメインソケットエンドポイントのアドレスを返します。

ネットワークはUnixのネットワーク名である必要があります。

ネットワークとアドレスのパラメータについての説明は、 Dial 関数を参照してください。

func (*UnixAddr) Network 

func (a *UnixAddr) Network() string

Networkはアドレスのネットワーク名を返します。"unix"、"unixgram"、または"unixpacket"です。

func (*UnixAddr) String 

func (a *UnixAddr) String() string

type UnixConn 

type UnixConn struct {
	// contains filtered or unexported fields
}

UnixConnは、Unixドメインソケットへの接続のための Conn インターフェースの実装です。

func DialUnix 

func DialUnix(network string, laddr, raddr *UnixAddr) (*UnixConn, error)

DialUnixは、Unixネットワークにおける Dial と同様の動作をします。

ネットワークはUnixネットワーク名でなければなりません。詳細についてはfunc Dialを参照してください。

laddrがnilでない場合、それは接続のローカルアドレスとして使用されます。

func ListenUnixgram 

func ListenUnixgram(network string, laddr *UnixAddr) (*UnixConn, error)

ListenUnixgramはUnixネットワーク用の ListenPacket のように動作します。

ネットワークは"unixgram"である必要があります。

func (*UnixConn) CloseRead added in v1.1.0 

func (c *UnixConn) CloseRead() error

CloseReadは、Unixドメイン接続の読み込み側をシャットダウンします。 ほとんどの呼び出し元は、単にCloseを使用すべきです。

func (*UnixConn) CloseWrite added in v1.1.0 

func (c *UnixConn) CloseWrite() error

CloseWriteはUnixドメイン接続の書き込み側をシャットダウンします。 ほとんどの呼び出し元は、単にCloseを使用するだけで十分です。

func (*UnixConn) ReadFrom 

func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error)

ReadFromは PacketConn のReadFromメソッドを実装します。

func (*UnixConn) ReadFromUnix 

func (c *UnixConn) ReadFromUnix(b []byte) (int, *UnixAddr, error)

ReadFromUnixは、UnixConn.ReadFrom と同様に動作しますが、UnixAddr を返します。

func (*UnixConn) ReadMsgUnix 

func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error)

ReadMsgUnix はcからメッセージを読み取り、そのペイロードをbに、 関連する帯域外データをoobにコピーします。bにコピーされたバイト数、oobに コピーされたバイト数、メッセージに設定されたフラグ、およびメッセージの 送信元アドレスを返します。

なお、len(b) == 0 かつ len(oob) > 0 の場合、この関数は依然として接続から 1バイトを読み取り(および破棄)ます。

func (*UnixConn) SyscallConn added in v1.9.0 

func (c *UnixConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは生のネットワーク接続を返します。 これは syscall.Conn インターフェースを実装しています。

func (*UnixConn) WriteMsgUnix 

func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error)

WriteMsgUnixは、ペイロードのbと関連するオーバンドデータのoobから、cを介してaddrにメッセージを書き込みます。書き込まれたペイロードとオーバンドバイトの数を返します。 注意：len(b) == 0かつlen(oob) > 0の場合、この関数は依然として接続に1バイトを書き込みます。

func (*UnixConn) WriteTo 

func (c *UnixConn) WriteTo(b []byte, addr Addr) (int, error)

WriteToは PacketConn のWriteToメソッドを実装します。

func (*UnixConn) WriteToUnix 

func (c *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (int, error)

WriteToUnixは UnixConn.WriteTo と同様に動作しますが、UnixAddr を取ります。

type UnixListener 

type UnixListener struct {
	// contains filtered or unexported fields
}

UnixListenerはUnixドメインソケットのリスナーです。クライアントは通常、Unixドメインソケットを想定せずに、Listener の型の変数を使用するべきです。

func ListenUnix 

func ListenUnix(network string, laddr *UnixAddr) (*UnixListener, error)

ListenUnixはUnixネットワーク向けの Listen のように機能します。

ネットワークは「unix」または「unixpacket」である必要があります。

func (*UnixListener) Accept 

func (l *UnixListener) Accept() (Conn, error)

Acceptは Listener インターフェースのAcceptメソッドを実装します。 返される接続は *UnixConn 型です。

func (*UnixListener) AcceptUnix 

func (l *UnixListener) AcceptUnix() (*UnixConn, error)

AcceptUnixは次の着信呼び出しを受け入れ、新しい接続を返します。

func (*UnixListener) Addr 

func (l *UnixListener) Addr() Addr

Addrはリスナーのネットワークアドレスを返します。 返されるAddrは、Addrのすべての呼び出しで共有されるため、 変更しないでください。

func (*UnixListener) Close 

func (l *UnixListener) Close() error

CloseはUnixアドレス上でのリスニングを停止します。既に受け付けた接続は閉じません。

func (*UnixListener) File 

func (l *UnixListener) File() (f *os.File, err error)

File は基になる os.File のコピーを返します。 終了時には、f を閉じるのは呼び出し元の責任です。 l を閉じても f に影響を与えず、f を閉じても l に影響を与えません。

返された os.File のファイルディスクリプタは、接続のものとは異なります。 この複製を使用して元のもののプロパティを変更しようとしても、望ましい効果があるかどうかはわかりません。

func (*UnixListener) SetDeadline 

func (l *UnixListener) SetDeadline(t time.Time) error

SetDeadlineはリスナーと関連付けられた締め切りを設定します。 ゼロの時間値は締め切りを無効にします。

func (*UnixListener) SetUnlinkOnClose added in v1.8.0 

func (l *UnixListener) SetUnlinkOnClose(unlink bool)

SetUnlinkOnCloseは、リスナーがクローズされたときに基礎となるソケットファイルを ファイルシステムから削除するかどうかを設定します。

デフォルトの動作では、ソケットファイルは、package netによって作成された場合にのみ アンリンクされます。つまり、リスナーや基礎となるソケットファイルが ListenまたはListenUnixの呼び出しによって作成された場合、デフォルトでは リスナーをクローズするとソケットファイルが削除されます。 ただし、リスナーが既存のソケットファイルを使用するためにFileListenerを呼び出して作成された場合、 デフォルトではリスナーをクローズしてもソケットファイルは削除されません。

func (*UnixListener) SyscallConn added in v1.10.0 

func (l *UnixListener) SyscallConn() (syscall.RawConn, error)

SyscallConnは、生のネットワーク接続を返します。 これは syscall.Conn インターフェースを実装します。

返されるRawConnは、Controlの呼び出しのみをサポートします。 ReadとWriteはエラーを返します。

type UnknownNetworkError 

type UnknownNetworkError string

func (UnknownNetworkError) Error 

func (e UnknownNetworkError) Error() string

func (UnknownNetworkError) Temporary 

func (e UnknownNetworkError) Temporary() bool

func (UnknownNetworkError) Timeout 

func (e UnknownNetworkError) Timeout() bool

Source Files

View all Source files

Directories

Path Synopsis
httpパッケージは HTTP クライアントとサーバーの実装を提供します。
 httpパッケージは HTTP クライアントとサーバーの実装を提供します。
cgi
cgiパッケージは、RFC 3875で指定されているCGI（Common Gateway Interface）を実装しています。
 cgiパッケージは、RFC 3875で指定されているCGI（Common Gateway Interface）を実装しています。
cookiejar
cookiejar パッケージはメモリ内で RFC 6265 に準拠した http.CookieJar を実装します。
 cookiejar パッケージはメモリ内で RFC 6265 に準拠した http.CookieJar を実装します。
fcgi
fcgiパッケージはFastCGIプロトコルを実装します。
 fcgiパッケージはFastCGIプロトコルを実装します。
httptest
httptestパッケージは、HTTPテストのためのユーティリティを提供します。
 httptestパッケージは、HTTPテストのためのユーティリティを提供します。
httptrace
httptraceパッケージは、HTTPクライアントリクエスト内のイベントをトレースするメカニズムを提供します。
 httptraceパッケージは、HTTPクライアントリクエスト内のイベントをトレースするメカニズムを提供します。
httputil
httputilパッケージは、net/httpパッケージにある一般的なものと補完するHTTPユーティリティ関数を提供します。
 httputilパッケージは、net/httpパッケージにある一般的なものと補完するHTTPユーティリティ関数を提供します。
internal
Package internal contains HTTP internals shared by net/http and net/http/httputil.
 Package internal contains HTTP internals shared by net/http and net/http/httputil.
internal/ascii
internal/testcert
Package testcert contains a test-only localhost certificate.
 Package testcert contains a test-only localhost certificate.
pprof
pprofパッケージは、pprof可視化ツールが期待する形式で実行時プロファイリングデータをHTTPサーバー経由で提供します。
 pprofパッケージは、pprof可視化ツールが期待する形式で実行時プロファイリングデータをHTTPサーバー経由で提供します。
internal
cgotest
socktest
Package socktest provides utilities for socket testing.
 Package socktest provides utilities for socket testing.
mailパッケージは、メールメッセージの解析を実装しています。
 mailパッケージは、メールメッセージの解析を実装しています。
netipパッケージは、小さな値型であるIPアドレス型を定義します。
 netipパッケージは、小さな値型であるIPアドレス型を定義します。
internal/intern
rpc
rpcパッケージは、オブジェクトのエクスポートされたメソッドに、ネットワークやその他のI/O接続を通じてアクセスする機能を提供します。
 rpcパッケージは、オブジェクトのエクスポートされたメソッドに、ネットワークやその他のI/O接続を通じてアクセスする機能を提供します。
jsonrpc
jsonrpcパッケージはRPCパッケージのためのJSON-RPC 1.0のClientCodecとServerCodecを実装します。
 jsonrpcパッケージはRPCパッケージのためのJSON-RPC 1.0のClientCodecとServerCodecを実装します。
smtp パッケージは RFC 5321 で定義されている Simple Mail Transfer Protocol を実装しています。
 smtp パッケージは RFC 5321 で定義されている Simple Mail Transfer Protocol を実装しています。
textprotoパッケージは、HTTP、NNTP、およびSMTPのスタイルでテキストベースのリクエスト/レスポンスプロトコルの汎用サポートを実装します。
 textprotoパッケージは、HTTP、NNTP、およびSMTPのスタイルでテキストベースのリクエスト/レスポンスプロトコルの汎用サポートを実装します。
urlパッケージはURLを解析し、クエリのエスケープを実装します。
 urlパッケージはURLを解析し、クエリのエスケープを実装します。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.